From 2860c34b0b52fc10d0075a0778fd0ddcca68065e Mon Sep 17 00:00:00 2001
From: Martin Quinson <martin.quinson@loria.fr>
Date: Sun, 4 Dec 2016 21:23:15 +0100
Subject: [PATCH] cleanups in the dict and dynar tests

---
 src/xbt/dict.cpp  | 148 ++++++++++++++++++++--------------------------
 src/xbt/dynar.cpp |  65 ++++++++++----------
 2 files changed, 95 insertions(+), 118 deletions(-)

diff --git a/src/xbt/dict.cpp b/src/xbt/dict.cpp
index 6141bc672a..c6827205e4 100644
--- a/src/xbt/dict.cpp
+++ b/src/xbt/dict.cpp
@@ -583,7 +583,7 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_dict);
 
 XBT_TEST_SUITE("dict", "Dict data container");
 
-static void debuged_add_ext(xbt_dict_t head, const char* key, const char* data_to_fill)
+static void debugged_add_ext(xbt_dict_t head, const char* key, const char* data_to_fill)
 {
   char *data = xbt_strdup(data_to_fill);
 
@@ -596,25 +596,25 @@ static void debuged_add_ext(xbt_dict_t head, const char* key, const char* data_t
   }
 }
 
-static void debuged_add(xbt_dict_t head, const char* key)
+static void debugged_add(xbt_dict_t head, const char* key)
 {
-  debuged_add_ext(head, key, key);
+  debugged_add_ext(head, key, key);
 }
 
-static void fill(xbt_dict_t* head)
+static xbt_dict_t new_fixture(void)
 {
   xbt_test_add("Fill in the dictionnary");
 
-  *head = xbt_dict_new_homogeneous(&free);
-  debuged_add(*head, "12");
-  debuged_add(*head, "12a");
-  debuged_add(*head, "12b");
-  debuged_add(*head, "123");
-  debuged_add(*head, "123456");
-  /* Child becomes child of what to add */
-  debuged_add(*head, "1234");
-  /* Need of common ancestor */
-  debuged_add(*head, "123457");
+  xbt_dict_t head = xbt_dict_new_homogeneous(&free);
+  debugged_add(head, "12");
+  debugged_add(head, "12a");
+  debugged_add(head, "12b");
+  debugged_add(head, "123");
+  debugged_add(head, "123456");
+  debugged_add(head, "1234");
+  debugged_add(head, "123457");
+
+  return head;
 }
 
 static void search_ext(xbt_dict_t head, const char *key, const char *data)
@@ -637,7 +637,7 @@ static void search(xbt_dict_t head, const char *key)
   search_ext(head, key, key);
 }
 
