[sonar] Split declarations, unshadow variables.

diff --git a/src/mc/sosp/PageStore_test.cpp b/src/mc/sosp/PageStore_test.cpp
index 791bf55..b4f7ea9 100644 (file)
--- a/src/mc/sosp/PageStore_test.cpp
+++ b/src/mc/sosp/PageStore_test.cpp
@@ -36,7 +36,7 @@ public:
   static void unref_pages();
   static void reallocate_page();
 
   static void unref_pages();
   static void reallocate_page();
 

-  static void new_content(void* data, std::size_t size);
+  static void new_content(void* buf, std::size_t size);

 };
 
 // static member datat initialization
 };
 
 // static member datat initialization


@@ -99,10 +99,10 @@ void helper_tests::reallocate_page()
   REQUIRE(store->size() == 2);
 }
 
   REQUIRE(store->size() == 2);
 }
 

-void helper_tests::new_content(void* data, std::size_t size)
+void helper_tests::new_content(void* buf, std::size_t size)

 {
   value++;
 {
   value++;

-  ::memset(data, value, size);
+  ::memset(buf, value, size);

 }
 
 TEST_CASE("MC page store, used during checkpoint", "MC::PageStore")
 }
 
 TEST_CASE("MC page store, used during checkpoint", "MC::PageStore")

