changing heap remove node api to not pass heap; more fs hacking

author: Christian Grothoff <christian@grothoff.org> 2011-03-11 16:58:27 +0000
committer: Christian Grothoff <christian@grothoff.org> 2011-03-11 16:58:27 +0000
commit: 562b33143ee9fa431a68ea6741e4feb3ba388f83 (patch)
tree: 6318eb2c56ff76730708a4791804842c63cf1f81 /src/util/test_container_heap.c
parent: 64821d4ae43b03b30de3dd136137598c0d5a2ab2 (diff)
download: gnunet-562b33143ee9fa431a68ea6741e4feb3ba388f83.tar.gz
gnunet-562b33143ee9fa431a68ea6741e4feb3ba388f83.zip
1 files changed, 36 insertions, 36 deletions
diff --git a/src/util/test_container_heap.c b/src/util/test_container_heap.c
index 87bc49129..6a0d5d68d 100644
--- a/src/util/test_container_heap.c
+++ b/src/util/test_container_heap.c
@@ -93,7 +93,7 @@ check ()
  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "78", 78);
  GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap));
  GNUNET_assert (0 == strcmp ("78",
-                              GNUNET_CONTAINER_heap_remove_node (myHeap, n2)));
+                              GNUNET_CONTAINER_heap_remove_node (n2)));
  GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap));
  GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
  
@@ -110,13 +110,13 @@ check ()
  n5 = GNUNET_CONTAINER_heap_insert (myHeap, "100", 100);
  n6 = GNUNET_CONTAINER_heap_insert (myHeap, "30/200", 30);
  GNUNET_assert (5 == GNUNET_CONTAINER_heap_get_size (myHeap));
-  GNUNET_CONTAINER_heap_remove_node (myHeap, n5);
+  GNUNET_CONTAINER_heap_remove_node (n5);
  r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n1 */
  GNUNET_assert (NULL != r);
  GNUNET_assert (0 == strcmp ("11",
                              r));
  GNUNET_CONTAINER_heap_update_cost (myHeap, n6, 200);
-  GNUNET_CONTAINER_heap_remove_node (myHeap, n3); 
+  GNUNET_CONTAINER_heap_remove_node (n3); 
  r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n4 */
  GNUNET_assert (NULL != r);
  GNUNET_assert (0 == strcmp ("50",
@@ -137,7 +137,7 @@ check ()
  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
  GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15);
  
-  r = GNUNET_CONTAINER_heap_remove_node (myHeap,n1);
+  r = GNUNET_CONTAINER_heap_remove_node (n1);
  GNUNET_assert (NULL != r);
  GNUNET_assert (0 == strcmp ("10", r));
  
@@ -145,10 +145,10 @@ check ()
  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  r = GNUNET_CONTAINER_heap_remove_node (myHeap,n2);
+  r = GNUNET_CONTAINER_heap_remove_node (n2);
  GNUNET_assert (NULL != r);
  GNUNET_assert (0 == strcmp ("20", r));
-  r = GNUNET_CONTAINER_heap_remove_node (myHeap,n1);
+  r = GNUNET_CONTAINER_heap_remove_node (n1);
  GNUNET_assert (NULL != r);
  GNUNET_assert (0 == strcmp ("10", r));
  
@@ -156,8 +156,8 @@ check ()
  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
  
-  GNUNET_CONTAINER_heap_remove_node (myHeap,n2);
+  GNUNET_CONTAINER_heap_remove_node (n2);
-  GNUNET_CONTAINER_heap_remove_node (myHeap,n1);  
+  GNUNET_CONTAINER_heap_remove_node (n1);  
  r = GNUNET_CONTAINER_heap_remove_root (myHeap); 
  GNUNET_assert (NULL != r);
  GNUNET_assert (0 == strcmp ("30", r));
@@ -166,9 +166,9 @@ check ()
  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
-  GNUNET_CONTAINER_heap_remove_node (myHeap,n2);
+  GNUNET_CONTAINER_heap_remove_node (n2);
-  GNUNET_CONTAINER_heap_remove_node (myHeap,n1);  
+  GNUNET_CONTAINER_heap_remove_node (n1);  
-  r = GNUNET_CONTAINER_heap_remove_node (myHeap, n3); 
+  r = GNUNET_CONTAINER_heap_remove_node ( n3); 
  GNUNET_assert (NULL != r);
  GNUNET_assert (0 == strcmp ("30", r));
  
@@ -176,7 +176,7 @@ check ()
  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);
  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30);
  
