diff options
Diffstat (limited to 'src/util/test_container_heap.c')
-rw-r--r-- | src/util/test_container_heap.c | 178 |
1 files changed, 88 insertions, 90 deletions
diff --git a/src/util/test_container_heap.c b/src/util/test_container_heap.c index 6a0d5d68d..7b352241c 100644 --- a/src/util/test_container_heap.c +++ b/src/util/test_container_heap.c | |||
@@ -30,20 +30,18 @@ | |||
30 | 30 | ||
31 | static int | 31 | static int |
32 | iterator_callback (void *cls, | 32 | iterator_callback (void *cls, |
33 | struct GNUNET_CONTAINER_HeapNode *node, | 33 | struct GNUNET_CONTAINER_HeapNode *node, |
34 | void *element, | 34 | void *element, GNUNET_CONTAINER_HeapCostType cost) |
35 | GNUNET_CONTAINER_HeapCostType cost) | ||
36 | { | 35 | { |
37 | return GNUNET_OK; | 36 | return GNUNET_OK; |
38 | } | 37 | } |
39 | 38 | ||
40 | static int | 39 | static int |
41 | nstrcmp (const char *a, | 40 | nstrcmp (const char *a, const char *b) |
42 | const char *b) | ||
43 | { | 41 | { |
44 | GNUNET_assert (a != NULL); | 42 | GNUNET_assert (a != NULL); |
45 | GNUNET_assert (b != NULL); | 43 | GNUNET_assert (b != NULL); |
46 | return strcmp (a,b); | 44 | return strcmp (a, b); |
47 | } | 45 | } |
48 | 46 | ||
49 | static int | 47 | static int |
@@ -61,47 +59,46 @@ check () | |||
61 | const char *r; | 59 | const char *r; |
62 | 60 | ||
63 | myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); | 61 | myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); |
64 | 62 | ||
65 | // GNUNET_CONTAINER_heap_remove_root heap empty, taking if-branch | 63 | // GNUNET_CONTAINER_heap_remove_root heap empty, taking if-branch |
66 | n1 = GNUNET_CONTAINER_heap_remove_root (myHeap); | 64 | n1 = GNUNET_CONTAINER_heap_remove_root (myHeap); |
67 | GNUNET_assert (NULL == n1); | 65 | GNUNET_assert (NULL == n1); |
68 | 66 | ||
69 | // GNUNET_CONTAINER_heap_peek heap empty, taking if-branch | 67 | // GNUNET_CONTAINER_heap_peek heap empty, taking if-branch |
70 | n1 = GNUNET_CONTAINER_heap_peek (myHeap); | 68 | n1 = GNUNET_CONTAINER_heap_peek (myHeap); |
71 | GNUNET_assert (NULL == n1); | 69 | GNUNET_assert (NULL == n1); |
72 | 70 | ||
73 | // GNUNET_CONTAINER_heap_walk_get_next: heap empty, taking if-branch | 71 | // GNUNET_CONTAINER_heap_walk_get_next: heap empty, taking if-branch |
74 | n1 = GNUNET_CONTAINER_heap_walk_get_next (myHeap); | 72 | n1 = GNUNET_CONTAINER_heap_walk_get_next (myHeap); |
75 | GNUNET_assert (NULL == n1); | 73 | GNUNET_assert (NULL == n1); |
76 | 74 | ||
77 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "11", 11); | 75 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "11", 11); |
78 | GNUNET_assert (NULL != n1); | 76 | GNUNET_assert (NULL != n1); |
79 | 77 | ||
80 | 78 | ||
81 | // GNUNET_CONTAINER_heap_peek not empty, taking if-branch | 79 | // GNUNET_CONTAINER_heap_peek not empty, taking if-branch |
82 | n2 = NULL; | 80 | n2 = NULL; |
83 | n2 = GNUNET_CONTAINER_heap_peek (myHeap); | 81 | n2 = GNUNET_CONTAINER_heap_peek (myHeap); |
84 | GNUNET_assert (NULL != n2); | 82 | GNUNET_assert (NULL != n2); |
85 | 83 | ||
86 | // GNUNET_CONTAINER_heap_walk_get_next: 1 element | 84 | // GNUNET_CONTAINER_heap_walk_get_next: 1 element |
87 | n1 = NULL; | 85 | n1 = NULL; |
88 | n1 = GNUNET_CONTAINER_heap_walk_get_next(myHeap); | 86 | n1 = GNUNET_CONTAINER_heap_walk_get_next (myHeap); |
89 | GNUNET_assert (NULL != n1); | 87 | GNUNET_assert (NULL != n1); |
90 | 88 | ||
91 | GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL); | 89 | GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL); |
92 | GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap)); | 90 | GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap)); |
93 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "78", 78); | 91 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "78", 78); |
94 | GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap)); | 92 | GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap)); |
95 | GNUNET_assert (0 == strcmp ("78", | 93 | GNUNET_assert (0 == strcmp ("78", GNUNET_CONTAINER_heap_remove_node (n2))); |
96 | GNUNET_CONTAINER_heap_remove_node (n2))); | ||
97 | GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap)); | 94 | GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap)); |
98 | GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL); | 95 | GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL); |
99 | 96 | ||
100 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "15", 5); | 97 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "15", 5); |
101 | GNUNET_CONTAINER_heap_update_cost (myHeap, n3, 15); | 98 | GNUNET_CONTAINER_heap_update_cost (myHeap, n3, 15); |
102 | GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap)); | 99 | GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap)); |
103 | GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL); | 100 | GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL); |
104 | 101 | ||
105 | n4 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50); | 102 | n4 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50); |
106 | GNUNET_CONTAINER_heap_update_cost (myHeap, n4, 50); | 103 | GNUNET_CONTAINER_heap_update_cost (myHeap, n4, 50); |
107 | GNUNET_assert (3 == GNUNET_CONTAINER_heap_get_size (myHeap)); | 104 | GNUNET_assert (3 == GNUNET_CONTAINER_heap_get_size (myHeap)); |
@@ -111,36 +108,34 @@ check () | |||
111 | n6 = GNUNET_CONTAINER_heap_insert (myHeap, "30/200", 30); | 108 | n6 = GNUNET_CONTAINER_heap_insert (myHeap, "30/200", 30); |
112 | GNUNET_assert (5 == GNUNET_CONTAINER_heap_get_size (myHeap)); | 109 | GNUNET_assert (5 == GNUNET_CONTAINER_heap_get_size (myHeap)); |
113 | GNUNET_CONTAINER_heap_remove_node (n5); | 110 | GNUNET_CONTAINER_heap_remove_node (n5); |
114 | r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n1 */ | 111 | r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n1 */ |
115 | GNUNET_assert (NULL != r); | 112 | GNUNET_assert (NULL != r); |
116 | GNUNET_assert (0 == strcmp ("11", | 113 | GNUNET_assert (0 == strcmp ("11", r)); |
117 | r)); | ||
118 | GNUNET_CONTAINER_heap_update_cost (myHeap, n6, 200); | 114 | GNUNET_CONTAINER_heap_update_cost (myHeap, n6, 200); |
119 | GNUNET_CONTAINER_heap_remove_node (n3); | 115 | GNUNET_CONTAINER_heap_remove_node (n3); |
120 | r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n4 */ | 116 | r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n4 */ |
121 | GNUNET_assert (NULL != r); | 117 | GNUNET_assert (NULL != r); |
122 | GNUNET_assert (0 == strcmp ("50", | 118 | GNUNET_assert (0 == strcmp ("50", r)); |
123 | r)); | 119 | r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n6 */ |
124 | r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n6 */ | ||
125 | GNUNET_assert (NULL != r); | 120 | GNUNET_assert (NULL != r); |
126 | GNUNET_assert (0 == strcmp ("30/200", r)); | 121 | GNUNET_assert (0 == strcmp ("30/200", r)); |
127 | GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (myHeap)); | 122 | GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (myHeap)); |
128 | 123 | ||
129 | GNUNET_CONTAINER_heap_destroy (myHeap); | 124 | GNUNET_CONTAINER_heap_destroy (myHeap); |
130 | 125 | ||
131 | // My additions to a complete testcase | 126 | // My additions to a complete testcase |
132 | // Testing a GNUNET_CONTAINER_HEAP_ORDER_MIN | 127 | // Testing a GNUNET_CONTAINER_HEAP_ORDER_MIN |
133 | // Testing remove_node | 128 | // Testing remove_node |
134 | 129 | ||
135 | myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); | 130 | myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); |
136 | 131 | ||
137 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 132 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
138 | GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15); | 133 | GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15); |
139 | 134 | ||
140 | r = GNUNET_CONTAINER_heap_remove_node (n1); | 135 | r = GNUNET_CONTAINER_heap_remove_node (n1); |
141 | GNUNET_assert (NULL != r); | 136 | GNUNET_assert (NULL != r); |
142 | GNUNET_assert (0 == strcmp ("10", r)); | 137 | GNUNET_assert (0 == strcmp ("10", r)); |
143 | 138 | ||
144 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 139 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
145 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); | 140 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); |
146 | 141 | ||
@@ -151,134 +146,137 @@ check () | |||
151 | r = GNUNET_CONTAINER_heap_remove_node (n1); | 146 | r = GNUNET_CONTAINER_heap_remove_node (n1); |
152 | GNUNET_assert (NULL != r); | 147 | GNUNET_assert (NULL != r); |
153 | GNUNET_assert (0 == strcmp ("10", r)); | 148 | GNUNET_assert (0 == strcmp ("10", r)); |
154 | 149 | ||
155 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 150 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
156 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); | 151 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); |
157 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); | 152 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); |
158 | 153 | ||
159 | GNUNET_CONTAINER_heap_remove_node (n2); | 154 | GNUNET_CONTAINER_heap_remove_node (n2); |
160 | GNUNET_CONTAINER_heap_remove_node (n1); | 155 | GNUNET_CONTAINER_heap_remove_node (n1); |
161 | r = GNUNET_CONTAINER_heap_remove_root (myHeap); | 156 | r = GNUNET_CONTAINER_heap_remove_root (myHeap); |
162 | GNUNET_assert (NULL != r); | 157 | GNUNET_assert (NULL != r); |
163 | GNUNET_assert (0 == strcmp ("30", r)); | 158 | GNUNET_assert (0 == strcmp ("30", r)); |
164 | 159 | ||
165 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 160 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
166 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); | 161 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); |
167 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); | 162 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); |
168 | 163 | ||
169 | GNUNET_CONTAINER_heap_remove_node (n2); | 164 | GNUNET_CONTAINER_heap_remove_node (n2); |
170 | GNUNET_CONTAINER_heap_remove_node (n1); | 165 | GNUNET_CONTAINER_heap_remove_node (n1); |
171 | r = GNUNET_CONTAINER_heap_remove_node ( n3); | 166 | r = GNUNET_CONTAINER_heap_remove_node (n3); |
172 | GNUNET_assert (NULL != r); | 167 | GNUNET_assert (NULL != r); |
173 | GNUNET_assert (0 == strcmp ("30", r)); | 168 | GNUNET_assert (0 == strcmp ("30", r)); |
174 | 169 | ||
175 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 170 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
176 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20); | 171 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20); |
177 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30); | 172 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30); |
178 | 173 | ||
179 | GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); | 174 | GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); |
180 | GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_root (myHeap))); | 175 | GNUNET_assert (0 == |
181 | GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap))); | 176 | nstrcmp ("10", GNUNET_CONTAINER_heap_remove_root (myHeap))); |
182 | 177 | GNUNET_assert (0 == | |
178 | nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap))); | ||
179 | |||
183 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 180 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
184 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20); | 181 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20); |
185 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30); | 182 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30); |
186 | n4 = GNUNET_CONTAINER_heap_insert (myHeap, "40", 40); | 183 | n4 = GNUNET_CONTAINER_heap_insert (myHeap, "40", 40); |
187 | n5 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50); | 184 | n5 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50); |
188 | n6 = GNUNET_CONTAINER_heap_insert (myHeap, "60", 60); | 185 | n6 = GNUNET_CONTAINER_heap_insert (myHeap, "60", 60); |
189 | 186 | ||
190 | // Inserting nodes deeper in the tree with lower costs | 187 | // Inserting nodes deeper in the tree with lower costs |
191 | n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10); | 188 | n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10); |
192 | n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10); | 189 | n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10); |
193 | 190 | ||
194 | GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3))); | 191 | GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3))); |
195 | 192 | ||
196 | // Cleaning up... | 193 | // Cleaning up... |
197 | GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6))); | 194 | GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6))); |
198 | GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5))); | 195 | GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5))); |
199 | 196 | ||
200 | // Testing heap_walk_get_next | 197 | // Testing heap_walk_get_next |
201 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); | 198 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); |
202 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); | 199 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); |
203 | GNUNET_CONTAINER_heap_walk_get_next (myHeap);; | 200 | GNUNET_CONTAINER_heap_walk_get_next (myHeap);; |
201 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); | ||
204 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); | 202 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); |
205 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); | 203 | |
206 | |||
207 | GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); | 204 | GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); |
208 | GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); | 205 | GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); |
209 | GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4))); | 206 | GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4))); |
210 | GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7))); | 207 | GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7))); |
211 | GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8))); | 208 | GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8))); |
212 | 209 | ||
213 | // End Testing remove_node | 210 | // End Testing remove_node |
214 | 211 | ||
215 | // Testing a GNUNET_CONTAINER_HEAP_ORDER_MAX | 212 | // Testing a GNUNET_CONTAINER_HEAP_ORDER_MAX |
216 | GNUNET_CONTAINER_heap_destroy (myHeap); | 213 | GNUNET_CONTAINER_heap_destroy (myHeap); |
217 | 214 | ||
218 | myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX); | 215 | myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX); |
219 | 216 | ||
220 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 217 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
221 | GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15); | 218 | GNUNET_CONTAINER_heap_update_cost (myHeap, n1, 15); |
222 | 219 | ||
223 | GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); | 220 | GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); |
224 | 221 | ||
225 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 222 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
226 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); | 223 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); |
227 | 224 | ||
228 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); | 225 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); |
229 | GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); | 226 | GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); |
230 | GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); | 227 | GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); |
231 | 228 | ||
232 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 229 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
233 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); | 230 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); |
234 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); | 231 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); |
235 | 232 | ||
236 | GNUNET_CONTAINER_heap_remove_node (n2); | 233 | GNUNET_CONTAINER_heap_remove_node (n2); |
237 | GNUNET_CONTAINER_heap_remove_node (n1); | 234 | GNUNET_CONTAINER_heap_remove_node (n1); |
238 | GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap))); | 235 | GNUNET_assert (0 == |
239 | 236 | nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap))); | |
237 | |||
240 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 238 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
241 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); | 239 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); |
242 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); | 240 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); |
243 | 241 | ||
244 | GNUNET_CONTAINER_heap_remove_node (n2); | 242 | GNUNET_CONTAINER_heap_remove_node (n2); |
245 | GNUNET_CONTAINER_heap_remove_node (n1); | 243 | GNUNET_CONTAINER_heap_remove_node (n1); |
246 | GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3))); | 244 | GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3))); |
247 | 245 | ||
248 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); | 246 | n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); |
249 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20); | 247 | n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20); |
250 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30); | 248 | n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30); |
251 | n4 = GNUNET_CONTAINER_heap_insert (myHeap, "40", 40); | 249 | n4 = GNUNET_CONTAINER_heap_insert (myHeap, "40", 40); |
252 | n5 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50); | 250 | n5 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50); |
253 | n6 = GNUNET_CONTAINER_heap_insert (myHeap, "60", 60); | 251 | n6 = GNUNET_CONTAINER_heap_insert (myHeap, "60", 60); |
254 | 252 | ||
255 | // Inserting nodes deeper in the tree with lower costs | 253 | // Inserting nodes deeper in the tree with lower costs |
256 | n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10); | 254 | n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10); |
257 | n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10); | 255 | n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10); |
258 | 256 | ||
259 | GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3))); | 257 | GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3))); |
260 | 258 | ||
261 | // Cleaning up... | 259 | // Cleaning up... |
262 | GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6))); | 260 | GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6))); |
263 | GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5))); | 261 | GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5))); |
264 | 262 | ||
265 | // Testing heap_walk_get_next | 263 | // Testing heap_walk_get_next |
266 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); | 264 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); |
267 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); | 265 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); |
268 | GNUNET_CONTAINER_heap_walk_get_next (myHeap);; | 266 | GNUNET_CONTAINER_heap_walk_get_next (myHeap);; |
269 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); | 267 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); |
270 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); | 268 | GNUNET_CONTAINER_heap_walk_get_next (myHeap); |
271 | 269 | ||
272 | GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); | 270 | GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); |
273 | GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); | 271 | GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); |
274 | GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4))); | 272 | GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4))); |
275 | GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7))); | 273 | GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7))); |
276 | GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8))); | 274 | GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8))); |
277 | 275 | ||
278 | // End Testing remove_node | 276 | // End Testing remove_node |
279 | 277 | ||
280 | GNUNET_CONTAINER_heap_destroy (myHeap); | 278 | GNUNET_CONTAINER_heap_destroy (myHeap); |
281 | 279 | ||
282 | return 0; | 280 | return 0; |
283 | } | 281 | } |
284 | 282 | ||
@@ -287,7 +285,7 @@ int | |||
287 | main (int argc, char **argv) | 285 | main (int argc, char **argv) |
288 | { | 286 | { |
289 | GNUNET_log_setup ("test-container-heap", "WARNING", NULL); | 287 | GNUNET_log_setup ("test-container-heap", "WARNING", NULL); |
290 | return check(); | 288 | return check (); |
291 | } | 289 | } |
292 | 290 | ||
293 | /* end of test_container_heap.c */ | 291 | /* end of test_container_heap.c */ |