diff --git a/src/xbt/dynar_test.cpp b/src/xbt/dynar_test.cpp
index b429ec5..87bd5fe 100644 (file)
--- a/src/xbt/dynar_test.cpp
+++ b/src/xbt/dynar_test.cpp
@@ -18,12 +18,12 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
   SECTION("Dynars of integers")
   {
     /* Vars_decl [doxygen cruft] */
   SECTION("Dynars of integers")
   {
     /* Vars_decl [doxygen cruft] */

-    int i;
+    int cpt;

     unsigned int cursor;
 
     INFO("==== Traverse the empty dynar");
     xbt_dynar_t d = xbt_dynar_new(sizeof(int), nullptr);
     unsigned int cursor;
 
     INFO("==== Traverse the empty dynar");
     xbt_dynar_t d = xbt_dynar_new(sizeof(int), nullptr);

-    xbt_dynar_foreach (d, cursor, i) {
+    xbt_dynar_foreach (d, cursor, cpt) {

       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_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 */


@@ -34,59 +34,59 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
     /* Populate_ints [doxygen cruft] */
     /* 1. Populate the dynar */
     d = xbt_dynar_new(sizeof(int), nullptr);
     /* 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 */
+    for (int i = 0; i < NB_ELEM; i++) {
+      xbt_dynar_push_as(d, int, i); /* This is faster (and possible only with scalars) */
+      /* xbt_dynar_push(d, &i);      This would also work */

     }
 
     /* 2. Traverse manually the dynar */
     }
 
     /* 2. Traverse manually the dynar */

-    for (cursor = 0; cursor < NB_ELEM; cursor++) {
-      int* iptr = (int*)xbt_dynar_get_ptr(d, cursor);
-      REQUIRE(cursor == (unsigned int)*iptr); // The retrieved value is not the same than the injected one
+    for (int i = 0; i < NB_ELEM; i++) {
+      int* iptr = (int*)xbt_dynar_get_ptr(d, i);
+      REQUIRE(i == *iptr); // The retrieved value is not the same than the injected one

     }
 
     /* 3. Traverse the dynar using the neat macro to that extend */
     }
 
     /* 3. Traverse the dynar using the neat macro to that extend */

-    int cpt;

     xbt_dynar_foreach (d, cursor, cpt) {
       REQUIRE(cursor == (unsigned int)cpt); // The retrieved value is not the same than the injected one
     }
     /* end_of_traversal */
 
     xbt_dynar_foreach (d, cursor, cpt) {
       REQUIRE(cursor == (unsigned int)cpt); // The retrieved value is not the same than the injected one
     }
     /* end_of_traversal */
 

-    for (int cpt = 0; cpt < NB_ELEM; cpt++)
-      *(int*)xbt_dynar_get_ptr(d, cpt) = cpt;
+    for (int i = 0; i < NB_ELEM; i++)
+      *(int*)xbt_dynar_get_ptr(d, i) = i;

 
 

-    for (int cpt = 0; cpt < NB_ELEM; cpt++)
-      *(int*)xbt_dynar_get_ptr(d, cpt) = cpt;
+    for (int i = 0; i < NB_ELEM; i++)
+      *(int*)xbt_dynar_get_ptr(d, i) = i;

 
 

-    for (int cpt = 0; cpt < NB_ELEM; cpt++)
-      *(int*)xbt_dynar_get_ptr(d, cpt) = cpt;
+    for (int i = 0; i < NB_ELEM; i++)
+      *(int*)xbt_dynar_get_ptr(d, i) = i;

 
 

-    cpt = 0;
-    xbt_dynar_foreach (d, cursor, i) {
-      REQUIRE(i == cpt); // The retrieved value is not the same than the injected one
-      cpt++;
+    int count = 0;
+    xbt_dynar_foreach (d, cursor, cpt) {
+      REQUIRE(cpt == count); // The retrieved value is not the same than the injected one
+      count++;

     }
     }

-    REQUIRE(cpt == NB_ELEM); // Cannot retrieve all my values. cpt is the last one I got
+    REQUIRE(count == NB_ELEM); // Cannot retrieve all my values. cpt is the last one I got

 
     /* shifting [doxygen cruft] */
     /* 4. Shift all the values */
 
     /* shifting [doxygen cruft] */
     /* 4. Shift all the values */

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
-      xbt_dynar_shift(d, &i);
-      REQUIRE(i == cpt); // The retrieved value is not the same than the injected one
+    for (int i = 0; i < NB_ELEM; i++) {
+      int val;
+      xbt_dynar_shift(d, &val);
+      REQUIRE(val == i); // The retrieved value is not the same than the injected one

     }
     REQUIRE(xbt_dynar_is_empty(d));
 
     }
     REQUIRE(xbt_dynar_is_empty(d));
 

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
+    for (int i = 0; i < NB_ELEM; i++) {

       xbt_dynar_push_as(d, int, -1);
     }
     int* pi;
     xbt_dynar_foreach_ptr(d, cursor, pi) { *pi = 0; }
       xbt_dynar_push_as(d, int, -1);
     }
     int* pi;
     xbt_dynar_foreach_ptr(d, cursor, pi) { *pi = 0; }

-    xbt_dynar_foreach (d, cursor, i) {
-      REQUIRE(i == 0); // The value is not the same as the expected one.
+    xbt_dynar_foreach (d, cursor, cpt) {
+      REQUIRE(cpt == 0); // The value is not the same as the expected one.

     }
     xbt_dynar_foreach_ptr(d, cursor, pi) { *pi = 1; }
     }
     xbt_dynar_foreach_ptr(d, cursor, pi) { *pi = 1; }

-    xbt_dynar_foreach (d, cursor, i) {
-      REQUIRE(i == 1); // The value is not the same as the expected one
+    xbt_dynar_foreach (d, cursor, cpt) {
+      REQUIRE(cpt == 1); // The value is not the same as the expected one

     }
 
     /* 5. Free the resources */
     }
 
     /* 5. Free the resources */


@@ -96,12 +96,12 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
 
     INFO("==== Unshift/pop " << NB_ELEM << " int");
     d = xbt_dynar_new(sizeof(int), nullptr);
 
     INFO("==== Unshift/pop " << NB_ELEM << " int");
     d = xbt_dynar_new(sizeof(int), nullptr);

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
-      xbt_dynar_unshift(d, &cpt);
+    for (int i = 0; i < NB_ELEM; i++) {
+      xbt_dynar_unshift(d, &i);

     }
     }

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
-      i = xbt_dynar_pop_as(d, int);
-      REQUIRE(i == cpt); // The retrieved value is not the same than the injected one
+    for (int i = 0; i < NB_ELEM; i++) {
+      int val = xbt_dynar_pop_as(d, int);
+      REQUIRE(val == i); // The retrieved value is not the same than the injected one

     }
     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 */
     }
     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 */


