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
At least. ignore ignorable
[simgrid.git] / src / dict_unit.c
diff --git a/src/dict_unit.c b/src/dict_unit.c
index 63da41e..7d5032e 100644 (file)
--- a/src/dict_unit.c
+++ b/src/dict_unit.c
@@ -8,7 +8,7 @@
 /* GENERATED FILE, DO NOT EDIT */
 /*******************************/
 
 /* GENERATED FILE, DO NOT EDIT */
 /*******************************/
 
-# 487 "xbt/dict.c" 
+# 639 "xbt/dict.c" 
 #include "xbt.h"
 #include "xbt/ex.h"
 #include "portable.h"
 #include "xbt.h"
 #include "xbt/ex.h"
 #include "portable.h"
@@ -33,7 +33,7 @@ static void debuged_add_ext(xbt_dict_t head,const char*key,const char*data_to_fi
   }
 }
 static void debuged_add(xbt_dict_t head,const char*key) {
   }
 }
 static void debuged_add(xbt_dict_t head,const char*key) {
-   debuged_add_ext(head,key,key);
+  debuged_add_ext(head,key,key);
 }
 
 static void fill(xbt_dict_t *head) {
 }
 
 static void fill(xbt_dict_t *head) {
@@ -54,7 +54,7 @@ static void fill(xbt_dict_t *head) {
 
 static void search_ext(xbt_dict_t head,const char*key, const char *data) {
   void *found;
 
 static void search_ext(xbt_dict_t head,const char*key, const char *data) {
   void *found;
-  
+
   xbt_test_add1("Search %s",key);
   found=xbt_dict_get(head,key);
   xbt_test_log1("Found %s",(char *)found);
   xbt_test_add1("Search %s",key);
   found=xbt_dict_get(head,key);
   xbt_test_log1("Found %s",(char *)found);
@@ -80,11 +80,16 @@ static void traverse(xbt_dict_t head) {
   xbt_dict_cursor_t cursor=NULL;
   char *key;
   char *data;
   xbt_dict_cursor_t cursor=NULL;
   char *key;
   char *data;
+  int i = 0;
 
   xbt_dict_foreach(head,cursor,key,data) {
 
   xbt_dict_foreach(head,cursor,key,data) {
-    xbt_test_log2("Seen:  %s->%s",PRINTF_STR(key),PRINTF_STR(data));
+    if (!key || !data || strcmp(key,data)) {
+      xbt_test_log3("Seen #%d:  %s->%s",++i,PRINTF_STR(key),PRINTF_STR(data));
+    } else {
+      xbt_test_log2("Seen #%d:  %s",++i,PRINTF_STR(key));
+    }
     xbt_test_assert2(!data || !strcmp(key,data),
     xbt_test_assert2(!data || !strcmp(key,data),
-                    "Key(%s) != value(%s). Abording\n",key,data);
+                     "Key(%s) != value(%s). Aborting",key,data);
   }
 }
 
   }
 }
 
@@ -94,11 +99,11 @@ static void search_not_found(xbt_dict_t head, const char *data) {
 
   xbt_test_add1("Search %s (expected not to be found)",data);
 
 
   xbt_test_add1("Search %s (expected not to be found)",data);
 
-  TRY {    
+  TRY {
     data = xbt_dict_get(head, data);
     THROW1(unknown_error,0,"Found something which shouldn't be there (%s)",data);
   } CATCH(e) {
     data = xbt_dict_get(head, data);
     THROW1(unknown_error,0,"Found something which shouldn't be there (%s)",data);
   } CATCH(e) {
-    if (e.category != not_found_error) 
+    if (e.category != not_found_error)
       xbt_test_exception(e);
     xbt_ex_free(e);
     ok=1;
       xbt_test_exception(e);
     xbt_ex_free(e);
     ok=1;
@@ -107,8 +112,19 @@ static void search_not_found(xbt_dict_t head, const char *data) {
 }
 
 static void count(xbt_dict_t dict, int length) {
 }
 
 static void count(xbt_dict_t dict, int length) {
+  xbt_dict_cursor_t cursor;
+  char *key;
+  void *data;
+  int effective = 0;
+
+
   xbt_test_add1("Count elements (expecting %d)", length);
   xbt_test_add1("Count elements (expecting %d)", length);
-  xbt_test_assert2(xbt_dict_length(dict) == length, "Length(%d) != %d.", xbt_dict_length(dict), length);
+  xbt_test_assert2(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.", effective, length);
 }
 
 xbt_ex_t e;
 }
 
 xbt_ex_t e;
@@ -117,25 +133,25 @@ char *data;
 
 
 XBT_TEST_UNIT("basic",test_dict_basic,"Basic usage: change, retrieve, traverse"){
 
 
 XBT_TEST_UNIT("basic",test_dict_basic,"Basic usage: change, retrieve, traverse"){
-  xbt_test_add0("Traversal the null dictionnary");
+  xbt_test_add0("Traversal the null dictionary");
   traverse(head);
 
   traverse(head);
 
-  xbt_test_add0("Traversal and search the empty dictionnary");
+  xbt_test_add0("Traversal and search the empty dictionary");
   head = xbt_dict_new();
   traverse(head);
   TRY {
     debuged_remove(head,"12346");
   } CATCH(e) {
   head = xbt_dict_new();
   traverse(head);
   TRY {
     debuged_remove(head,"12346");
   } CATCH(e) {
-    if (e.category != not_found_error) 
+    if (e.category != not_found_error)
       xbt_test_exception(e);
     xbt_ex_free(e);
   }
   xbt_dict_free(&head);
 
       xbt_test_exception(e);
     xbt_ex_free(e);
   }
   xbt_dict_free(&head);
 
-  xbt_test_add0("Traverse the full dictionnary");
+  xbt_test_add0("Traverse the full dictionary");
   fill(&head);
   count(head, 7);
   fill(&head);
   count(head, 7);
-   
+
   debuged_add_ext(head,"toto","tutu");
   search_ext(head,"toto","tutu");
   debuged_remove(head,"toto");
   debuged_add_ext(head,"toto","tutu");
   search_ext(head,"toto","tutu");
   debuged_remove(head,"toto");
@@ -143,7 +159,7 @@ XBT_TEST_UNIT("basic",test_dict_basic,"Basic usage: change, retrieve, traverse")
   search(head,"12a");
   traverse(head);
 
   search(head,"12a");
   traverse(head);
 
-  xbt_test_add0("Free the dictionnary (twice)");
+  xbt_test_add0("Free the dictionary (twice)");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 
@@ -166,9 +182,9 @@ XBT_TEST_UNIT("basic",test_dict_basic,"Basic usage: change, retrieve, traverse")
   xbt_dict_set(head,"12a",strdup("12a"),&free);
   count(head, 7);
 
   xbt_dict_set(head,"12a",strdup("12a"),&free);
   count(head, 7);
 
-  xbt_test_add0("Traverse the resulting dictionnary");
+  xbt_test_add0("Traverse the resulting dictionary");
   traverse(head);
   traverse(head);
-  
+
   /* RETRIEVE */
   xbt_test_add0("Search 123");
   data = xbt_dict_get(head,"123");
   /* RETRIEVE */
   xbt_test_add0("Search 123");
   data = xbt_dict_get(head,"123");
@@ -186,16 +202,16 @@ XBT_TEST_UNIT("basic",test_dict_basic,"Basic usage: change, retrieve, traverse")
   search(head,"1234");
   search(head,"123457");
 
   search(head,"1234");
   search(head,"123457");
 
-  xbt_test_add0("Traverse the resulting dictionnary");
+  xbt_test_add0("Traverse the resulting dictionary");
   traverse(head);
 
   /*  xbt_dict_dump(head,(void (*)(void*))&printf); */
 
   traverse(head);
 
   /*  xbt_dict_dump(head,(void (*)(void*))&printf); */
 
-  xbt_test_add0("Free the dictionnary twice");
+  xbt_test_add0("Free the dictionary twice");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 
   xbt_dict_free(&head);
   xbt_dict_free(&head);
 
-  xbt_test_add0("Traverse the resulting dictionnary");
+  xbt_test_add0("Traverse the resulting dictionary");
   traverse(head);
 }
 
   traverse(head);
 }
 
@@ -206,7 +222,7 @@ XBT_TEST_UNIT("remove",test_dict_remove,"Removing some values"){
   TRY {
     debuged_remove(head,"Does not exist");
   } CATCH(e) {
   TRY {
     debuged_remove(head,"Does not exist");
   } CATCH(e) {
-    if (e.category != not_found_error) 
+    if (e.category != not_found_error)
       xbt_test_exception(e);
     xbt_ex_free(e);
   }
       xbt_test_exception(e);
     xbt_ex_free(e);
   }
@@ -214,7 +230,7 @@ XBT_TEST_UNIT("remove",test_dict_remove,"Removing some values"){
 
   xbt_dict_free(&head);
 
 
   xbt_dict_free(&head);
 
-  xbt_test_add0("Remove each data manually (traversing the resulting dictionnary each time)");
+  xbt_test_add0("Remove each data manually (traversing the resulting dictionary each time)");
   fill(&head);
   debuged_remove(head,"12a");    traverse(head);
   count(head, 6);
   fill(&head);
   debuged_remove(head,"12a");    traverse(head);
   count(head, 6);
@@ -227,32 +243,32 @@ XBT_TEST_UNIT("remove",test_dict_remove,"Removing some values"){
   TRY {
     debuged_remove(head,"12346");
   } CATCH(e) {
   TRY {
     debuged_remove(head,"12346");
   } CATCH(e) {
-    if (e.category != not_found_error) 
+    if (e.category != not_found_error)
       xbt_test_exception(e);
       xbt_test_exception(e);
-    xbt_ex_free(e);         
+    xbt_ex_free(e);
     traverse(head);
     traverse(head);
-  } 
+  }
   debuged_remove(head,"1234");   traverse(head);
   debuged_remove(head,"123457"); traverse(head);
   debuged_remove(head,"123");    traverse(head);
   TRY {
     debuged_remove(head,"12346");
   } CATCH(e) {
   debuged_remove(head,"1234");   traverse(head);
   debuged_remove(head,"123457"); traverse(head);
   debuged_remove(head,"123");    traverse(head);
   TRY {
     debuged_remove(head,"12346");
   } CATCH(e) {
-    if (e.category != not_found_error) 
+    if (e.category != not_found_error)
       xbt_test_exception(e);
     xbt_ex_free(e);
   }                              traverse(head);
       xbt_test_exception(e);
     xbt_ex_free(e);
   }                              traverse(head);
-  
-  xbt_test_add0("Remove all values");
+
+  xbt_test_add0("Free dict, create new fresh one, and then reset the dict");
   xbt_dict_free(&head);
   fill(&head);
   xbt_dict_reset(head);
   count(head, 0);
   traverse(head);
 
   xbt_dict_free(&head);
   fill(&head);
   xbt_dict_reset(head);
   count(head, 0);
   traverse(head);
 
-  xbt_test_add0("Free the dictionnary twice");
+  xbt_test_add0("Free the dictionary twice");
+  xbt_dict_free(&head);
   xbt_dict_free(&head);
   xbt_dict_free(&head);
-  xbt_dict_free(&head);      
 }
 
 XBT_TEST_UNIT("nulldata",test_dict_nulldata,"NULL data management"){
 }
 
 XBT_TEST_UNIT("nulldata",test_dict_nulldata,"NULL data management"){
@@ -269,9 +285,14 @@ XBT_TEST_UNIT("nulldata",test_dict_nulldata,"NULL data management"){
     int found=0;
 
     xbt_dict_foreach(head,cursor,key,data) {
     int found=0;
 
     xbt_dict_foreach(head,cursor,key,data) {
-      xbt_test_log2("Seen:  %s->%s",PRINTF_STR(key),PRINTF_STR(data));
+      if (!key || !data || strcmp(key,data)) {
+        xbt_test_log2("Seen:  %s->%s",PRINTF_STR(key),PRINTF_STR(data));
+      } else {
+        xbt_test_log1("Seen:  %s",PRINTF_STR(key));
+      }
+
       if (!strcmp(key,"null"))
       if (!strcmp(key,"null"))
-       found = 1;
+        found = 1;
     }
     xbt_test_assert0(found,"the key 'null', associated to NULL is not found");
   }
     }
     xbt_test_assert0(found,"the key 'null', associated to NULL is not found");
   }
@@ -300,26 +321,32 @@ XBT_TEST_UNIT("crash",test_dict_crash,"Crash test"){
 
   srand((unsigned int)time(NULL));
 
 
   srand((unsigned int)time(NULL));
 
-  xbt_test_add0("CRASH test");
-  xbt_test_log0("Fill the struct, count its elems and frees the structure (x10)");
-  xbt_test_log1("using 1000 elements with %d chars long randomized keys.",SIZEOFKEY);
-
   for (i=0;i<10;i++) {
   for (i=0;i<10;i++) {
+    xbt_test_add2("CRASH test number %d (%d to go)",i+1,10-i-1);
+    xbt_test_log0("Fill the struct, count its elems and frees the structure");
+    xbt_test_log1("using 1000 elements with %d chars long randomized keys.",SIZEOFKEY);
     head=xbt_dict_new();
     /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */
     nb=0;
     for (j=0;j<1000;j++) {
     head=xbt_dict_new();
     /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */
     nb=0;
     for (j=0;j<1000;j++) {
+      char *data = NULL;
       key=xbt_malloc(SIZEOFKEY);
 
       key=xbt_malloc(SIZEOFKEY);
 
-      for (k=0;k<SIZEOFKEY-1;k++)
-       key[k]=rand() % ('z' - 'a') + 'a';
-      key[k]='\0';
-      /*      printf("[%d %s]\n",j,key); */
+      do {
+        for (k=0;k<SIZEOFKEY-1;k++)
+          key[k]=rand() % ('z' - 'a') + 'a';
+        key[k]='\0';
+        /*      printf("[%d %s]\n",j,key); */
+        data = xbt_dict_get_or_null(head,key);
+      } while (data != NULL);
+
       xbt_dict_set(head,key,key,&free);
       xbt_dict_set(head,key,key,&free);
+      data = xbt_dict_get(head,key);
+      xbt_test_assert2(!strcmp(key,data), "Retrieved value (%s) != Injected value (%s)",key,data);
+
+      count(head,j+1);
     }
     /*    xbt_dict_dump(head,(void (*)(void*))&printf); */
     }
     /*    xbt_dict_dump(head,(void (*)(void*))&printf); */
-    nb = countelems(head);
-    xbt_test_assert1(nb == 1000,"found %d elements instead of 1000",nb);
     traverse(head);
     xbt_dict_free(&head);
     xbt_dict_free(&head);
     traverse(head);
     xbt_dict_free(&head);
     xbt_dict_free(&head);
@@ -332,10 +359,11 @@ XBT_TEST_UNIT("crash",test_dict_crash,"Crash test"){
     /* if (!(j%1000)) { printf("."); fflush(stdout); } */
 
     key = xbt_malloc(10);
     /* if (!(j%1000)) { printf("."); fflush(stdout); } */
 
     key = xbt_malloc(10);
-    
+
     sprintf(key,"%d",j);
     xbt_dict_set(head,key,key,&free);
   }
     sprintf(key,"%d",j);
     xbt_dict_set(head,key,key,&free);
   }
+  /*xbt_dict_dump(head,(void (*)(void*))&printf);*/
 
   xbt_test_add0("Count the elements (retrieving the key and data for each)");
   i = countelems(head);
 
   xbt_test_add0("Count the elements (retrieving the key and data for each)");
   i = countelems(head);
@@ -346,11 +374,14 @@ XBT_TEST_UNIT("crash",test_dict_crash,"Crash test"){
   for (i=0;i<20;i++) {
     /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */
     for (j=0;j<NB_ELM;j++) {
   for (i=0;i<20;i++) {
     /* if (i%10) printf("."); else printf("%d",i/10); fflush(stdout); */
     for (j=0;j<NB_ELM;j++) {
-      
+
       sprintf(key,"%d",j);
       data = xbt_dict_get(head,key);
       xbt_test_assert2(!strcmp(key,(char*)data),
       sprintf(key,"%d",j);
       data = xbt_dict_get(head,key);
       xbt_test_assert2(!strcmp(key,(char*)data),
-                      "key=%s != data=%s\n",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),
+                       "with get_ext, key=%s != data=%s",key,(char*)data);
     }
   }
   free(key);
     }
   }
   free(key);
@@ -359,13 +390,13 @@ XBT_TEST_UNIT("crash",test_dict_crash,"Crash test"){
   key=xbt_malloc(10);
   for (j=0;j<NB_ELM;j++) {
     /* if (!(j%10000)) printf("."); fflush(stdout); */
   key=xbt_malloc(10);
   for (j=0;j<NB_ELM;j++) {
     /* if (!(j%10000)) printf("."); fflush(stdout); */
-    
+
     sprintf(key,"%d",j);
     xbt_dict_remove(head,key);
   }
   free(key);
 
     sprintf(key,"%d",j);
     xbt_dict_remove(head,key);
   }
   free(key);
 
-  
+
   xbt_test_add0("Free the structure (twice)");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
   xbt_test_add0("Free the structure (twice)");
   xbt_dict_free(&head);
   xbt_dict_free(&head);
@@ -383,7 +414,7 @@ XBT_TEST_UNIT("multicrash",test_dict_multicrash,"Multi-dict crash test"){
 #define DEPTH 5
 #define KEY_SIZE 512
 #define NB_TEST 20 /*20*/
 #define DEPTH 5
 #define KEY_SIZE 512
 #define NB_TEST 20 /*20*/
-int verbose=0;
+  int verbose=0;
 
   xbt_dict_t mdict = NULL;
   int i,j,k,l;
 
   xbt_dict_t mdict = NULL;
   int i,j,k,l;
@@ -394,13 +425,13 @@ int verbose=0;
 
   xbt_test_add0("Generic multicache CRASH test");
   xbt_test_log4(" Fill the struct and frees it %d times, using %d elements, "
 
   xbt_test_add0("Generic multicache CRASH test");
   xbt_test_log4(" 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);
+                "depth of multicache=%d, key size=%d",
+                NB_TEST,NB_ELM,DEPTH,KEY_SIZE);
 
   for (l=0 ; l<DEPTH ; l++) {
     key=xbt_malloc(KEY_SIZE);
     xbt_dynar_push(keys,&key);
 
   for (l=0 ; l<DEPTH ; l++) {
     key=xbt_malloc(KEY_SIZE);
     xbt_dynar_push(keys,&key);
-  }    
+  }
 
   for (i=0;i<NB_TEST;i++) {
     mdict = xbt_dict_new();
 
   for (i=0;i<NB_TEST;i++) {
     mdict = xbt_dict_new();
@@ -408,38 +439,38 @@ int verbose=0;
     if (verbose>0)
       printf("Test %d\n",i);
     /* else if (i%10) printf("."); else printf("%d",i/10);*/
     if (verbose>0)
       printf("Test %d\n",i);
     /* else if (i%10) printf("."); else printf("%d",i/10);*/
-    
+
     for (j=0;j<NB_ELM;j++) {
       if (verbose>0) printf ("  Add {");
     for (j=0;j<NB_ELM;j++) {
       if (verbose>0) printf ("  Add {");
-      
+
       for (l=0 ; l<DEPTH ; l++) {
         key=*(char**)xbt_dynar_get_ptr(keys,l);
       for (l=0 ; l<DEPTH ; l++) {
         key=*(char**)xbt_dynar_get_ptr(keys,l);
-        
-       for (k=0;k<KEY_SIZE-1;k++) 
-         key[k]=rand() % ('z' - 'a') + 'a';
-         
-       key[k]='\0';
-       
-       if (verbose>0) printf("%p=%s %s ",key, key,(l<DEPTH-1?";":"}"));
+
+        for (k=0;k<KEY_SIZE-1;k++)
+          key[k]=rand() % ('z' - 'a') + 'a';
+
+        key[k]='\0';
+
+        if (verbose>0) printf("%p=%s %s ",key, key,(l<DEPTH-1?";":"}"));
       }
       if (verbose>0) printf("in multitree %p.\n",mdict);
       }
       if (verbose>0) printf("in multitree %p.\n",mdict);
-                                                        
+
       xbt_multidict_set(mdict,keys,xbt_strdup(key),free);
 
       data = xbt_multidict_get(mdict,keys);
 
       xbt_test_assert2(data && !strcmp((char*)data,key),
       xbt_multidict_set(mdict,keys,xbt_strdup(key),free);
 
       data = xbt_multidict_get(mdict,keys);
 
       xbt_test_assert2(data && !strcmp((char*)data,key),
-                      "Retrieved value (%s) does not match the entrered one (%s)\n",
-                      (char*)data,key);
+                       "Retrieved value (%s) does not match the given one (%s)\n",
+                       (char*)data,key);
     }
     xbt_dict_free(&mdict);
   }
     }
     xbt_dict_free(&mdict);
   }
-  
+
   xbt_dynar_free(&keys);
 
   xbt_dynar_free(&keys);
 
-/*  if (verbose>0)
+  /*  if (verbose>0)
     xbt_dict_dump(mdict,&xbt_dict_print);*/
     xbt_dict_dump(mdict,&xbt_dict_print);*/
-    
+
   xbt_dict_free(&mdict);
   xbt_dynar_free(&keys);
 
   xbt_dict_free(&mdict);
   xbt_dynar_free(&keys);
 
Clone of SimGrid repository with local patches