Logo AND Algorithmique Numérique Distribuée
Public GIT Repository
projects / simgrid.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Use variadic variants of xbt_test_{add,fail,assert,log}.
[simgrid.git] / src / xbt / dict.c
diff --git a/src/xbt/dict.c b/src/xbt/dict.c
index 032bf5d..7518075 100644 (file)
--- a/src/xbt/dict.c
+++ b/src/xbt/dict.c
@@ -848,7 +848,7 @@ static void debuged_add_ext(xbt_dict_t head, const char *key,
 {
   char *data = xbt_strdup(data_to_fill);
 
-  xbt_test_log2("Add %s under %s", PRINTF_STR(data_to_fill),
+  xbt_test_log("Add %s under %s", PRINTF_STR(data_to_fill),
                 PRINTF_STR(key));
 
   xbt_dict_set(head, key, data, &free);
@@ -865,7 +865,7 @@ static void debuged_add(xbt_dict_t head, const char *key)
 
 static void fill(xbt_dict_t * head)
 {
-  xbt_test_add0("Fill in the dictionnary");
+  xbt_test_add("Fill in the dictionnary");
 
   *head = xbt_dict_new();
   debuged_add(*head, "12");
@@ -884,15 +884,15 @@ static void search_ext(xbt_dict_t head, const char *key, const char *data)
 {
   void *found;
 
-  xbt_test_add1("Search %s", key);
+  xbt_test_add("Search %s", key);
   found = xbt_dict_get(head, key);
-  xbt_test_log1("Found %s", (char *) found);
+  xbt_test_log("Found %s", (char *) found);
   if (data)
-    xbt_test_assert1(found,
+    xbt_test_assert(found,
                      "data do not match expectations: found NULL while searching for %s",
                      data);
   if (found)
-    xbt_test_assert2(!strcmp((char *) data, found),
+    xbt_test_assert(!strcmp((char *) data, found),
                      "data do not match expectations: found %s while searching for %s",
                      (char *) found, data);
 }
@@ -905,7 +905,7 @@ static void search(xbt_dict_t head, const char *key)
 static void debuged_remove(xbt_dict_t head, const char *key)
 {
 
-  xbt_test_add1("Remove '%s'", PRINTF_STR(key));
+  xbt_test_add("Remove '%s'", PRINTF_STR(key));
   xbt_dict_remove(head, key);
   /*  xbt_dict_dump(head,(void (*)(void*))&printf); */
 }
@@ -920,12 +920,12 @@ static void traverse(xbt_dict_t head)
 
   xbt_dict_foreach(head, cursor, key, data) {
     if (!key || !data || strcmp(key, data)) {
-      xbt_test_log3("Seen #%d:  %s->%s", ++i, PRINTF_STR(key),
+      xbt_test_log("Seen #%d:  %s->%s", ++i, PRINTF_STR(key),
                     PRINTF_STR(data));
     } else {
-      xbt_test_log2("Seen #%d:  %s", ++i, PRINTF_STR(key));
+      xbt_test_log("Seen #%d:  %s", ++i, PRINTF_STR(key));
     }
-    xbt_test_assert2(!data || !strcmp(key, data),
+    xbt_test_assert(!data || !strcmp(key, data),
                      "Key(%s) != value(%s). Aborting", key, data);
   }
 }
@@ -935,7 +935,7 @@ static void search_not_found(xbt_dict_t head, const char *data)
   int ok = 0;
   xbt_ex_t e;
 
-  xbt_test_add1("Search %s (expected not to be found)", data);
+  xbt_test_add("Search %s (expected not to be found)", data);
 
   TRY {
     data = xbt_dict_get(head, data);
@@ -947,7 +947,7 @@ static void search_not_found(xbt_dict_t head, const char *data)
     xbt_ex_free(e);
     ok = 1;
   }
-  xbt_test_assert0(ok, "Exception not raised");
+  xbt_test_assert(ok, "Exception not raised");
 }
 
 static void count(xbt_dict_t dict, int length)
@@ -958,15 +958,15 @@ static void count(xbt_dict_t dict, int length)
   int effective = 0;
 
 
-  xbt_test_add1("Count elements (expecting %d)", length);
-  xbt_test_assert2(xbt_dict_length(dict) == 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_foreach(dict, cursor, key, data)
       effective++;
 
-  xbt_test_assert2(effective == length, "Effective length(%d) != %d.",
+  xbt_test_assert(effective == length, "Effective length(%d) != %d.",
                    effective, length);
 
 }
@@ -979,10 +979,10 @@ static void count_check_get_key(xbt_dict_t dict, int length)
   int effective = 0;
 
 
-  xbt_test_add1
+  xbt_test_add
       ("Count elements (expecting %d), and test the getkey function",
        length);
-  xbt_test_assert2(xbt_dict_length(dict) == length,
+  xbt_test_assert(xbt_dict_length(dict) == length,
                    "Announced length(%d) != %d.", xbt_dict_length(dict),
                    length);
 
@@ -994,7 +994,7 @@ static void count_check_get_key(xbt_dict_t dict, int length)
                 key2, key);
   }
 
-  xbt_test_assert2(effective == length, "Effective length(%d) != %d.",
+  xbt_test_assert(effective == length, "Effective length(%d) != %d.",
                    effective, length);
 
 }
@@ -1006,10 +1006,10 @@ char *data;
 
 XBT_TEST_UNIT("basic", test_dict_basic, "Basic usage: change, retrieve, traverse")
 {
-  xbt_test_add0("Traversal the null dictionary");
+  xbt_test_add("Traversal the null dictionary");
   traverse(head);
 
-  xbt_test_add0("Traversal and search the empty dictionary");
+  xbt_test_add("Traversal and search the empty dictionary");
   head = xbt_dict_new();
   traverse(head);
   TRY {
@@ -1021,7 +1021,7 @@ XBT_TEST_UNIT("basic", test_dict_basic, "Basic usage: change, retrieve, traverse
   }
   xbt_dict_free(&head);
 
-  xbt_test_add0("Traverse the full dictionary");
+  xbt_test_add("Traverse the full dictionary");
   fill(&head);
   count_check_get_key(head, 7);
 
@@ -1032,34 +1032,34 @@ XBT_TEST_UNIT("basic", test_dict_basic, "Basic usage: change, retrieve, traverse
   search(head, "12a");
   traverse(head);
 
-  xbt_test_add0("Free the dictionary (twice)");
+  xbt_test_add("Free the dictionary (twice)");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 
   /* CHANGING */
   fill(&head);
   count_check_get_key(head, 7);
-  xbt_test_add0("Change 123 to 'Changed 123'");
+  xbt_test_add("Change 123 to 'Changed 123'");
   xbt_dict_set(head, "123", strdup("Changed 123"), &free);
   count_check_get_key(head, 7);
 
-  xbt_test_add0("Change 123 back to '123'");
+  xbt_test_add("Change 123 back to '123'");
   xbt_dict_set(head, "123", strdup("123"), &free);
   count_check_get_key(head, 7);
 
-  xbt_test_add0("Change 12a to 'Dummy 12a'");
+  xbt_test_add("Change 12a to 'Dummy 12a'");
   xbt_dict_set(head, "12a", strdup("Dummy 12a"), &free);
   count_check_get_key(head, 7);
 
-  xbt_test_add0("Change 12a to '12a'");
+  xbt_test_add("Change 12a to '12a'");
   xbt_dict_set(head, "12a", strdup("12a"), &free);
   count_check_get_key(head, 7);
 
-  xbt_test_add0("Traverse the resulting dictionary");
+  xbt_test_add("Traverse the resulting dictionary");
   traverse(head);
 
   /* RETRIEVE */
-  xbt_test_add0("Search 123");
+  xbt_test_add("Search 123");
   data = xbt_dict_get(head, "123");
   xbt_test_assert(data);
   xbt_test_assert(!strcmp("123", data));
@@ -1075,16 +1075,16 @@ XBT_TEST_UNIT("basic", test_dict_basic, "Basic usage: change, retrieve, traverse
   search(head, "1234");
   search(head, "123457");
 
-  xbt_test_add0("Traverse the resulting dictionary");
+  xbt_test_add("Traverse the resulting dictionary");
   traverse(head);
 
   /*  xbt_dict_dump(head,(void (*)(void*))&printf); */
 
-  xbt_test_add0("Free the dictionary twice");
+  xbt_test_add("Free the dictionary twice");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 
-  xbt_test_add0("Traverse the resulting dictionary");
+  xbt_test_add("Traverse the resulting dictionary");
   traverse(head);
 }
 
@@ -1092,7 +1092,7 @@ XBT_TEST_UNIT("remove", test_dict_remove, "Removing some values")
 {
   fill(&head);
   count(head, 7);
-  xbt_test_add0("Remove non existing data");
+  xbt_test_add("Remove non existing data");
   TRY {
     debuged_remove(head, "Does not exist");
   }
@@ -1105,7 +1105,7 @@ XBT_TEST_UNIT("remove", test_dict_remove, "Removing some values")
 
   xbt_dict_free(&head);
 
-  xbt_test_add0
+  xbt_test_add
       ("Remove each data manually (traversing the resulting dictionary each time)");
   fill(&head);
   debuged_remove(head, "12a");
@@ -1145,7 +1145,7 @@ XBT_TEST_UNIT("remove", test_dict_remove, "Removing some values")
   }
   traverse(head);
 
-  xbt_test_add0
+  xbt_test_add
       ("Free dict, create new fresh one, and then reset the dict");
   xbt_dict_free(&head);
   fill(&head);
@@ -1153,7 +1153,7 @@ XBT_TEST_UNIT("remove", test_dict_remove, "Removing some values")
   count(head, 0);
   traverse(head);
 
-  xbt_test_add0("Free the dictionary twice");
+  xbt_test_add("Free the dictionary twice");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 }
@@ -1162,11 +1162,11 @@ XBT_TEST_UNIT("nulldata", test_dict_nulldata, "NULL data management")
 {
   fill(&head);
 
-  xbt_test_add0("Store NULL under 'null'");
+  xbt_test_add("Store NULL under 'null'");
   xbt_dict_set(head, "null", NULL, NULL);
   search_ext(head, "null", NULL);
 
-  xbt_test_add0("Check whether I see it while traversing...");
+  xbt_test_add("Check whether I see it while traversing...");
   {
     xbt_dict_cursor_t cursor = NULL;
     char *key;
@@ -1174,15 +1174,15 @@ XBT_TEST_UNIT("nulldata", test_dict_nulldata, "NULL data management")
 
     xbt_dict_foreach(head, cursor, key, data) {
       if (!key || !data || strcmp(key, data)) {
-        xbt_test_log2("Seen:  %s->%s", PRINTF_STR(key), PRINTF_STR(data));
+        xbt_test_log("Seen:  %s->%s", PRINTF_STR(key), PRINTF_STR(data));
       } else {
-        xbt_test_log1("Seen:  %s", PRINTF_STR(key));
+        xbt_test_log("Seen:  %s", PRINTF_STR(key));
       }
 
       if (!strcmp(key, "null"))
         found = 1;
     }
-    xbt_test_assert0(found,
+    xbt_test_assert(found,
                      "the key 'null', associated to NULL is not found");
   }
   xbt_dict_free(&head);
@@ -1191,7 +1191,7 @@ XBT_TEST_UNIT("nulldata", test_dict_nulldata, "NULL data management")
 static void debuged_addi(xbt_dict_t head, uintptr_t key, uintptr_t data)
 {
   uintptr_t stored_data = 0;
-  xbt_test_log2("Add %zu under %zu", data, key);
+  xbt_test_log("Add %zu under %zu", data, key);
 
   xbt_dicti_set(head, key, data);
   if (XBT_LOG_ISENABLED(xbt_dict, xbt_log_priority_debug)) {
@@ -1199,14 +1199,14 @@ static void debuged_addi(xbt_dict_t head, uintptr_t key, uintptr_t data)
     fflush(stdout);
   }
   stored_data = xbt_dicti_get(head, key);
-  xbt_test_assert3(stored_data == data,
+  xbt_test_assert(stored_data == data,
                    "Retrieved data (%zu) is not what I just stored (%zu) under key %zu",
                    stored_data, data, key);
 }
 
 XBT_TEST_UNIT("dicti", test_dict_scalar, "Scalar data and key management")
 {
-  xbt_test_add0("Fill in the dictionnary");
+  xbt_test_add("Fill in the dictionnary");
 
   head = xbt_dict_new();
   debuged_addi(head, 12, 12);
@@ -1255,10 +1255,10 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
   srand((unsigned int) time(NULL));
 
   for (i = 0; i < 10; i++) {
-    xbt_test_add2("CRASH test number %d (%d to go)", i + 1, 10 - i - 1);
-    xbt_test_log0
+    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_log1
+    xbt_test_log
         ("using 1000 elements with %d chars long randomized keys.",
          SIZEOFKEY);
     head = xbt_dict_new();
@@ -1278,7 +1278,7 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
 
       xbt_dict_set(head, key, key, &free);
       data = xbt_dict_get(head, key);
-      xbt_test_assert2(!strcmp(key, data),
+      xbt_test_assert(!strcmp(key, data),
                        "Retrieved value (%s) != Injected value (%s)", key,
                        data);
 
@@ -1292,7 +1292,7 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
 
 
   head = xbt_dict_new();
-  xbt_test_add1("Fill %d elements, with keys being the number of element",
+  xbt_test_add("Fill %d elements, with keys being the number of element",
                 NB_ELM);
   for (j = 0; j < NB_ELM; j++) {
     /* if (!(j%1000)) { printf("."); fflush(stdout); } */
@@ -1304,12 +1304,12 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
   }
   /*xbt_dict_dump(head,(void (*)(void*))&printf); */
 
-  xbt_test_add0
+  xbt_test_add
       ("Count the elements (retrieving the key and data for each)");
   i = countelems(head);
-  xbt_test_log1("There is %d elements", i);
+  xbt_test_log("There is %d elements", i);
 
-  xbt_test_add1("Search my %d elements 20 times", NB_ELM);
+  xbt_test_add("Search my %d elements 20 times", NB_ELM);
   key = xbt_malloc(10);
   for (i = 0; i < 20; i++) {
     /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */
@@ -1317,17 +1317,17 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
 
       sprintf(key, "%d", j);
       data = xbt_dict_get(head, key);
-      xbt_test_assert2(!strcmp(key, (char *) data),
+      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_assert2(!strcmp(key, (char *) data),
+      xbt_test_assert(!strcmp(key, (char *) data),
                        "with get_ext, key=%s != data=%s", key,
                        (char *) data);
     }
   }
   free(key);
 
-  xbt_test_add1("Remove my %d elements", NB_ELM);
+  xbt_test_add("Remove my %d elements", NB_ELM);
   key = xbt_malloc(10);
   for (j = 0; j < NB_ELM; j++) {
     /* if (!(j%10000)) printf("."); fflush(stdout); */
@@ -1338,7 +1338,7 @@ XBT_TEST_UNIT("crash", test_dict_crash, "Crash test")
   free(key);
 
 
-  xbt_test_add0("Free the structure (twice)");
+  xbt_test_add("Free the structure (twice)");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 }
@@ -1366,8 +1366,8 @@ XBT_TEST_UNIT("multicrash", test_dict_multicrash, "Multi-dict crash test")
   char *key;
 
 
-  xbt_test_add0("Generic multicache CRASH test");
-  xbt_test_log4
+  xbt_test_add("Generic multicache CRASH test");
+  xbt_test_log
       (" Fill the struct and frees it %d times, using %d elements, "
        "depth of multicache=%d, key size=%d", NB_TEST, NB_ELM, DEPTH,
        KEY_SIZE);
@@ -1406,7 +1406,7 @@ XBT_TEST_UNIT("multicrash", test_dict_multicrash, "Multi-dict crash test")
 
       data = xbt_multidict_get(mdict, keys);
 
-      xbt_test_assert2(data && !strcmp((char *) data, key),
+      xbt_test_assert(data && !strcmp((char *) data, key),
                        "Retrieved value (%s) does not match the given one (%s)\n",
                        (char *) data, key);
     }
Clone of SimGrid repository with local patches