diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/set/test_set_union_result_symmetric.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/set/test_set_union_result_symmetric.c')
-rw-r--r-- | src/set/test_set_union_result_symmetric.c | 394 |
1 files changed, 201 insertions, 193 deletions
diff --git a/src/set/test_set_union_result_symmetric.c b/src/set/test_set_union_result_symmetric.c index 3fe7e4995..5238aa596 100644 --- a/src/set/test_set_union_result_symmetric.c +++ b/src/set/test_set_union_result_symmetric.c | |||
@@ -11,12 +11,12 @@ | |||
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 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file set/test_set_union_result_smmetric | 22 | * @file set/test_set_union_result_smmetric |
@@ -75,120 +75,128 @@ static struct GNUNET_SCHEDULER_Task *timeout_task; | |||
75 | 75 | ||
76 | 76 | ||
77 | static void | 77 | static void |
78 | result_cb_set1 (void *cls, | 78 | result_cb_set1(void *cls, |
79 | const struct GNUNET_SET_Element *element, | 79 | const struct GNUNET_SET_Element *element, |
80 | uint64_t current_size, | 80 | uint64_t current_size, |
81 | enum GNUNET_SET_Status status) | 81 | enum GNUNET_SET_Status status) |
82 | { | 82 | { |
83 | switch (status) | 83 | switch (status) |
84 | { | 84 | { |
85 | case GNUNET_SET_STATUS_ADD_LOCAL: | 85 | case GNUNET_SET_STATUS_ADD_LOCAL: |
86 | count_set1++; | 86 | count_set1++; |
87 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 87 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
88 | "set 1: got element\n"); | 88 | "set 1: got element\n"); |
89 | break; | 89 | break; |
90 | |||
90 | case GNUNET_SET_STATUS_FAILURE: | 91 | case GNUNET_SET_STATUS_FAILURE: |
91 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 92 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
92 | "set 1: failure\n"); | 93 | "set 1: failure\n"); |
93 | oh1 = NULL; | 94 | oh1 = NULL; |
94 | ret = 1; | 95 | ret = 1; |
95 | if (NULL != timeout_task) | 96 | if (NULL != timeout_task) |
96 | { | 97 | { |
97 | GNUNET_SCHEDULER_cancel (timeout_task); | 98 | GNUNET_SCHEDULER_cancel(timeout_task); |
98 | timeout_task = NULL; | 99 | timeout_task = NULL; |
99 | } | 100 | } |
100 | GNUNET_SCHEDULER_shutdown (); | 101 | GNUNET_SCHEDULER_shutdown(); |
101 | break; | 102 | break; |
103 | |||
102 | case GNUNET_SET_STATUS_DONE: | 104 | case GNUNET_SET_STATUS_DONE: |
103 | oh1 = NULL; | 105 | oh1 = NULL; |
104 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 106 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
105 | "set 1: done\n"); | 107 | "set 1: done\n"); |
106 | GNUNET_SET_destroy (set1); | 108 | GNUNET_SET_destroy(set1); |
107 | set1 = NULL; | 109 | set1 = NULL; |
108 | if (NULL == set2) | 110 | if (NULL == set2) |
109 | { | ||
110 | if (NULL != timeout_task) | ||
111 | { | 111 | { |
112 | GNUNET_SCHEDULER_cancel (timeout_task); | 112 | if (NULL != timeout_task) |
113 | timeout_task = NULL; | 113 | { |
114 | GNUNET_SCHEDULER_cancel(timeout_task); | ||
115 | timeout_task = NULL; | ||
116 | } | ||
117 | GNUNET_SCHEDULER_shutdown(); | ||
114 | } | 118 | } |
115 | GNUNET_SCHEDULER_shutdown (); | ||
116 | } | ||
117 | break; | 119 | break; |
120 | |||
118 | case GNUNET_SET_STATUS_ADD_REMOTE: | 121 | case GNUNET_SET_STATUS_ADD_REMOTE: |
119 | break; | 122 | break; |
123 | |||
120 | default: | 124 | default: |
121 | GNUNET_assert (0); | 125 | GNUNET_assert(0); |
122 | } | 126 | } |
123 | } | 127 | } |
124 | 128 | ||
125 | 129 | ||
126 | static void | 130 | static void |
127 | result_cb_set2 (void *cls, | 131 | result_cb_set2(void *cls, |
128 | const struct GNUNET_SET_Element *element, | 132 | const struct GNUNET_SET_Element *element, |
129 | uint64_t current_size, | 133 | uint64_t current_size, |
130 | enum GNUNET_SET_Status status) | 134 | enum GNUNET_SET_Status status) |
131 | { | 135 | { |
132 | switch (status) | 136 | switch (status) |
133 | { | 137 | { |
134 | case GNUNET_SET_STATUS_ADD_LOCAL: | 138 | case GNUNET_SET_STATUS_ADD_LOCAL: |
135 | count_set2++; | 139 | count_set2++; |
136 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 140 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
137 | "set 2: got element\n"); | 141 | "set 2: got element\n"); |
138 | break; | 142 | break; |
143 | |||
139 | case GNUNET_SET_STATUS_FAILURE: | 144 | case GNUNET_SET_STATUS_FAILURE: |
140 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 145 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
141 | "set 2: failure\n"); | 146 | "set 2: failure\n"); |
142 | oh2 = NULL; | 147 | oh2 = NULL; |
143 | ret = 1; | 148 | ret = 1; |
144 | if (NULL != timeout_task) | 149 | if (NULL != timeout_task) |
145 | { | 150 | { |
146 | GNUNET_SCHEDULER_cancel (timeout_task); | 151 | GNUNET_SCHEDULER_cancel(timeout_task); |
147 | timeout_task = NULL; | 152 | timeout_task = NULL; |
148 | } | 153 | } |
149 | GNUNET_SCHEDULER_shutdown (); | 154 | GNUNET_SCHEDULER_shutdown(); |
150 | break; | 155 | break; |
156 | |||
151 | case GNUNET_SET_STATUS_DONE: | 157 | case GNUNET_SET_STATUS_DONE: |
152 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 158 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
153 | "set 2: done\n"); | 159 | "set 2: done\n"); |
154 | oh2 = NULL; | 160 | oh2 = NULL; |
155 | GNUNET_SET_destroy (set2); | 161 | GNUNET_SET_destroy(set2); |
156 | set2 = NULL; | 162 | set2 = NULL; |
157 | if (NULL == set1) | 163 | if (NULL == set1) |
158 | { | ||
159 | if (NULL != timeout_task) | ||
160 | { | 164 | { |
161 | GNUNET_SCHEDULER_cancel (timeout_task); | 165 | if (NULL != timeout_task) |
162 | timeout_task = NULL; | 166 | { |
167 | GNUNET_SCHEDULER_cancel(timeout_task); | ||
168 | timeout_task = NULL; | ||
169 | } | ||
170 | GNUNET_SCHEDULER_shutdown(); | ||
163 | } | 171 | } |
164 | GNUNET_SCHEDULER_shutdown (); | ||
165 | } | ||
166 | break; | 172 | break; |
173 | |||
167 | case GNUNET_SET_STATUS_ADD_REMOTE: | 174 | case GNUNET_SET_STATUS_ADD_REMOTE: |
168 | break; | 175 | break; |
176 | |||
169 | default: | 177 | default: |
170 | GNUNET_assert (0); | 178 | GNUNET_assert(0); |
171 | } | 179 | } |
172 | } | 180 | } |
173 | 181 | ||
174 | 182 | ||
175 | static void | 183 | static void |
176 | listen_cb (void *cls, | 184 | listen_cb(void *cls, |
177 | const struct GNUNET_PeerIdentity *other_peer, | 185 | const struct GNUNET_PeerIdentity *other_peer, |
178 | const struct GNUNET_MessageHeader *context_msg, | 186 | const struct GNUNET_MessageHeader *context_msg, |
179 | struct GNUNET_SET_Request *request) | 187 | struct GNUNET_SET_Request *request) |
180 | { | 188 | { |
181 | GNUNET_assert (NULL != context_msg); | 189 | GNUNET_assert(NULL != context_msg); |
182 | GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); | 190 | GNUNET_assert(ntohs(context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); |
183 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 191 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
184 | "listen cb called\n"); | 192 | "listen cb called\n"); |
185 | oh2 = GNUNET_SET_accept (request, | 193 | oh2 = GNUNET_SET_accept(request, |
186 | GNUNET_SET_RESULT_SYMMETRIC, | 194 | GNUNET_SET_RESULT_SYMMETRIC, |
187 | (struct GNUNET_SET_Option[]) { 0 }, | 195 | (struct GNUNET_SET_Option[]) { 0 }, |
188 | &result_cb_set2, | 196 | &result_cb_set2, |
189 | NULL); | 197 | NULL); |
190 | GNUNET_SET_commit (oh2, | 198 | GNUNET_SET_commit(oh2, |
191 | set2); | 199 | set2); |
192 | } | 200 | } |
193 | 201 | ||
194 | 202 | ||
@@ -198,24 +206,24 @@ listen_cb (void *cls, | |||
198 | * @param cls closure, unused | 206 | * @param cls closure, unused |
199 | */ | 207 | */ |
200 | static void | 208 | static void |
201 | start (void *cls) | 209 | start(void *cls) |
202 | { | 210 | { |
203 | struct GNUNET_MessageHeader context_msg; | 211 | struct GNUNET_MessageHeader context_msg; |
204 | 212 | ||
205 | context_msg.size = htons (sizeof context_msg); | 213 | context_msg.size = htons(sizeof context_msg); |
206 | context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY); | 214 | context_msg.type = htons(GNUNET_MESSAGE_TYPE_DUMMY); |
207 | 215 | ||
208 | listen_handle = GNUNET_SET_listen (config, | 216 | listen_handle = GNUNET_SET_listen(config, |
209 | GNUNET_SET_OPERATION_UNION, | 217 | GNUNET_SET_OPERATION_UNION, |
210 | &app_id, | 218 | &app_id, |
211 | &listen_cb, NULL); | 219 | &listen_cb, NULL); |
212 | oh1 = GNUNET_SET_prepare (&local_id, | 220 | oh1 = GNUNET_SET_prepare(&local_id, |
213 | &app_id, | 221 | &app_id, |
214 | &context_msg, | 222 | &context_msg, |
215 | GNUNET_SET_RESULT_SYMMETRIC, | 223 | GNUNET_SET_RESULT_SYMMETRIC, |
216 | (struct GNUNET_SET_Option[]) { 0 }, | 224 | (struct GNUNET_SET_Option[]) { 0 }, |
217 | &result_cb_set1, NULL); | 225 | &result_cb_set1, NULL); |
218 | GNUNET_SET_commit (oh1, set1); | 226 | GNUNET_SET_commit(oh1, set1); |
219 | } | 227 | } |
220 | 228 | ||
221 | 229 | ||
@@ -225,35 +233,35 @@ start (void *cls) | |||
225 | * @param cls closure, unused | 233 | * @param cls closure, unused |
226 | */ | 234 | */ |
227 | static void | 235 | static void |
228 | init_set2 (void *cls) | 236 | init_set2(void *cls) |
229 | { | 237 | { |
230 | struct GNUNET_SET_Element element; | 238 | struct GNUNET_SET_Element element; |
231 | 239 | ||
232 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 240 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
233 | "initializing set 2\n"); | 241 | "initializing set 2\n"); |
234 | if (empty) | 242 | if (empty) |
235 | { | 243 | { |
236 | start (NULL); | 244 | start(NULL); |
237 | return; | 245 | return; |
238 | } | 246 | } |
239 | element.element_type = 0; | 247 | element.element_type = 0; |
240 | element.data = "hello"; | 248 | element.data = "hello"; |
241 | element.size = strlen(element.data); | 249 | element.size = strlen(element.data); |
242 | GNUNET_SET_add_element (set2, | 250 | GNUNET_SET_add_element(set2, |
243 | &element, | 251 | &element, |
244 | NULL, | 252 | NULL, |
245 | NULL); | 253 | NULL); |
246 | element.data = "quux"; | 254 | element.data = "quux"; |
247 | element.size = strlen(element.data); | 255 | element.size = strlen(element.data); |
248 | GNUNET_SET_add_element (set2, | 256 | GNUNET_SET_add_element(set2, |
249 | &element, | 257 | &element, |
250 | NULL, | 258 | NULL, |
251 | NULL); | 259 | NULL); |
252 | element.data = "baz"; | 260 | element.data = "baz"; |
253 | element.size = strlen(element.data); | 261 | element.size = strlen(element.data); |
254 | GNUNET_SET_add_element (set2, | 262 | GNUNET_SET_add_element(set2, |
255 | &element, | 263 | &element, |
256 | &start, NULL); | 264 | &start, NULL); |
257 | } | 265 | } |
258 | 266 | ||
259 | 267 | ||
@@ -261,72 +269,72 @@ init_set2 (void *cls) | |||
261 | * Initialize the first set, continue. | 269 | * Initialize the first set, continue. |
262 | */ | 270 | */ |
263 | static void | 271 | static void |
264 | init_set1 (void) | 272 | init_set1(void) |
265 | { | 273 | { |
266 | struct GNUNET_SET_Element element; | 274 | struct GNUNET_SET_Element element; |
267 | 275 | ||
268 | if (empty) | 276 | if (empty) |
269 | { | 277 | { |
270 | init_set2 (NULL); | 278 | init_set2(NULL); |
271 | return; | 279 | return; |
272 | } | 280 | } |
273 | element.element_type = 0; | 281 | element.element_type = 0; |
274 | element.data = "hello"; | 282 | element.data = "hello"; |
275 | element.size = strlen(element.data); | 283 | element.size = strlen(element.data); |
276 | GNUNET_SET_add_element (set1, | 284 | GNUNET_SET_add_element(set1, |
277 | &element, | 285 | &element, |
278 | NULL, | 286 | NULL, |
279 | NULL); | 287 | NULL); |
280 | element.data = "bar"; | 288 | element.data = "bar"; |
281 | element.size = strlen(element.data); | 289 | element.size = strlen(element.data); |
282 | GNUNET_SET_add_element (set1, | 290 | GNUNET_SET_add_element(set1, |
283 | &element, | 291 | &element, |
284 | &init_set2, | 292 | &init_set2, |
285 | NULL); | 293 | NULL); |
286 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 294 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
287 | "initialized set 1\n"); | 295 | "initialized set 1\n"); |
288 | } | 296 | } |
289 | 297 | ||
290 | 298 | ||
291 | static int | 299 | static int |
292 | iter_cb (void *cls, | 300 | iter_cb(void *cls, |
293 | const struct GNUNET_SET_Element *element) | 301 | const struct GNUNET_SET_Element *element) |
294 | { | 302 | { |
295 | if (NULL == element) | 303 | if (NULL == element) |
296 | { | 304 | { |
297 | GNUNET_assert (iter_count == 3); | 305 | GNUNET_assert(iter_count == 3); |
298 | GNUNET_SET_destroy (cls); | 306 | GNUNET_SET_destroy(cls); |
299 | return GNUNET_YES; | 307 | return GNUNET_YES; |
300 | } | 308 | } |
301 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 309 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
302 | "iter: got element\n"); | 310 | "iter: got element\n"); |
303 | iter_count++; | 311 | iter_count++; |
304 | return GNUNET_YES; | 312 | return GNUNET_YES; |
305 | } | 313 | } |
306 | 314 | ||
307 | 315 | ||
308 | static void | 316 | static void |
309 | test_iter () | 317 | test_iter() |
310 | { | 318 | { |
311 | struct GNUNET_SET_Element element; | 319 | struct GNUNET_SET_Element element; |
312 | struct GNUNET_SET_Handle *iter_set; | 320 | struct GNUNET_SET_Handle *iter_set; |
313 | 321 | ||
314 | iter_count = 0; | 322 | iter_count = 0; |
315 | iter_set = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION); | 323 | iter_set = GNUNET_SET_create(config, GNUNET_SET_OPERATION_UNION); |
316 | element.element_type = 0; | 324 | element.element_type = 0; |
317 | element.data = "hello"; | 325 | element.data = "hello"; |
318 | element.size = strlen(element.data); | 326 | element.size = strlen(element.data); |
319 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); | 327 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); |
320 | element.data = "bar"; | 328 | element.data = "bar"; |
321 | element.size = strlen(element.data); | 329 | element.size = strlen(element.data); |
322 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); | 330 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); |
323 | element.data = "quux"; | 331 | element.data = "quux"; |
324 | element.size = strlen(element.data); | 332 | element.size = strlen(element.data); |
325 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); | 333 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); |
326 | 334 | ||
327 | GNUNET_SET_iterate (iter_set, | 335 | GNUNET_SET_iterate(iter_set, |
328 | &iter_cb, | 336 | &iter_cb, |
329 | iter_set); | 337 | iter_set); |
330 | } | 338 | } |
331 | 339 | ||
332 | 340 | ||
@@ -336,12 +344,12 @@ test_iter () | |||
336 | * @param cls closure | 344 | * @param cls closure |
337 | */ | 345 | */ |
338 | static void | 346 | static void |
339 | timeout_fail (void *cls) | 347 | timeout_fail(void *cls) |
340 | { | 348 | { |
341 | timeout_task = NULL; | 349 | timeout_task = NULL; |
342 | GNUNET_SCHEDULER_shutdown (); | 350 | GNUNET_SCHEDULER_shutdown(); |
343 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 351 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
344 | "test timed out\n"); | 352 | "test timed out\n"); |
345 | ret = 1; | 353 | ret = 1; |
346 | } | 354 | } |
347 | 355 | ||
@@ -352,38 +360,38 @@ timeout_fail (void *cls) | |||
352 | * @param cls closure | 360 | * @param cls closure |
353 | */ | 361 | */ |
354 | static void | 362 | static void |
355 | do_shutdown (void *cls) | 363 | do_shutdown(void *cls) |
356 | { | 364 | { |
357 | if (NULL != timeout_task) | 365 | if (NULL != timeout_task) |
358 | { | 366 | { |
359 | GNUNET_SCHEDULER_cancel (timeout_task); | 367 | GNUNET_SCHEDULER_cancel(timeout_task); |
360 | timeout_task = NULL; | 368 | timeout_task = NULL; |
361 | } | 369 | } |
362 | if (NULL != oh1) | 370 | if (NULL != oh1) |
363 | { | 371 | { |
364 | GNUNET_SET_operation_cancel (oh1); | 372 | GNUNET_SET_operation_cancel(oh1); |
365 | oh1 = NULL; | 373 | oh1 = NULL; |
366 | } | 374 | } |
367 | if (NULL != oh2) | 375 | if (NULL != oh2) |
368 | { | 376 | { |
369 | GNUNET_SET_operation_cancel (oh2); | 377 | GNUNET_SET_operation_cancel(oh2); |
370 | oh2 = NULL; | 378 | oh2 = NULL; |
371 | } | 379 | } |
372 | if (NULL != set1) | 380 | if (NULL != set1) |
373 | { | 381 | { |
374 | GNUNET_SET_destroy (set1); | 382 | GNUNET_SET_destroy(set1); |
375 | set1 = NULL; | 383 | set1 = NULL; |
376 | } | 384 | } |
377 | if (NULL != set2) | 385 | if (NULL != set2) |
378 | { | 386 | { |
379 | GNUNET_SET_destroy (set2); | 387 | GNUNET_SET_destroy(set2); |
380 | set2 = NULL; | 388 | set2 = NULL; |
381 | } | 389 | } |
382 | if (NULL != listen_handle) | 390 | if (NULL != listen_handle) |
383 | { | 391 | { |
384 | GNUNET_SET_listen_cancel (listen_handle); | 392 | GNUNET_SET_listen_cancel(listen_handle); |
385 | listen_handle = NULL; | 393 | listen_handle = NULL; |
386 | } | 394 | } |
387 | } | 395 | } |
388 | 396 | ||
389 | 397 | ||
@@ -396,51 +404,51 @@ do_shutdown (void *cls) | |||
396 | * @param peer identity of the peer that was created | 404 | * @param peer identity of the peer that was created |
397 | */ | 405 | */ |
398 | static void | 406 | static void |
399 | run (void *cls, | 407 | run(void *cls, |
400 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 408 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
401 | struct GNUNET_TESTING_Peer *peer) | 409 | struct GNUNET_TESTING_Peer *peer) |
402 | { | 410 | { |
403 | timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5), | 411 | timeout_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), |
404 | &timeout_fail, | 412 | &timeout_fail, |
405 | NULL); | 413 | NULL); |
406 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, | 414 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, |
407 | NULL); | 415 | NULL); |
408 | config = cfg; | 416 | config = cfg; |
409 | GNUNET_TESTING_peer_get_identity (peer, | 417 | GNUNET_TESTING_peer_get_identity(peer, |
410 | &local_id); | 418 | &local_id); |
411 | 419 | ||
412 | if (0) | 420 | if (0) |
413 | test_iter (); | 421 | test_iter(); |
414 | 422 | ||
415 | set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION); | 423 | set1 = GNUNET_SET_create(cfg, GNUNET_SET_OPERATION_UNION); |
416 | set2 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION); | 424 | set2 = GNUNET_SET_create(cfg, GNUNET_SET_OPERATION_UNION); |
417 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id); | 425 | GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &app_id); |
418 | 426 | ||
419 | /* test the real set reconciliation */ | 427 | /* test the real set reconciliation */ |
420 | init_set1 (); | 428 | init_set1(); |
421 | } | 429 | } |
422 | 430 | ||
423 | 431 | ||
424 | int | 432 | int |
425 | main (int argc, char **argv) | 433 | main(int argc, char **argv) |
426 | { | 434 | { |
427 | empty = 1; | 435 | empty = 1; |
428 | if (0 != GNUNET_TESTING_peer_run ("test_set_api", | 436 | if (0 != GNUNET_TESTING_peer_run("test_set_api", |
429 | "test_set.conf", | 437 | "test_set.conf", |
430 | &run, NULL)) | 438 | &run, NULL)) |
431 | { | 439 | { |
432 | return 1; | 440 | return 1; |
433 | } | 441 | } |
434 | GNUNET_assert (0 == count_set1); | 442 | GNUNET_assert(0 == count_set1); |
435 | GNUNET_assert (0 == count_set2); | 443 | GNUNET_assert(0 == count_set2); |
436 | empty = 0; | 444 | empty = 0; |
437 | if (0 != GNUNET_TESTING_peer_run ("test_set_api", | 445 | if (0 != GNUNET_TESTING_peer_run("test_set_api", |
438 | "test_set.conf", | 446 | "test_set.conf", |
439 | &run, NULL)) | 447 | &run, NULL)) |
440 | { | 448 | { |
441 | return 1; | 449 | return 1; |
442 | } | 450 | } |
443 | GNUNET_break (2 == count_set1); | 451 | GNUNET_break(2 == count_set1); |
444 | GNUNET_break (1 == count_set2); | 452 | GNUNET_break(1 == count_set2); |
445 | return ret; | 453 | return ret; |
446 | } | 454 | } |