@@ -109,24 +109,27 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
 
     INFO("==== Push " << NB_ELEM << "%d int, insert 1000 int in the middle, shift everything");
     d = xbt_dynar_new(sizeof(int), nullptr);
 
     INFO("==== Push " << NB_ELEM << "%d int, insert 1000 int in the middle, shift everything");
     d = xbt_dynar_new(sizeof(int), nullptr);

-    for (cpt = 0; cpt < NB_ELEM; cpt++) {
-      xbt_dynar_push_as(d, int, cpt);
+    for (int i = 0; i < NB_ELEM; i++) {
+      xbt_dynar_push_as(d, int, i);

     }
     }

-    for (cpt = 0; cpt < NB_ELEM / 5; cpt++) {
-      xbt_dynar_insert_at_as(d, NB_ELEM / 2, int, cpt);
+    for (int i = 0; i < NB_ELEM / 5; i++) {
+      xbt_dynar_insert_at_as(d, NB_ELEM / 2, int, i);

     }
 
     }
 

-    for (cpt = 0; cpt < NB_ELEM / 2; cpt++) {
-      xbt_dynar_shift(d, &i);
-      REQUIRE(i == cpt); // The retrieved value is not the same than the injected one at the begining
+    for (int i = 0; i < NB_ELEM / 2; i++) {
+      int val;
+      xbt_dynar_shift(d, &val);
+      REQUIRE(val == i); // The retrieved value is not the same than the injected one at the begining

     }
     }

-    for (cpt = 999; cpt >= 0; cpt--) {
-      xbt_dynar_shift(d, &i);
-      REQUIRE(i == cpt); // The retrieved value is not the same than the injected one in the middle
+    for (int i = 999; i >= 0; i--) {
+      int val;
+      xbt_dynar_shift(d, &val);
+      REQUIRE(val == i); // The retrieved value is not the same than the injected one in the middle

     }
     }

-    for (cpt = 2500; cpt < NB_ELEM; cpt++) {
-      xbt_dynar_shift(d, &i);
-      REQUIRE(i == cpt); // The retrieved value is not the same than the injected one at the end
+    for (int i = 2500; i < NB_ELEM; i++) {
+      int val;
+      xbt_dynar_shift(d, &val);
+      REQUIRE(val == i); // The retrieved value is not the same than the injected one at the end

     }
     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 */
     }
     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 */


@@ -134,12 +137,13 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
 
     INFO("==== Push " << NB_ELEM << " int, remove 2000-4000. free the rest");
     d = xbt_dynar_new(sizeof(int), nullptr);
 
     INFO("==== Push " << NB_ELEM << " int, remove 2000-4000. free the rest");
     d = xbt_dynar_new(sizeof(int), nullptr);

-    for (cpt = 0; cpt < NB_ELEM; cpt++)
-      xbt_dynar_push_as(d, int, cpt);
+    for (int i = 0; i < NB_ELEM; i++)
+      xbt_dynar_push_as(d, int, i);

 
 

-    for (cpt = 2000; cpt < 4000; cpt++) {
-      xbt_dynar_remove_at(d, 2000, &i);
-      REQUIRE(i == cpt); // Remove a bad value
+    for (int i = 2000; i < 4000; i++) {
+      int val;
+      xbt_dynar_remove_at(d, 2000, &val);
+      REQUIRE(val == i); // Remove a bad value

     }
     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 */
     }
     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 */


@@ -155,8 +159,8 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
     INFO("==== Insert " << NB_ELEM << " int, traverse them, remove them");
     /* Populate_ints [doxygen cruft] */
     /* 1. Populate the dynar */
     INFO("==== Insert " << NB_ELEM << " int, traverse them, remove them");
     /* Populate_ints [doxygen cruft] */
     /* 1. Populate the dynar */

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
-      xbt_dynar_insert_at(d, cpt, &cpt);
+    for (int i = 0; i < NB_ELEM; i++) {
+      xbt_dynar_insert_at(d, i, &i);

     }
 
     /* 3. Traverse the dynar */
     }
 
     /* 3. Traverse the dynar */