-static void debuged_remove(xbt_dict_t head, const char *key)
+static void debugged_remove(xbt_dict_t head, const char* key)
 {
   xbt_test_add("Remove '%s'", key);
   xbt_dict_remove(head, key);
@@ -680,14 +680,13 @@ static void search_not_found(xbt_dict_t head, const char *data)
 
 static void count(xbt_dict_t dict, int length)
 {
+  xbt_test_add("Count elements (expecting %d)", length);
+  xbt_test_assert(xbt_dict_length(dict) == length, "Announced length(%d) != %d.", xbt_dict_length(dict), length);
+
   xbt_dict_cursor_t cursor;
   char *key;
   void *data;
   int effective = 0;
-
-  xbt_test_add("Count elements (expecting %d)", length);
-  xbt_test_assert(xbt_dict_length(dict) == length, "Announced length(%d) != %d.", xbt_dict_length(dict), length);
-
   xbt_dict_foreach(dict, cursor, key, data)
       effective++;
 
@@ -698,7 +697,6 @@ static void count_check_get_key(xbt_dict_t dict, int length)
 {
   xbt_dict_cursor_t cursor;
   char *key;
-  XBT_ATTRIB_UNUSED char *key2;
   void *data;
   int effective = 0;
 
@@ -707,27 +705,23 @@ static void count_check_get_key(xbt_dict_t dict, int length)
 
   xbt_dict_foreach(dict, cursor, key, data) {
     effective++;
-    key2 = xbt_dict_get_key(dict, data);
+    char* key2 = xbt_dict_get_key(dict, data);
     xbt_assert(!strcmp(key, key2), "The data was registered under %s instead of %s as expected", key2, key);
   }
 
   xbt_test_assert(effective == length, "Effective length(%d) != %d.", effective, length);
 }
 
-xbt_ex_t e;
-xbt_dict_t head = nullptr;
-char *data;
-
-static void basic_test(void)
+XBT_TEST_UNIT("basic", test_dict_basic, "Basic usage: change, retrieve and traverse homogeneous dicts")
 {
   xbt_test_add("Traversal the null dictionary");
-  traverse(head);
+  traverse(nullptr);
 
   xbt_test_add("Traversal and search the empty dictionary");
-  head = xbt_dict_new_homogeneous(&free);
+  xbt_dict_t head = xbt_dict_new_homogeneous(&free);
   traverse(head);
   try {
-    debuged_remove(head, "12346");
+    debugged_remove(head, "12346");
   }
   catch(xbt_ex& e) {
     if (e.category != not_found_error)
@@ -736,12 +730,12 @@ static void basic_test(void)
   xbt_dict_free(&head);
 
   xbt_test_add("Traverse the full dictionary");
-  fill(&head);
+  head = new_fixture();
   count_check_get_key(head, 7);
 
-  debuged_add_ext(head, "toto", "tutu");
+  debugged_add_ext(head, "toto", "tutu");
   search_ext(head, "toto", "tutu");
-  debuged_remove(head, "toto");
+  debugged_remove(head, "toto");
 
   search(head, "12a");
   traverse(head);
@@ -751,7 +745,7 @@ static void basic_test(void)
   xbt_dict_free(&head);
 
   /* CHANGING */
-  fill(&head);
+  head = new_fixture();
   count_check_get_key(head, 7);
   xbt_test_add("Change 123 to 'Changed 123'");
   xbt_dict_set(head, "123", xbt_strdup("Changed 123"), nullptr);
@@ -774,7 +768,7 @@ static void basic_test(void)
 
   /* RETRIEVE */
   xbt_test_add("Search 123");
-  data = (char*) xbt_dict_get(head, "123");
+  char* data = (char*)xbt_dict_get(head, "123");
   xbt_test_assert(data);
   xbt_test_assert(!strcmp("123", data));
 
@@ -802,18 +796,13 @@ static void basic_test(void)
   traverse(head);
 }
 
-XBT_TEST_UNIT("basic_homogeneous", test_dict_basic_homogeneous, "Basic usage: change, retrieve, traverse: homogeneous dict")
+XBT_TEST_UNIT("remove_homogeneous", test_dict_remove, "Removing some values from homogeneous dicts")
 {
-  basic_test();
-}
-
-static void remove_test()
-{
-  fill(&head);
+  xbt_dict_t head = new_fixture();
   count(head, 7);
   xbt_test_add("Remove non existing data");
   try {
-    debuged_remove(head, "Does not exist");
+    debugged_remove(head, "Does not exist");
   }
   catch(xbt_ex& e) {
     if (e.category != not_found_error)
@@ -824,35 +813,35 @@ static void remove_test()
   xbt_dict_free(&head);
 
   xbt_test_add("Remove each data manually (traversing the resulting dictionary each time)");
-  fill(&head);
-  debuged_remove(head, "12a");
+  head = new_fixture();
+  debugged_remove(head, "12a");
   traverse(head);
   count(head, 6);
-  debuged_remove(head, "12b");
+  debugged_remove(head, "12b");
   traverse(head);
   count(head, 5);
-  debuged_remove(head, "12");
+  debugged_remove(head, "12");
   traverse(head);
   count(head, 4);
-  debuged_remove(head, "123456");
+  debugged_remove(head, "123456");
   traverse(head);
   count(head, 3);
   try {
-    debuged_remove(head, "12346");
+    debugged_remove(head, "12346");
   }
   catch(xbt_ex& e) {
     if (e.category != not_found_error)
       xbt_test_exception(e);
     traverse(head);
   }
-  debuged_remove(head, "1234");
+  debugged_remove(head, "1234");
   traverse(head);
-  debuged_remove(head, "123457");
+  debugged_remove(head, "123457");
   traverse(head);
-  debuged_remove(head, "123");
+  debugged_remove(head, "123");
   traverse(head);
   try {
-    debuged_remove(head, "12346");
+    debugged_remove(head, "12346");
   }
   catch(xbt_ex& e) {
     if (e.category != not_found_error)
@@ -862,7 +851,7 @@ static void remove_test()
 
   xbt_test_add("Free dict, create new fresh one, and then reset the dict");
   xbt_dict_free(&head);
-  fill(&head);
+  head = new_fixture();
   xbt_dict_reset(head);
   count(head, 0);
   traverse(head);
@@ -872,14 +861,9 @@ static void remove_test()
   xbt_dict_free(&head);
 }
 
-XBT_TEST_UNIT("remove_homogeneous", test_dict_remove_homogeneous, "Removing some values: homogeneous dict")
-{
-  remove_test();
-}
-
 XBT_TEST_UNIT("nulldata", test_dict_nulldata, "nullptr data management")
 {
-  fill(&head);
+  xbt_dict_t head = new_fixture();
 
   xbt_test_add("Store nullptr under 'null'");
   xbt_dict_set(head, "null", nullptr, nullptr);
@@ -890,6 +874,7 @@ XBT_TEST_UNIT("nulldata", test_dict_nulldata, "nullptr data management")
     xbt_dict_cursor_t cursor = nullptr;
     char *key;
     int found = 0;
+    char* data;
 
     xbt_dict_foreach(head, cursor, key, data) {
       if (!key || !data || strcmp(key, data)) {
@@ -923,26 +908,22 @@ static int countelems(xbt_dict_t head)
 
 XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
 {
-  xbt_dict_t head = nullptr;
-  int i, j, k;
-  char *key;
-
   srand((unsigned int) time(nullptr));
 
-  for (i = 0; i < 10; i++) {
+  for (int i = 0; i < 10; i++) {
     xbt_test_add("CRASH test number %d (%d to go)", i + 1, 10 - i - 1);
     xbt_test_log("Fill the struct, count its elems and frees the structure");
     xbt_test_log("using 1000 elements with %d chars long randomized keys.", SIZEOFKEY);
-    head = xbt_dict_new_homogeneous(free);
+    xbt_dict_t head = xbt_dict_new_homogeneous(free);
     /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */
-    for (j = 0; j < 1000; j++) {
-      char *data = nullptr;
-      key = (char*) xbt_malloc(SIZEOFKEY);
+    for (int j = 0; j < 1000; j++) {
+      char* data = nullptr;
+      char* key  = (char*)xbt_malloc(SIZEOFKEY);
 
       do {
-        for (k = 0; k < SIZEOFKEY - 1; k++)
+        for (int k         = 0; k < SIZEOFKEY - 1; k++)
           key[k] = rand() % ('z' - 'a') + 'a';
-        key[k] = '\0';
+        key[SIZEOFKEY - 1] = '\0';
         /*      printf("[%d %s]\n",j,key); */
         data = (char*) xbt_dict_get_or_null(head, key);
       } while (data != nullptr);
@@ -959,11 +940,11 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
     xbt_dict_free(&head);
   }
 
-  head = xbt_dict_new_homogeneous(&free);
+  xbt_dict_t head = xbt_dict_new_homogeneous(&free);
   xbt_test_add("Fill %d elements, with keys being the number of element", NB_ELM);
-  for (j = 0; j < NB_ELM; j++) {
+  for (int j = 0; j < NB_ELM; j++) {
     /* if (!(j%1000)) { printf("."); fflush(stdout); } */
-    key = (char*) xbt_malloc(10);
+    char* key = (char*)xbt_malloc(10);
 
     snprintf(key,10, "%d", j);
     xbt_dict_set(head, key, key, nullptr);
@@ -971,17 +952,15 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
   /*xbt_dict_dump(head,(void (*)(void*))&printf); */
 
   xbt_test_add("Count the elements (retrieving the key and data for each)");
-  i = countelems(head);
-  xbt_test_log("There is %d elements", i);
+  xbt_test_log("There is %d elements", countelems(head));
 
   xbt_test_add("Search my %d elements 20 times", NB_ELM);
-  key = (char*) xbt_malloc(10);
-  for (i = 0; i < 20; i++) {
-    void *data;
+  char* key = (char*)xbt_malloc(10);
+  for (int i = 0; i < 20; i++) {
     /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */
-    for (j = 0; j < NB_ELM; j++) {
+    for (int j = 0; j < NB_ELM; j++) {
       snprintf(key,10, "%d", j);
-      data = xbt_dict_get(head, key);
+      void* data = xbt_dict_get(head, key);
       xbt_test_assert(!strcmp(key, (char *) data), "with get, key=%s != data=%s", key, (char *) data);
       data = xbt_dict_get_ext(head, key, strlen(key));
       xbt_test_assert(!strcmp(key, (char *) data), "with get_ext, key=%s != data=%s", key, (char *) data);
@@ -991,14 +970,14 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
 
   xbt_test_add("Remove my %d elements", NB_ELM);
   key = (char*) xbt_malloc(10);
-  for (j = 0; j < NB_ELM; j++) {
+  for (int j = 0; j < NB_ELM; j++) {
     /* if (!(j%10000)) printf("."); fflush(stdout); */
     snprintf(key,10, "%d", j);
     xbt_dict_remove(head, key);
   }
   free(key);
 
-  xbt_test_add("Free the structure (twice)");
+  xbt_test_add("Free the object (twice)");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 }
@@ -1009,13 +988,12 @@ XBT_TEST_UNIT("ext", test_dict_int, "Test dictionnary with int keys")
   int count = 500;
 
   xbt_test_add("Insert elements");
-  int i;
-  for (i = 0; i < count; ++i)
+  for (int i = 0; i < count; ++i)
     xbt_dict_set_ext(dict, (char*) &i, sizeof(i), (void*) (intptr_t) i, nullptr);
   xbt_test_assert(xbt_dict_size(dict) == (unsigned) count, "Bad number of elements in the dictionnary");
 
   xbt_test_add("Check elements");
-  for (i = 0; i < count; ++i) {
+  for (int i = 0; i < count; ++i) {
     int res = (int) (intptr_t) xbt_dict_get_ext(dict, (char*) &i, sizeof(i));
     xbt_test_assert(xbt_dict_size(dict) == (unsigned) count, "Unexpected value at index %i, expected %i but was %i", i, i, res);
   }
diff --git a/src/xbt/dynar.cpp b/src/xbt/dynar.cpp
index 0ceb8cc948..62a607ee40 100644
--- a/src/xbt/dynar.cpp
+++ b/src/xbt/dynar.cpp
@@ -720,13 +720,12 @@ XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_dyn);
 XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
 {
   /* Vars_decl [doxygen cruft] */
-  xbt_dynar_t d;
-  int i, cpt;
+  int i;
   unsigned int cursor;
   int *iptr;
 
   xbt_test_add("==== Traverse the empty dynar");
-  d = xbt_dynar_new(sizeof(int), nullptr);
+  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");
   }
@@ -738,7 +737,7 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   /* Populate_ints [doxygen cruft] */
   /* 1. Populate the dynar */
   d = xbt_dynar_new(sizeof(int), nullptr);
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  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));
@@ -747,23 +746,25 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
   /* 2. Traverse manually the dynar */
   for (cursor = 0; cursor < NB_ELEM; cursor++) {
     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, cpt);
+    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 (cpt = 0; cpt < NB_ELEM; cpt++)
+  for (int cpt = 0; cpt < NB_ELEM; cpt++)
     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
 
-  for (cpt = 0; cpt < NB_ELEM; cpt++)
+  for (int cpt = 0; cpt < NB_ELEM; cpt++)
     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
   /*     xbt_dynar_set(d,cpt,&cpt); */
 
-  for (cpt = 0; cpt < NB_ELEM; cpt++)
+  for (int cpt = 0; cpt < NB_ELEM; cpt++)
     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
 
   cpt = 0;
@@ -775,7 +776,7 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
 
   /* shifting [doxygen cruft] */
   /* 4. Shift all the values */
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  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));
@@ -802,11 +803,11 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
 
   xbt_test_add("==== Unshift/pop %d int", NB_ELEM);
   d = xbt_dynar_new(sizeof(int), nullptr);
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  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 (cpt = 0; cpt < NB_ELEM; cpt++) {
+  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));
@@ -865,29 +866,29 @@ XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dyn
 {
   xbt_dynar_t d = xbt_dynar_new(sizeof(unsigned int), nullptr);
   unsigned int cursor;
-  int cpt;
 
   xbt_test_add("==== Insert %d int, traverse them, remove them",NB_ELEM);
   /* Populate_ints [doxygen cruft] */
   /* 1. Populate the dynar */
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  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 (cpt = 0; cpt < NB_ELEM; cpt++)
+  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 (cpt = 0; cpt < NB_ELEM; 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);
@@ -899,7 +900,7 @@ XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dyn
   /* ********************* */
   xbt_test_add("==== Insert %d int in reverse order, traverse them, remove them",NB_ELEM);
   d = xbt_dynar_new(sizeof(int), nullptr);
-  for (cpt = NB_ELEM-1; cpt >=0; cpt--) {
+  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));
   }
@@ -1025,14 +1026,12 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
 /*******************************************************************************/
 XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
 {
-  xbt_dynar_t d;
-  int cpt;
   unsigned int iter;
   char buf[1024];
   char *s1, *s2;
 
   xbt_test_add("==== Traverse the empty dynar");
-  d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
+  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");
   }
@@ -1044,27 +1043,27 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
   /* Populate_str [doxygen cruft] */
   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
   /* 1. Populate the dynar */
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_push(d, &s1);
   }
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_replace(d, cpt, &s1);
   }
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_replace(d, cpt, &s1);
   }
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_replace(d, cpt, &s1);
   }
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_shift(d, &s2);
     xbt_test_assert(!strcmp(buf, s2), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s2);
@@ -1076,7 +1075,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
 
   xbt_test_add("==== Unshift, traverse and pop %d strings", NB_ELEM);
   d = xbt_dynar_new(sizeof(char **), &xbt_free_ref);
-  for (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_unshift(d, &s1);
@@ -1087,7 +1086,7 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
     xbt_test_assert(!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 (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_pop(d, &s2);
     xbt_test_assert(!strcmp(buf, s2), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s2);
@@ -1100,32 +1099,32 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
 
   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 (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_push(d, &s1);
   }
-  for (cpt = 0; cpt < NB_ELEM / 5; cpt++) {
+  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 (cpt = 0; cpt < NB_ELEM / 2; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM / 2; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_shift(d, &s2);
     xbt_test_assert(!strcmp(buf, s2),
                      "The retrieved value is not the same than the injected one at the begining (%s!=%s)", buf, s2);
     free(s2);
   }
-  for (cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) {
+  for (int cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_shift(d, &s2);
     xbt_test_assert(!strcmp(buf, s2),
                      "The retrieved value is not the same than the injected one in the middle (%s!=%s)", buf, s2);
     free(s2);
   }
-  for (cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) {
+  for (int cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     xbt_dynar_shift(d, &s2);
     xbt_test_assert(!strcmp(buf, s2), "The retrieved value is not the same than the injected one at the end (%s!=%s)",
@@ -1138,12 +1137,12 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
 
   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 (cpt = 0; cpt < NB_ELEM; cpt++) {
+  for (int cpt = 0; cpt < NB_ELEM; cpt++) {
     snprintf(buf,1023, "%d", cpt);
     s1 = xbt_strdup(buf);
     xbt_dynar_push(d, &s1);
   }
-  for (cpt = 2 * (NB_ELEM / 5); cpt < 4 * (NB_ELEM / 5); cpt++) {
+  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(!strcmp(buf, s2), "Remove a bad value. Got %s, expected %s", s2, buf);
-- 
2.20.1