aboutsummaryrefslogtreecommitdiff
path: root/src/util/test_container_heap.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/util/test_container_heap.c')
-rw-r--r--src/util/test_container_heap.c382
1 files changed, 191 insertions, 191 deletions
diff --git a/src/util/test_container_heap.c b/src/util/test_container_heap.c
index f95032ca0..8df6553b6 100644
--- a/src/util/test_container_heap.c
+++ b/src/util/test_container_heap.c
@@ -1,19 +1,19 @@
1/* 1/*
2 This file is part of GNUnet. 2 This file is part of GNUnet.
3 Copyright (C) 2008 GNUnet e.V. 3 Copyright (C) 2008 GNUnet e.V.
4 4
5 GNUnet is free software: you can redistribute it and/or modify it 5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published 6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License, 7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version. 8 or (at your option) any later version.
9 9
10 GNUnet is distributed in the hope that it will be useful, but 10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19 */ 19 */
@@ -28,23 +28,23 @@
28#include "gnunet_util_lib.h" 28#include "gnunet_util_lib.h"
29 29
30static int 30static int
31iterator_callback (void *cls, 31iterator_callback(void *cls,
32 struct GNUNET_CONTAINER_HeapNode *node, 32 struct GNUNET_CONTAINER_HeapNode *node,
33 void *element, GNUNET_CONTAINER_HeapCostType cost) 33 void *element, GNUNET_CONTAINER_HeapCostType cost)
34{ 34{
35 return GNUNET_OK; 35 return GNUNET_OK;
36} 36}
37 37
38static int 38static int
39nstrcmp (const char *a, const char *b) 39nstrcmp(const char *a, const char *b)
40{ 40{
41 GNUNET_assert (a != NULL); 41 GNUNET_assert(a != NULL);
42 GNUNET_assert (b != NULL); 42 GNUNET_assert(b != NULL);
43 return strcmp (a, b); 43 return strcmp(a, b);
44} 44}
45 45
46static int 46static int
47check () 47check()
48{ 48{
49 struct GNUNET_CONTAINER_Heap *myHeap; 49 struct GNUNET_CONTAINER_Heap *myHeap;
50 struct GNUNET_CONTAINER_HeapNode *n1; 50 struct GNUNET_CONTAINER_HeapNode *n1;
@@ -57,234 +57,234 @@ check ()
57 struct GNUNET_CONTAINER_HeapNode *n8; 57 struct GNUNET_CONTAINER_HeapNode *n8;
58 const char *r; 58 const char *r;
59 59
60 myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); 60 myHeap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
61 61
62 // GNUNET_CONTAINER_heap_remove_root heap empty, taking if-branch 62 // GNUNET_CONTAINER_heap_remove_root heap empty, taking if-branch
63 n1 = GNUNET_CONTAINER_heap_remove_root (myHeap); 63 n1 = GNUNET_CONTAINER_heap_remove_root(myHeap);
64 GNUNET_assert (NULL == n1); 64 GNUNET_assert(NULL == n1);
65 65
66 // GNUNET_CONTAINER_heap_peek heap empty, taking if-branch 66 // GNUNET_CONTAINER_heap_peek heap empty, taking if-branch
67 n1 = GNUNET_CONTAINER_heap_peek (myHeap); 67 n1 = GNUNET_CONTAINER_heap_peek(myHeap);
68 GNUNET_assert (NULL == n1); 68 GNUNET_assert(NULL == n1);
69 69
70 // GNUNET_CONTAINER_heap_walk_get_next: heap empty, taking if-branch 70 // GNUNET_CONTAINER_heap_walk_get_next: heap empty, taking if-branch
71 n1 = GNUNET_CONTAINER_heap_walk_get_next (myHeap); 71 n1 = GNUNET_CONTAINER_heap_walk_get_next(myHeap);
72 GNUNET_assert (NULL == n1); 72 GNUNET_assert(NULL == n1);
73 73
74 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "11", 11); 74 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "11", 11);
75 GNUNET_assert (NULL != n1); 75 GNUNET_assert(NULL != n1);
76 76
77 77
78 // GNUNET_CONTAINER_heap_peek not empty, taking if-branch 78 // GNUNET_CONTAINER_heap_peek not empty, taking if-branch
79 n2 = NULL; 79 n2 = NULL;
80 n2 = GNUNET_CONTAINER_heap_peek (myHeap); 80 n2 = GNUNET_CONTAINER_heap_peek(myHeap);
81 GNUNET_assert (NULL != n2); 81 GNUNET_assert(NULL != n2);
82 82
83 // GNUNET_CONTAINER_heap_walk_get_next: 1 element 83 // GNUNET_CONTAINER_heap_walk_get_next: 1 element
84 n1 = NULL; 84 n1 = NULL;
85 n1 = GNUNET_CONTAINER_heap_walk_get_next (myHeap); 85 n1 = GNUNET_CONTAINER_heap_walk_get_next(myHeap);
86 GNUNET_assert (NULL != n1); 86 GNUNET_assert(NULL != n1);
87 87
88 GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL); 88 GNUNET_CONTAINER_heap_iterate(myHeap, &iterator_callback, NULL);
89 GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap)); 89 GNUNET_assert(1 == GNUNET_CONTAINER_heap_get_size(myHeap));
90 n2 = GNUNET_CONTAINER_heap_insert (myHeap, "78", 78); 90 n2 = GNUNET_CONTAINER_heap_insert(myHeap, "78", 78);
91 GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap)); 91 GNUNET_assert(2 == GNUNET_CONTAINER_heap_get_size(myHeap));
92 GNUNET_assert (0 == strcmp ("78", GNUNET_CONTAINER_heap_remove_node (n2))); 92 GNUNET_assert(0 == strcmp("78", GNUNET_CONTAINER_heap_remove_node(n2)));
93 GNUNET_assert (1 == GNUNET_CONTAINER_heap_get_size (myHeap)); 93 GNUNET_assert(1 == GNUNET_CONTAINER_heap_get_size(myHeap));
94 GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL); 94 GNUNET_CONTAINER_heap_iterate(myHeap, &iterator_callback, NULL);
95 95
96 n3 = GNUNET_CONTAINER_heap_insert (myHeap, "15", 5); 96 n3 = GNUNET_CONTAINER_heap_insert(myHeap, "15", 5);
97 GNUNET_CONTAINER_heap_update_cost (n3, 15); 97 GNUNET_CONTAINER_heap_update_cost(n3, 15);
98 GNUNET_assert (2 == GNUNET_CONTAINER_heap_get_size (myHeap)); 98 GNUNET_assert(2 == GNUNET_CONTAINER_heap_get_size(myHeap));
99 GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL); 99 GNUNET_CONTAINER_heap_iterate(myHeap, &iterator_callback, NULL);
100 100
101 n4 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50); 101 n4 = GNUNET_CONTAINER_heap_insert(myHeap, "50", 50);
102 GNUNET_CONTAINER_heap_update_cost (n4, 50); 102 GNUNET_CONTAINER_heap_update_cost(n4, 50);
103 GNUNET_assert (3 == GNUNET_CONTAINER_heap_get_size (myHeap)); 103 GNUNET_assert(3 == GNUNET_CONTAINER_heap_get_size(myHeap));
104 GNUNET_CONTAINER_heap_iterate (myHeap, &iterator_callback, NULL); 104 GNUNET_CONTAINER_heap_iterate(myHeap, &iterator_callback, NULL);
105 105
106 n5 = GNUNET_CONTAINER_heap_insert (myHeap, "100", 100); 106 n5 = GNUNET_CONTAINER_heap_insert(myHeap, "100", 100);
107 n6 = GNUNET_CONTAINER_heap_insert (myHeap, "30/200", 30); 107 n6 = GNUNET_CONTAINER_heap_insert(myHeap, "30/200", 30);
108 GNUNET_assert (5 == GNUNET_CONTAINER_heap_get_size (myHeap)); 108 GNUNET_assert(5 == GNUNET_CONTAINER_heap_get_size(myHeap));
109 GNUNET_CONTAINER_heap_remove_node (n5); 109 GNUNET_CONTAINER_heap_remove_node(n5);
110 r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n1 */ 110 r = GNUNET_CONTAINER_heap_remove_root(myHeap); /* n1 */
111 GNUNET_assert (NULL != r); 111 GNUNET_assert(NULL != r);
112 GNUNET_assert (0 == strcmp ("11", r)); 112 GNUNET_assert(0 == strcmp("11", r));
113 GNUNET_CONTAINER_heap_update_cost (n6, 200); 113 GNUNET_CONTAINER_heap_update_cost(n6, 200);
114 GNUNET_CONTAINER_heap_remove_node (n3); 114 GNUNET_CONTAINER_heap_remove_node(n3);
115 r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n4 */ 115 r = GNUNET_CONTAINER_heap_remove_root(myHeap); /* n4 */
116 GNUNET_assert (NULL != r); 116 GNUNET_assert(NULL != r);
117 GNUNET_assert (0 == strcmp ("50", r)); 117 GNUNET_assert(0 == strcmp("50", r));
118 r = GNUNET_CONTAINER_heap_remove_root (myHeap); /* n6 */ 118 r = GNUNET_CONTAINER_heap_remove_root(myHeap); /* n6 */
119 GNUNET_assert (NULL != r); 119 GNUNET_assert(NULL != r);
120 GNUNET_assert (0 == strcmp ("30/200", r)); 120 GNUNET_assert(0 == strcmp("30/200", r));
121 GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (myHeap)); 121 GNUNET_assert(0 == GNUNET_CONTAINER_heap_get_size(myHeap));
122 122
123 GNUNET_CONTAINER_heap_destroy (myHeap); 123 GNUNET_CONTAINER_heap_destroy(myHeap);
124 124
125 // My additions to a complete testcase 125 // My additions to a complete testcase
126 // Testing a GNUNET_CONTAINER_HEAP_ORDER_MIN 126 // Testing a GNUNET_CONTAINER_HEAP_ORDER_MIN
127 // Testing remove_node 127 // Testing remove_node
128 128
129 myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); 129 myHeap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
130 130
131 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 131 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
132 GNUNET_CONTAINER_heap_update_cost (n1, 15); 132 GNUNET_CONTAINER_heap_update_cost(n1, 15);
133 133
134 r = GNUNET_CONTAINER_heap_remove_node (n1); 134 r = GNUNET_CONTAINER_heap_remove_node(n1);
135 GNUNET_assert (NULL != r); 135 GNUNET_assert(NULL != r);
136 GNUNET_assert (0 == strcmp ("10", r)); 136 GNUNET_assert(0 == strcmp("10", r));
137 137
138 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 138 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
139 n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); 139 n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
140 140
141 GNUNET_CONTAINER_heap_walk_get_next (myHeap); 141 GNUNET_CONTAINER_heap_walk_get_next(myHeap);
142 r = GNUNET_CONTAINER_heap_remove_node (n2); 142 r = GNUNET_CONTAINER_heap_remove_node(n2);
143 GNUNET_assert (NULL != r); 143 GNUNET_assert(NULL != r);
144 GNUNET_assert (0 == strcmp ("20", r)); 144 GNUNET_assert(0 == strcmp("20", r));
145 r = GNUNET_CONTAINER_heap_remove_node (n1); 145 r = GNUNET_CONTAINER_heap_remove_node(n1);
146 GNUNET_assert (NULL != r); 146 GNUNET_assert(NULL != r);
147 GNUNET_assert (0 == strcmp ("10", r)); 147 GNUNET_assert(0 == strcmp("10", r));
148 148
149 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 149 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
150 n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); 150 n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
151 n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); 151 n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 10);
152 152
153 GNUNET_CONTAINER_heap_remove_node (n2); 153 GNUNET_CONTAINER_heap_remove_node(n2);
154 GNUNET_CONTAINER_heap_remove_node (n1); 154 GNUNET_CONTAINER_heap_remove_node(n1);
155 r = GNUNET_CONTAINER_heap_remove_root (myHeap); 155 r = GNUNET_CONTAINER_heap_remove_root(myHeap);
156 GNUNET_assert (NULL != r); 156 GNUNET_assert(NULL != r);
157 GNUNET_assert (0 == strcmp ("30", r)); 157 GNUNET_assert(0 == strcmp("30", r));
158 158
159 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 159 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
160 n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); 160 n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
161 n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); 161 n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 10);
162 162
163 GNUNET_CONTAINER_heap_remove_node (n2); 163 GNUNET_CONTAINER_heap_remove_node(n2);
164 GNUNET_CONTAINER_heap_remove_node (n1); 164 GNUNET_CONTAINER_heap_remove_node(n1);
165 r = GNUNET_CONTAINER_heap_remove_node (n3); 165 r = GNUNET_CONTAINER_heap_remove_node(n3);
166 GNUNET_assert (NULL != r); 166 GNUNET_assert(NULL != r);
167 GNUNET_assert (0 == strcmp ("30", r)); 167 GNUNET_assert(0 == strcmp("30", r));
168 168
169 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 169 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
170 n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20); 170 n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 20);
171 n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30); 171 n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 30);
172 172
173 GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); 173 GNUNET_assert(0 == nstrcmp("20", GNUNET_CONTAINER_heap_remove_node(n2)));
174 GNUNET_assert (0 == 174 GNUNET_assert(0 ==
175 nstrcmp ("10", GNUNET_CONTAINER_heap_remove_root (myHeap))); 175 nstrcmp("10", GNUNET_CONTAINER_heap_remove_root(myHeap)));
176 GNUNET_assert (0 == 176 GNUNET_assert(0 ==
177 nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap))); 177 nstrcmp("30", GNUNET_CONTAINER_heap_remove_root(myHeap)));
178 178
179 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 179 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
180 n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20); 180 n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 20);
181 n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30); 181 n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 30);
182 n4 = GNUNET_CONTAINER_heap_insert (myHeap, "40", 40); 182 n4 = GNUNET_CONTAINER_heap_insert(myHeap, "40", 40);
183 n5 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50); 183 n5 = GNUNET_CONTAINER_heap_insert(myHeap, "50", 50);
184 n6 = GNUNET_CONTAINER_heap_insert (myHeap, "60", 60); 184 n6 = GNUNET_CONTAINER_heap_insert(myHeap, "60", 60);
185 185
186 // Inserting nodes deeper in the tree with lower costs 186 // Inserting nodes deeper in the tree with lower costs
187 n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10); 187 n7 = GNUNET_CONTAINER_heap_insert(myHeap, "70", 10);
188 n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10); 188 n8 = GNUNET_CONTAINER_heap_insert(myHeap, "80", 10);
189 189
190 GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3))); 190 GNUNET_assert(0 == nstrcmp("30", GNUNET_CONTAINER_heap_remove_node(n3)));
191 191
192 // Cleaning up... 192 // Cleaning up...
193 GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6))); 193 GNUNET_assert(0 == nstrcmp("60", GNUNET_CONTAINER_heap_remove_node(n6)));
194 GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5))); 194 GNUNET_assert(0 == nstrcmp("50", GNUNET_CONTAINER_heap_remove_node(n5)));
195 195
196 // Testing heap_walk_get_next 196 // Testing heap_walk_get_next
197 GNUNET_CONTAINER_heap_walk_get_next (myHeap); 197 GNUNET_CONTAINER_heap_walk_get_next(myHeap);
198 GNUNET_CONTAINER_heap_walk_get_next (myHeap); 198 GNUNET_CONTAINER_heap_walk_get_next(myHeap);
199 GNUNET_CONTAINER_heap_walk_get_next (myHeap);; 199 GNUNET_CONTAINER_heap_walk_get_next(myHeap);;
200 GNUNET_CONTAINER_heap_walk_get_next (myHeap); 200 GNUNET_CONTAINER_heap_walk_get_next(myHeap);
201 GNUNET_CONTAINER_heap_walk_get_next (myHeap); 201 GNUNET_CONTAINER_heap_walk_get_next(myHeap);
202 202
203 GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); 203 GNUNET_assert(0 == nstrcmp("10", GNUNET_CONTAINER_heap_remove_node(n1)));
204 GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); 204 GNUNET_assert(0 == nstrcmp("20", GNUNET_CONTAINER_heap_remove_node(n2)));
205 GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4))); 205 GNUNET_assert(0 == nstrcmp("40", GNUNET_CONTAINER_heap_remove_node(n4)));
206 GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7))); 206 GNUNET_assert(0 == nstrcmp("70", GNUNET_CONTAINER_heap_remove_node(n7)));
207 GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8))); 207 GNUNET_assert(0 == nstrcmp("80", GNUNET_CONTAINER_heap_remove_node(n8)));
208 208
209 // End Testing remove_node 209 // End Testing remove_node
210 210
211 // Testing a GNUNET_CONTAINER_HEAP_ORDER_MAX 211 // Testing a GNUNET_CONTAINER_HEAP_ORDER_MAX
212 GNUNET_CONTAINER_heap_destroy (myHeap); 212 GNUNET_CONTAINER_heap_destroy(myHeap);
213 213
214 myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX); 214 myHeap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MAX);
215 215
216 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 216 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
217 GNUNET_CONTAINER_heap_update_cost (n1, 15); 217 GNUNET_CONTAINER_heap_update_cost(n1, 15);
218 218
219 GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); 219 GNUNET_assert(0 == nstrcmp("10", GNUNET_CONTAINER_heap_remove_node(n1)));
220 220
221 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 221 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
222 n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); 222 n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
223 223
224 GNUNET_CONTAINER_heap_walk_get_next (myHeap); 224 GNUNET_CONTAINER_heap_walk_get_next(myHeap);
225 GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); 225 GNUNET_assert(0 == nstrcmp("20", GNUNET_CONTAINER_heap_remove_node(n2)));
226 GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); 226 GNUNET_assert(0 == nstrcmp("10", GNUNET_CONTAINER_heap_remove_node(n1)));
227 227
228 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 228 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
229 n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); 229 n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
230 n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); 230 n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 10);
231 231
232 GNUNET_CONTAINER_heap_remove_node (n2); 232 GNUNET_CONTAINER_heap_remove_node(n2);
233 GNUNET_CONTAINER_heap_remove_node (n1); 233 GNUNET_CONTAINER_heap_remove_node(n1);
234 GNUNET_assert (0 == 234 GNUNET_assert(0 ==
235 nstrcmp ("30", GNUNET_CONTAINER_heap_remove_root (myHeap))); 235 nstrcmp("30", GNUNET_CONTAINER_heap_remove_root(myHeap)));
236 236
237 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 237 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
238 n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 10); 238 n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 10);
239 n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 10); 239 n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 10);
240 240
241 GNUNET_CONTAINER_heap_remove_node (n2); 241 GNUNET_CONTAINER_heap_remove_node(n2);
242 GNUNET_CONTAINER_heap_remove_node (n1); 242 GNUNET_CONTAINER_heap_remove_node(n1);
243 GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3))); 243 GNUNET_assert(0 == nstrcmp("30", GNUNET_CONTAINER_heap_remove_node(n3)));
244 244
245 n1 = GNUNET_CONTAINER_heap_insert (myHeap, "10", 10); 245 n1 = GNUNET_CONTAINER_heap_insert(myHeap, "10", 10);
246 n2 = GNUNET_CONTAINER_heap_insert (myHeap, "20", 20); 246 n2 = GNUNET_CONTAINER_heap_insert(myHeap, "20", 20);
247 n3 = GNUNET_CONTAINER_heap_insert (myHeap, "30", 30); 247 n3 = GNUNET_CONTAINER_heap_insert(myHeap, "30", 30);
248 n4 = GNUNET_CONTAINER_heap_insert (myHeap, "40", 40); 248 n4 = GNUNET_CONTAINER_heap_insert(myHeap, "40", 40);
249 n5 = GNUNET_CONTAINER_heap_insert (myHeap, "50", 50); 249 n5 = GNUNET_CONTAINER_heap_insert(myHeap, "50", 50);
250 n6 = GNUNET_CONTAINER_heap_insert (myHeap, "60", 60); 250 n6 = GNUNET_CONTAINER_heap_insert(myHeap, "60", 60);
251 251
252 // Inserting nodes deeper in the tree with lower costs 252 // Inserting nodes deeper in the tree with lower costs
253 n7 = GNUNET_CONTAINER_heap_insert (myHeap, "70", 10); 253 n7 = GNUNET_CONTAINER_heap_insert(myHeap, "70", 10);
254 n8 = GNUNET_CONTAINER_heap_insert (myHeap, "80", 10); 254 n8 = GNUNET_CONTAINER_heap_insert(myHeap, "80", 10);
255 255
256 GNUNET_assert (0 == nstrcmp ("30", GNUNET_CONTAINER_heap_remove_node (n3))); 256 GNUNET_assert(0 == nstrcmp("30", GNUNET_CONTAINER_heap_remove_node(n3)));
257 257
258 // Cleaning up... 258 // Cleaning up...
259 GNUNET_assert (0 == nstrcmp ("60", GNUNET_CONTAINER_heap_remove_node (n6))); 259 GNUNET_assert(0 == nstrcmp("60", GNUNET_CONTAINER_heap_remove_node(n6)));
260 GNUNET_assert (0 == nstrcmp ("50", GNUNET_CONTAINER_heap_remove_node (n5))); 260 GNUNET_assert(0 == nstrcmp("50", GNUNET_CONTAINER_heap_remove_node(n5)));
261 261
262 // Testing heap_walk_get_next 262 // Testing heap_walk_get_next
263 GNUNET_CONTAINER_heap_walk_get_next (myHeap); 263 GNUNET_CONTAINER_heap_walk_get_next(myHeap);
264 GNUNET_CONTAINER_heap_walk_get_next (myHeap); 264 GNUNET_CONTAINER_heap_walk_get_next(myHeap);
265 GNUNET_CONTAINER_heap_walk_get_next (myHeap);; 265 GNUNET_CONTAINER_heap_walk_get_next(myHeap);;
266 GNUNET_CONTAINER_heap_walk_get_next (myHeap); 266 GNUNET_CONTAINER_heap_walk_get_next(myHeap);
267 GNUNET_CONTAINER_heap_walk_get_next (myHeap); 267 GNUNET_CONTAINER_heap_walk_get_next(myHeap);
268 268
269 GNUNET_assert (0 == nstrcmp ("10", GNUNET_CONTAINER_heap_remove_node (n1))); 269 GNUNET_assert(0 == nstrcmp("10", GNUNET_CONTAINER_heap_remove_node(n1)));
270 GNUNET_assert (0 == nstrcmp ("20", GNUNET_CONTAINER_heap_remove_node (n2))); 270 GNUNET_assert(0 == nstrcmp("20", GNUNET_CONTAINER_heap_remove_node(n2)));
271 GNUNET_assert (0 == nstrcmp ("40", GNUNET_CONTAINER_heap_remove_node (n4))); 271 GNUNET_assert(0 == nstrcmp("40", GNUNET_CONTAINER_heap_remove_node(n4)));
272 GNUNET_assert (0 == nstrcmp ("70", GNUNET_CONTAINER_heap_remove_node (n7))); 272 GNUNET_assert(0 == nstrcmp("70", GNUNET_CONTAINER_heap_remove_node(n7)));
273 GNUNET_assert (0 == nstrcmp ("80", GNUNET_CONTAINER_heap_remove_node (n8))); 273 GNUNET_assert(0 == nstrcmp("80", GNUNET_CONTAINER_heap_remove_node(n8)));
274 274
275 // End Testing remove_node 275 // End Testing remove_node
276 276
277 GNUNET_CONTAINER_heap_destroy (myHeap); 277 GNUNET_CONTAINER_heap_destroy(myHeap);
278 278
279 return 0; 279 return 0;
280} 280}
281 281
282 282
283int 283int
284main (int argc, char **argv) 284main(int argc, char **argv)
285{ 285{
286 GNUNET_log_setup ("test-container-heap", "WARNING", NULL); 286 GNUNET_log_setup("test-container-heap", "WARNING", NULL);
287 return check (); 287 return check();
288} 288}
289 289
290/* end of test_container_heap.c */ 290/* end of test_container_heap.c */
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-19 23:54:53 +0000