@@ -167,15 +171,15 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
     /* end_of_traversal */
 
     /* Re-fill with the same values using set_as (and re-verify) */
     /* 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);
+    for (int i = 0; i < NB_ELEM; i++)
+      xbt_dynar_set_as(d, i, int, i);

     xbt_dynar_foreach (d, cursor, cpt)
       REQUIRE(cursor == (unsigned int)cpt); // The retrieved value is not the same than the injected one
 
     xbt_dynar_foreach (d, cursor, cpt)
       REQUIRE(cursor == (unsigned int)cpt); // The retrieved value is not the same than the injected one
 

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
+    for (int i = 0; i < NB_ELEM; i++) {

       int val;
       xbt_dynar_remove_at(d, 0, &val);
       int val;
       xbt_dynar_remove_at(d, 0, &val);

-      REQUIRE(cpt == val); // The retrieved value is not the same than the injected one
+      REQUIRE(i == val); // The retrieved value is not the same than the injected one

     }
     REQUIRE(xbt_dynar_is_empty(d));
     xbt_dynar_free(&d);
     }
     REQUIRE(xbt_dynar_is_empty(d));
     xbt_dynar_free(&d);


@@ -183,8 +187,8 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
     /* ********************* */
     INFO("==== Insert " << NB_ELEM << " int in reverse order, traverse them, remove them");
     d = xbt_dynar_new(sizeof(int), nullptr);
     /* ********************* */
     INFO("==== Insert " << NB_ELEM << " int in reverse order, traverse them, remove them");
     d = xbt_dynar_new(sizeof(int), nullptr);

-    for (int cpt = NB_ELEM - 1; cpt >= 0; cpt--) {
-      xbt_dynar_replace(d, cpt, &cpt);
+    for (int i = NB_ELEM - 1; i >= 0; i--) {
+      xbt_dynar_replace(d, i, &i);

     }
 
     /* 3. Traverse the dynar */
     }
 
     /* 3. Traverse the dynar */


@@ -193,10 +197,10 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
     }
     /* end_of_traversal */
 
     }
     /* end_of_traversal */
 

-    for (cpt = NB_ELEM - 1; cpt >= 0; cpt--) {
+    for (int i = NB_ELEM - 1; i >= 0; i--) {

       int val;
       xbt_dynar_remove_at(d, xbt_dynar_length(d) - 1, &val);
       int val;
       xbt_dynar_remove_at(d, xbt_dynar_length(d) - 1, &val);

-      REQUIRE(cpt == val); // The retrieved value is not the same than the injected one
+      REQUIRE(val == i); // The retrieved value is not the same than the injected one

     }
     REQUIRE(xbt_dynar_is_empty(d));
     xbt_dynar_free(&d);
     }
     REQUIRE(xbt_dynar_is_empty(d));
     xbt_dynar_free(&d);


@@ -208,7 +212,8 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
     xbt_dynar_t d;
     int cpt;
     unsigned int cursor;
     xbt_dynar_t d;
     int cpt;
     unsigned int cursor;

-    double d1, d2;
+    double d1;
+    double d2;

 
     INFO("==== Traverse the empty dynar");
     d = xbt_dynar_new(sizeof(int), nullptr);
 
     INFO("==== Traverse the empty dynar");
     d = xbt_dynar_new(sizeof(int), nullptr);


@@ -221,16 +226,16 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
 
     INFO("==== Push/shift 5000 doubles");
     d = xbt_dynar_new(sizeof(double), nullptr);
 
     INFO("==== Push/shift 5000 doubles");
     d = xbt_dynar_new(sizeof(double), nullptr);