-  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (myHeap,n2)));
+  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_root (myHeap)));  
  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap)));  
  
@@ -191,11 +191,11 @@ check ()
  n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10);
  n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10);  
  
-  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (myHeap,n3)));
+  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
  
  // Cleaning up...
-  GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (myHeap,n6)));   
+  GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6)));   
-  GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (myHeap,n5)));
+  GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5)));
  
  // Testing heap_walk_get_next
  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
@@ -204,11 +204,11 @@ check ()
  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
  GNUNET_CONTAINER_heap_walk_get_next (myHeap);  
  
-  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (myHeap,n1)));
+  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
-  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (myHeap,n2)));  
+  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));  
-  GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (myHeap,n4)));
+  GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4)));
-  GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (myHeap,n7)));  
+  GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7)));  
-  GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (myHeap,n8)));
+  GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8)));
  
  // End Testing remove_node
 
@@ -220,30 +220,30 @@ check ()
  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
  GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15);
  
-  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (myHeap,n1)));
+  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
  
  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
-  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (myHeap,n2)));
+  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
-  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (myHeap,n1))); 
+  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); 
  
  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);  
  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
  
-  GNUNET_CONTAINER_heap_remove_node (myHeap,n2);
+  GNUNET_CONTAINER_heap_remove_node (n2);
-  GNUNET_CONTAINER_heap_remove_node (myHeap,n1);  
+  GNUNET_CONTAINER_heap_remove_node (n1);  
  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap)));
  
  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
  n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
-  GNUNET_CONTAINER_heap_remove_node (myHeap,n2);
+  GNUNET_CONTAINER_heap_remove_node (n2);
-  GNUNET_CONTAINER_heap_remove_node (myHeap,n1);  
+  GNUNET_CONTAINER_heap_remove_node (n1);  
-  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (myHeap,n3)));
+  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
  
  n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
  n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);
@@ -256,11 +256,11 @@ check ()
  n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10);
  n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10);  
  
-  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (myHeap,n3)));
+  GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
  
  // Cleaning up...
-  GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (myHeap,n6)));   
+  GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6)));   
-  GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (myHeap,n5)));
+  GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5)));
  
  // Testing heap_walk_get_next
  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
@@ -269,11 +269,11 @@ check ()
  GNUNET_CONTAINER_heap_walk_get_next (myHeap);
  GNUNET_CONTAINER_heap_walk_get_next (myHeap);  
  
-  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (myHeap,n1)));
+  GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
-  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (myHeap,n2)));  
+  GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));  
-  GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (myHeap,n4)));
+  GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4)));
-  GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (myHeap,n7)));  
+  GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7)));  
-  GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (myHeap,n8)));
+  GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8)));
  
  // End Testing remove_node
author	Christian Grothoff <christian@grothoff.org>	2011-03-11 16:58:27 +0000
committer	Christian Grothoff <christian@grothoff.org>	2011-03-11 16:58:27 +0000
commit	562b33143ee9fa431a68ea6741e4feb3ba388f83 (patch)
tree	6318eb2c56ff76730708a4791804842c63cf1f81 /src/util/test_container_heap.c
parent	64821d4ae43b03b30de3dd136137598c0d5a2ab2 (diff)
download	gnunet-562b33143ee9fa431a68ea6741e4feb3ba388f83.tar.gz gnunet-562b33143ee9fa431a68ea6741e4feb3ba388f83.zip