-    for (cpt = 0; cpt < 5000; cpt++) {
-      d1 = (double)cpt;
+    for (int i = 0; i < 5000; i++) {
+      d1 = (double)i;

       xbt_dynar_push(d, &d1);
     }
     xbt_dynar_foreach (d, cursor, d2) {
       d1 = (double)cursor;
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one
     }
       xbt_dynar_push(d, &d1);
     }
     xbt_dynar_foreach (d, cursor, d2) {
       d1 = (double)cursor;
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one
     }

-    for (cpt = 0; cpt < 5000; cpt++) {
-      d1 = (double)cpt;
+    for (int i = 0; i < 5000; i++) {
+      d1 = (double)i;

       xbt_dynar_shift(d, &d2);
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one
     }
       xbt_dynar_shift(d, &d2);
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one
     }


@@ -240,12 +245,12 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
 
     INFO("==== Unshift/pop 5000 doubles");
     d = xbt_dynar_new(sizeof(double), nullptr);
 
     INFO("==== Unshift/pop 5000 doubles");
     d = xbt_dynar_new(sizeof(double), nullptr);

-    for (cpt = 0; cpt < 5000; cpt++) {
-      d1 = (double)cpt;
+    for (int i = 0; i < 5000; i++) {
+      d1 = (double)i;

       xbt_dynar_unshift(d, &d1);
     }
       xbt_dynar_unshift(d, &d1);
     }

-    for (cpt = 0; cpt < 5000; cpt++) {
-      d1 = (double)cpt;
+    for (int i = 0; i < 5000; i++) {
+      d1 = (double)i;

       xbt_dynar_pop(d, &d2);
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one
     }
       xbt_dynar_pop(d, &d2);
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one
     }


@@ -255,27 +260,27 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
 
     INFO("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything");
     d = xbt_dynar_new(sizeof(double), nullptr);
 
     INFO("==== 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;
+    for (int i = 0; i < 5000; i++) {
+      d1 = (double)i;

       xbt_dynar_push(d, &d1);
     }
       xbt_dynar_push(d, &d1);
     }

-    for (cpt = 0; cpt < 1000; cpt++) {
-      d1 = (double)cpt;
+    for (int i = 0; i < 1000; i++) {
+      d1 = (double)i;

       xbt_dynar_insert_at(d, 2500, &d1);
     }
 
       xbt_dynar_insert_at(d, 2500, &d1);
     }
 

-    for (cpt = 0; cpt < 2500; cpt++) {
-      d1 = (double)cpt;
+    for (int i = 0; i < 2500; i++) {
+      d1 = (double)i;

       xbt_dynar_shift(d, &d2);
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one at the begining
     }
       xbt_dynar_shift(d, &d2);
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one at the begining
     }

-    for (cpt = 999; cpt >= 0; cpt--) {
-      d1 = (double)cpt;
+    for (int i = 999; i >= 0; i--) {
+      d1 = (double)i;

       xbt_dynar_shift(d, &d2);
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one in the middle
     }
       xbt_dynar_shift(d, &d2);
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one in the middle
     }

-    for (cpt = 2500; cpt < 5000; cpt++) {
-      d1 = (double)cpt;
+    for (int i = 2500; i < 5000; i++) {
+      d1 = (double)i;

       xbt_dynar_shift(d, &d2);
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one at the end
     }
       xbt_dynar_shift(d, &d2);
       REQUIRE(d1 == d2); // The retrieved value is not the same than the injected one at the end
     }


@@ -285,12 +290,12 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
 
     INFO("==== Push 5000 double, remove 2000-4000. free the rest");
     d = xbt_dynar_new(sizeof(double), nullptr);
 
     INFO("==== 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;
+    for (int i = 0; i < 5000; i++) {
+      d1 = (double)i;

       xbt_dynar_push(d, &d1);
     }
       xbt_dynar_push(d, &d1);
     }

-    for (cpt = 2000; cpt < 4000; cpt++) {
-      d1 = (double)cpt;
+    for (int i = 2000; i < 4000; i++) {
+      d1 = (double)i;

       xbt_dynar_remove_at(d, 2000, &d2);
       REQUIRE(d1 == d2); // Remove a bad value
     }
       xbt_dynar_remove_at(d, 2000, &d2);
       REQUIRE(d1 == d2); // Remove a bad value
     }


@@ -304,7 +309,8 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
   {
     unsigned int iter;
     char buf[1024];
   {
     unsigned int iter;
     char buf[1024];

-    char *s1, *s2;
+    char* s1;
+    char* s2;

 
     INFO("==== Traverse the empty dynar");
     xbt_dynar_t d = xbt_dynar_new(sizeof(char*), &xbt_free_ref);
 
     INFO("==== Traverse the empty dynar");
     xbt_dynar_t d = xbt_dynar_new(sizeof(char*), &xbt_free_ref);


@@ -319,20 +325,20 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
     /* Populate_str [doxygen cruft] */
     d = xbt_dynar_new(sizeof(char*), &xbt_free_ref);
     /* 1. Populate the dynar */
     /* 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);
+    for (int i = 0; i < NB_ELEM; i++) {
+      snprintf(buf, 1023, "%d", i);

       s1 = xbt_strdup(buf);
       xbt_dynar_push(d, &s1);
     }
       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);
+    for (int k = 0; k < 3; k++) {
+      for (int i = 0; i < NB_ELEM; i++) {
+        snprintf(buf, 1023, "%d", i);

         s1 = xbt_strdup(buf);
         s1 = xbt_strdup(buf);

-        xbt_dynar_replace(d, cpt, &s1);
+        xbt_dynar_replace(d, i, &s1);

       }
     }
       }
     }

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
-      snprintf(buf, 1023, "%d", cpt);
+    for (int i = 0; i < NB_ELEM; i++) {
+      snprintf(buf, 1023, "%d", i);

       xbt_dynar_shift(d, &s2);
       REQUIRE(not strcmp(buf, s2)); // The retrieved value is not the same than the injected one
       xbt_free(s2);
       xbt_dynar_shift(d, &s2);
       REQUIRE(not strcmp(buf, s2)); // The retrieved value is not the same than the injected one
       xbt_free(s2);


@@ -343,8 +349,8 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
 
     INFO("==== Unshift, traverse and pop " << NB_ELEM << " strings");
     d = xbt_dynar_new(sizeof(char**), &xbt_free_ref);
 
     INFO("==== Unshift, traverse and pop " << NB_ELEM << " strings");
     d = xbt_dynar_new(sizeof(char**), &xbt_free_ref);

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
-      snprintf(buf, 1023, "%d", cpt);
+    for (int i = 0; i < NB_ELEM; i++) {
+      snprintf(buf, 1023, "%d", i);

       s1 = xbt_strdup(buf);
       xbt_dynar_unshift(d, &s1);
     }
       s1 = xbt_strdup(buf);
       xbt_dynar_unshift(d, &s1);
     }


@@ -354,8 +360,8 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
       REQUIRE(not strcmp(buf, s1)); // The retrieved value is not the same than the injected one
     }
     /* 3. Traverse the dynar with the macro */
       REQUIRE(not strcmp(buf, s1)); // The retrieved value is not the same than the injected one
     }
     /* 3. Traverse the dynar with the macro */

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
-      snprintf(buf, 1023, "%d", cpt);
+    for (int i = 0; i < NB_ELEM; i++) {
+      snprintf(buf, 1023, "%d", i);

       xbt_dynar_pop(d, &s2);
       REQUIRE(not strcmp(buf, s2)); // The retrieved value is not the same than the injected one
       xbt_free(s2);
       xbt_dynar_pop(d, &s2);
       REQUIRE(not strcmp(buf, s2)); // The retrieved value is not the same than the injected one
       xbt_free(s2);


@@ -367,31 +373,31 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
 
     INFO("==== Push " << NB_ELEM << " strings, insert " << (NB_ELEM / 5) << " strings in the middle, shift everything");
     d = xbt_dynar_new(sizeof(char*), &xbt_free_ref);
 
     INFO("==== Push " << NB_ELEM << " strings, insert " << (NB_ELEM / 5) << " strings in the middle, shift everything");
     d = xbt_dynar_new(sizeof(char*), &xbt_free_ref);

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
-      snprintf(buf, 1023, "%d", cpt);
+    for (int i = 0; i < NB_ELEM; i++) {
+      snprintf(buf, 1023, "%d", i);

       s1 = xbt_strdup(buf);
       xbt_dynar_push(d, &s1);
     }
       s1 = xbt_strdup(buf);
       xbt_dynar_push(d, &s1);
     }

-    for (int cpt = 0; cpt < NB_ELEM / 5; cpt++) {
-      snprintf(buf, 1023, "%d", cpt);
+    for (int i = 0; i < NB_ELEM / 5; i++) {
+      snprintf(buf, 1023, "%d", i);

       s1 = xbt_strdup(buf);
       xbt_dynar_insert_at(d, NB_ELEM / 2, &s1);
     }
 
       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);
+    for (int i = 0; i < NB_ELEM / 2; i++) {
+      snprintf(buf, 1023, "%d", i);

       xbt_dynar_shift(d, &s2);
       REQUIRE(not strcmp(buf, s2)); // The retrieved value is not the same than the injected one at the beginning
       xbt_free(s2);
     }
       xbt_dynar_shift(d, &s2);
       REQUIRE(not strcmp(buf, s2)); // The retrieved value is not the same than the injected one at the beginning
       xbt_free(s2);
     }