diff --git a/src/util/test_container_heap.c b/src/util/test_container_heap.c index 87bc49129..6a0d5d68d 100644 --- a/src/util/test_container_heap.c +++ b/src/util/test_container_heap.c
@@ -93,7 +93,7 @@ check ()
93	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "78", 78);	93	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "78", 78);
94	GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap));	94	GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap));
95	GNUNET_assert (0 == strcmp ("78",	95	GNUNET_assert (0 == strcmp ("78",
96	GNUNET_CONTAINER_heap_remove_node (myHeap, n2)));	96	GNUNET_CONTAINER_heap_remove_node (n2)));
97	GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap));	97	GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap));
98	GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);	98	GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL);
99		99
@@ -110,13 +110,13 @@ check ()
110	n5 = GNUNET_CONTAINER_heap_insert (myHeap, "100", 100);	110	n5 = GNUNET_CONTAINER_heap_insert (myHeap, "100", 100);
111	n6 = GNUNET_CONTAINER_heap_insert (myHeap, "30/200", 30);	111	n6 = GNUNET_CONTAINER_heap_insert (myHeap, "30/200", 30);
112	GNUNET_assert (5 == GNUNET_CONTAINER_heap_get_size (myHeap));	112	GNUNET_assert (5 == GNUNET_CONTAINER_heap_get_size (myHeap));
113	GNUNET_CONTAINER_heap_remove_node (myHeap, n5);	113	GNUNET_CONTAINER_heap_remove_node (n5);
114	r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n1 */	114	r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n1 */
115	GNUNET_assert (NULL != r);	115	GNUNET_assert (NULL != r);
116	GNUNET_assert (0 == strcmp ("11",	116	GNUNET_assert (0 == strcmp ("11",
117	r));	117	r));
118	GNUNET_CONTAINER_heap_update_cost (myHeap, n6, 200);	118	GNUNET_CONTAINER_heap_update_cost (myHeap, n6, 200);
119	GNUNET_CONTAINER_heap_remove_node (myHeap, n3);	119	GNUNET_CONTAINER_heap_remove_node (n3);
120	r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n4 */	120	r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n4 */
121	GNUNET_assert (NULL != r);	121	GNUNET_assert (NULL != r);
122	GNUNET_assert (0 == strcmp ("50",	122	GNUNET_assert (0 == strcmp ("50",
@@ -137,7 +137,7 @@ check ()
137	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);	137	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
138	GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15);	138	GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15);
139		139
140	r = GNUNET_CONTAINER_heap_remove_node (myHeap,n1);	140	r = GNUNET_CONTAINER_heap_remove_node (n1);
141	GNUNET_assert (NULL != r);	141	GNUNET_assert (NULL != r);
142	GNUNET_assert (0 == strcmp ("10", r));	142	GNUNET_assert (0 == strcmp ("10", r));
143		143
@@ -145,10 +145,10 @@ check ()
145	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);	145	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
146		146
147	GNUNET_CONTAINER_heap_walk_get_next (myHeap);	147	GNUNET_CONTAINER_heap_walk_get_next (myHeap);
148	r = GNUNET_CONTAINER_heap_remove_node (myHeap,n2);	148	r = GNUNET_CONTAINER_heap_remove_node (n2);
149	GNUNET_assert (NULL != r);	149	GNUNET_assert (NULL != r);
150	GNUNET_assert (0 == strcmp ("20", r));	150	GNUNET_assert (0 == strcmp ("20", r));
151	r = GNUNET_CONTAINER_heap_remove_node (myHeap,n1);	151	r = GNUNET_CONTAINER_heap_remove_node (n1);
152	GNUNET_assert (NULL != r);	152	GNUNET_assert (NULL != r);
153	GNUNET_assert (0 == strcmp ("10", r));	153	GNUNET_assert (0 == strcmp ("10", r));
154		154
@@ -156,8 +156,8 @@ check ()
156	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);	156	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
157	n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);	157	n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
158		158
159	GNUNET_CONTAINER_heap_remove_node (myHeap,n2);	159	GNUNET_CONTAINER_heap_remove_node (n2);
160	GNUNET_CONTAINER_heap_remove_node (myHeap,n1);	160	GNUNET_CONTAINER_heap_remove_node (n1);
161	r = GNUNET_CONTAINER_heap_remove_root (myHeap);	161	r = GNUNET_CONTAINER_heap_remove_root (myHeap);
162	GNUNET_assert (NULL != r);	162	GNUNET_assert (NULL != r);
163	GNUNET_assert (0 == strcmp ("30", r));	163	GNUNET_assert (0 == strcmp ("30", r));
@@ -166,9 +166,9 @@ check ()
166	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);	166	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
167	n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);	167	n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
168		168
169	GNUNET_CONTAINER_heap_remove_node (myHeap,n2);	169	GNUNET_CONTAINER_heap_remove_node (n2);
170	GNUNET_CONTAINER_heap_remove_node (myHeap,n1);	170	GNUNET_CONTAINER_heap_remove_node (n1);
171	r = GNUNET_CONTAINER_heap_remove_node (myHeap, n3);	171	r = GNUNET_CONTAINER_heap_remove_node ( n3);
172	GNUNET_assert (NULL != r);	172	GNUNET_assert (NULL != r);
173	GNUNET_assert (0 == strcmp ("30", r));	173	GNUNET_assert (0 == strcmp ("30", r));
174		174
@@ -176,7 +176,7 @@ check ()
176	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);	176	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);
177	n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30);	177	n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30);
178		178
179	GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (myHeap,n2)));	179	GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
180	GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_root (myHeap)));	180	GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_root (myHeap)));
181	GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap)));	181	GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap)));
182		182
@@ -191,11 +191,11 @@ check ()
191	n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10);	191	n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10);
192	n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10);	192	n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10);
193		193
194	GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (myHeap,n3)));	194	GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
195		195
196	// Cleaning up...	196	// Cleaning up...
197	GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (myHeap,n6)));	197	GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6)));
198	GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (myHeap,n5)));	198	GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5)));
199		199
200	// Testing heap_walk_get_next	200	// Testing heap_walk_get_next
201	GNUNET_CONTAINER_heap_walk_get_next (myHeap);	201	GNUNET_CONTAINER_heap_walk_get_next (myHeap);
@@ -204,11 +204,11 @@ check ()
204	GNUNET_CONTAINER_heap_walk_get_next (myHeap);	204	GNUNET_CONTAINER_heap_walk_get_next (myHeap);
205	GNUNET_CONTAINER_heap_walk_get_next (myHeap);	205	GNUNET_CONTAINER_heap_walk_get_next (myHeap);
206		206
207	GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (myHeap,n1)));	207	GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
208	GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (myHeap,n2)));	208	GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
209	GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (myHeap,n4)));	209	GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4)));
210	GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (myHeap,n7)));	210	GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7)));
211	GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (myHeap,n8)));	211	GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8)));
212		212
213	// End Testing remove_node	213	// End Testing remove_node
214		214
@@ -220,30 +220,30 @@ check ()
220	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);	220	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
221	GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15);	221	GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15);
222		222
223	GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (myHeap,n1)));	223	GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
224		224
225	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);	225	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
226	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);	226	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
227		227
228	GNUNET_CONTAINER_heap_walk_get_next (myHeap);	228	GNUNET_CONTAINER_heap_walk_get_next (myHeap);
229	GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (myHeap,n2)));	229	GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
230	GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (myHeap,n1)));	230	GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
231		231
232	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);	232	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
233	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);	233	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
234	n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);	234	n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
235		235
236	GNUNET_CONTAINER_heap_remove_node (myHeap,n2);	236	GNUNET_CONTAINER_heap_remove_node (n2);
237	GNUNET_CONTAINER_heap_remove_node (myHeap,n1);	237	GNUNET_CONTAINER_heap_remove_node (n1);
238	GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap)));	238	GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap)));
239		239
240	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);	240	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
241	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);	241	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10);
242	n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);	242	n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10);
243		243
244	GNUNET_CONTAINER_heap_remove_node (myHeap,n2);	244	GNUNET_CONTAINER_heap_remove_node (n2);
245	GNUNET_CONTAINER_heap_remove_node (myHeap,n1);	245	GNUNET_CONTAINER_heap_remove_node (n1);
246	GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (myHeap,n3)));	246	GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
247		247
248	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);	248	n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10);
249	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);	249	n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20);
@@ -256,11 +256,11 @@ check ()
256	n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10);	256	n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10);
257	n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10);	257	n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10);
258		258
259	GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (myHeap,n3)));	259	GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3)));
260		260
261	// Cleaning up...	261	// Cleaning up...
262	GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (myHeap,n6)));	262	GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6)));
263	GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (myHeap,n5)));	263	GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5)));
264		264
265	// Testing heap_walk_get_next	265	// Testing heap_walk_get_next
266	GNUNET_CONTAINER_heap_walk_get_next (myHeap);	266	GNUNET_CONTAINER_heap_walk_get_next (myHeap);
@@ -269,11 +269,11 @@ check ()
269	GNUNET_CONTAINER_heap_walk_get_next (myHeap);	269	GNUNET_CONTAINER_heap_walk_get_next (myHeap);
270	GNUNET_CONTAINER_heap_walk_get_next (myHeap);	270	GNUNET_CONTAINER_heap_walk_get_next (myHeap);
271		271
272	GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (myHeap,n1)));	272	GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1)));
273	GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (myHeap,n2)));	273	GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2)));
274	GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (myHeap,n4)));	274	GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4)));
275	GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (myHeap,n7)));	275	GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7)));
276	GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (myHeap,n8)));	276	GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8)));
277		277
278	// End Testing remove_node	278	// End Testing remove_node
279		279