-    for (int cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) {
-      snprintf(buf, 1023, "%d", cpt);
+    for (int i = (NB_ELEM / 5) - 1; i >= 0; i--) {
+      snprintf(buf, 1023, "%d", i);

       xbt_dynar_shift(d, &s2);
       REQUIRE(not strcmp(buf, s2)); // The retrieved value is not the same than the injected one in the middle
       xbt_free(s2);
     }
       xbt_dynar_shift(d, &s2);
       REQUIRE(not strcmp(buf, s2)); // The retrieved value is not the same than the injected one in the middle
       xbt_free(s2);
     }

-    for (int cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) {
-      snprintf(buf, 1023, "%d", cpt);
+    for (int i = NB_ELEM / 2; i < NB_ELEM; i++) {
+      snprintf(buf, 1023, "%d", i);

       xbt_dynar_shift(d, &s2);
       REQUIRE(not strcmp(buf, s2)); // The retrieved value is not the same than the injected one at the end
       xbt_free(s2);
       xbt_dynar_shift(d, &s2);
       REQUIRE(not strcmp(buf, s2)); // The retrieved value is not the same than the injected one at the end
       xbt_free(s2);


@@ -403,13 +409,13 @@ TEST_CASE("xbt::dynar: generic C vector", "dynar")
     INFO("==== Push " << NB_ELEM << " strings, remove " << (2 * NB_ELEM / 5) << "-" << (4 * NB_ELEM / 5)
                       << ". free the rest");
     d = xbt_dynar_new(sizeof(char*), &xbt_free_ref);
     INFO("==== Push " << NB_ELEM << " strings, remove " << (2 * NB_ELEM / 5) << "-" << (4 * NB_ELEM / 5)
                       << ". free the rest");
     d = xbt_dynar_new(sizeof(char*), &xbt_free_ref);

-    for (int cpt = 0; cpt < NB_ELEM; cpt++) {
-      snprintf(buf, 1023, "%d", cpt);
+    for (int i = 0; i < NB_ELEM; i++) {
+      snprintf(buf, 1023, "%d", i);

       s1 = xbt_strdup(buf);
       xbt_dynar_push(d, &s1);
     }
       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);
+    for (int i = 2 * (NB_ELEM / 5); i < 4 * (NB_ELEM / 5); i++) {
+      snprintf(buf, 1023, "%d", i);

       xbt_dynar_remove_at(d, 2 * (NB_ELEM / 5), &s2);
       REQUIRE(not strcmp(buf, s2)); // Remove a bad value
       xbt_free(s2);
       xbt_dynar_remove_at(d, 2 * (NB_ELEM / 5), &s2);
       REQUIRE(not strcmp(buf, s2)); // Remove a bad value
       xbt_free(s2);