diff options
Diffstat (limited to 'src/set/test_set_api.c')
-rw-r--r-- | src/set/test_set_api.c | 411 |
1 files changed, 208 insertions, 203 deletions
diff --git a/src/set/test_set_api.c b/src/set/test_set_api.c index 0f2b20a01..7cfa222b1 100644 --- a/src/set/test_set_api.c +++ b/src/set/test_set_api.c | |||
@@ -16,7 +16,7 @@ | |||
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_api.c | 22 | * @file set/test_set_api.c |
@@ -53,100 +53,106 @@ static struct GNUNET_SCHEDULER_Task *tt; | |||
53 | 53 | ||
54 | 54 | ||
55 | static void | 55 | static void |
56 | result_cb_set1 (void *cls, | 56 | result_cb_set1(void *cls, |
57 | const struct GNUNET_SET_Element *element, | 57 | const struct GNUNET_SET_Element *element, |
58 | uint64_t size, | 58 | uint64_t size, |
59 | enum GNUNET_SET_Status status) | 59 | enum GNUNET_SET_Status status) |
60 | { | 60 | { |
61 | switch (status) | 61 | switch (status) |
62 | { | ||
63 | case GNUNET_SET_STATUS_OK: | ||
64 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: got element\n"); | ||
65 | break; | ||
66 | case GNUNET_SET_STATUS_FAILURE: | ||
67 | GNUNET_break (0); | ||
68 | oh1 = NULL; | ||
69 | fprintf (stderr, "set 1: received failure status!\n"); | ||
70 | ret = 1; | ||
71 | if (NULL != tt) | ||
72 | { | ||
73 | GNUNET_SCHEDULER_cancel (tt); | ||
74 | tt = NULL; | ||
75 | } | ||
76 | GNUNET_SCHEDULER_shutdown (); | ||
77 | break; | ||
78 | case GNUNET_SET_STATUS_DONE: | ||
79 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: done\n"); | ||
80 | oh1 = NULL; | ||
81 | if (NULL != set1) | ||
82 | { | 62 | { |
83 | GNUNET_SET_destroy (set1); | 63 | case GNUNET_SET_STATUS_OK: |
84 | set1 = NULL; | 64 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "set 1: got element\n"); |
85 | } | 65 | break; |
86 | if (NULL == set2) | 66 | |
87 | { | 67 | case GNUNET_SET_STATUS_FAILURE: |
88 | GNUNET_SCHEDULER_cancel (tt); | 68 | GNUNET_break(0); |
89 | tt = NULL; | 69 | oh1 = NULL; |
90 | GNUNET_SCHEDULER_shutdown (); | 70 | fprintf(stderr, "set 1: received failure status!\n"); |
71 | ret = 1; | ||
72 | if (NULL != tt) | ||
73 | { | ||
74 | GNUNET_SCHEDULER_cancel(tt); | ||
75 | tt = NULL; | ||
76 | } | ||
77 | GNUNET_SCHEDULER_shutdown(); | ||
78 | break; | ||
79 | |||
80 | case GNUNET_SET_STATUS_DONE: | ||
81 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "set 1: done\n"); | ||
82 | oh1 = NULL; | ||
83 | if (NULL != set1) | ||
84 | { | ||
85 | GNUNET_SET_destroy(set1); | ||
86 | set1 = NULL; | ||
87 | } | ||
88 | if (NULL == set2) | ||
89 | { | ||
90 | GNUNET_SCHEDULER_cancel(tt); | ||
91 | tt = NULL; | ||
92 | GNUNET_SCHEDULER_shutdown(); | ||
93 | } | ||
94 | break; | ||
95 | |||
96 | default: | ||
97 | GNUNET_assert(0); | ||
91 | } | 98 | } |
92 | break; | ||
93 | default: | ||
94 | GNUNET_assert (0); | ||
95 | } | ||
96 | } | 99 | } |
97 | 100 | ||
98 | 101 | ||
99 | static void | 102 | static void |
100 | result_cb_set2 (void *cls, | 103 | result_cb_set2(void *cls, |
101 | const struct GNUNET_SET_Element *element, | 104 | const struct GNUNET_SET_Element *element, |
102 | uint64_t size, | 105 | uint64_t size, |
103 | enum GNUNET_SET_Status status) | 106 | enum GNUNET_SET_Status status) |
104 | { | 107 | { |
105 | switch (status) | 108 | switch (status) |
106 | { | ||
107 | case GNUNET_SET_STATUS_OK: | ||
108 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: got element\n"); | ||
109 | break; | ||
110 | case GNUNET_SET_STATUS_FAILURE: | ||
111 | GNUNET_break (0); | ||
112 | oh2 = NULL; | ||
113 | fprintf (stderr, "set 2: received failure status\n"); | ||
114 | GNUNET_SCHEDULER_shutdown (); | ||
115 | ret = 1; | ||
116 | break; | ||
117 | case GNUNET_SET_STATUS_DONE: | ||
118 | oh2 = NULL; | ||
119 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: done\n"); | ||
120 | GNUNET_SET_destroy (set2); | ||
121 | set2 = NULL; | ||
122 | if (NULL == set1) | ||
123 | { | 109 | { |
124 | GNUNET_SCHEDULER_cancel (tt); | 110 | case GNUNET_SET_STATUS_OK: |
125 | tt = NULL; | 111 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "set 2: got element\n"); |
126 | GNUNET_SCHEDULER_shutdown (); | 112 | break; |
113 | |||
114 | case GNUNET_SET_STATUS_FAILURE: | ||
115 | GNUNET_break(0); | ||
116 | oh2 = NULL; | ||
117 | fprintf(stderr, "set 2: received failure status\n"); | ||
118 | GNUNET_SCHEDULER_shutdown(); | ||
119 | ret = 1; | ||
120 | break; | ||
121 | |||
122 | case GNUNET_SET_STATUS_DONE: | ||
123 | oh2 = NULL; | ||
124 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "set 2: done\n"); | ||
125 | GNUNET_SET_destroy(set2); | ||
126 | set2 = NULL; | ||
127 | if (NULL == set1) | ||
128 | { | ||
129 | GNUNET_SCHEDULER_cancel(tt); | ||
130 | tt = NULL; | ||
131 | GNUNET_SCHEDULER_shutdown(); | ||
132 | } | ||
133 | break; | ||
134 | |||
135 | default: | ||
136 | GNUNET_assert(0); | ||
127 | } | 137 | } |
128 | break; | ||
129 | default: | ||
130 | GNUNET_assert (0); | ||
131 | } | ||
132 | } | 138 | } |
133 | 139 | ||
134 | 140 | ||
135 | static void | 141 | static void |
136 | listen_cb (void *cls, | 142 | listen_cb(void *cls, |
137 | const struct GNUNET_PeerIdentity *other_peer, | 143 | const struct GNUNET_PeerIdentity *other_peer, |
138 | const struct GNUNET_MessageHeader *context_msg, | 144 | const struct GNUNET_MessageHeader *context_msg, |
139 | struct GNUNET_SET_Request *request) | 145 | struct GNUNET_SET_Request *request) |
140 | { | 146 | { |
141 | GNUNET_assert (NULL != context_msg); | 147 | GNUNET_assert(NULL != context_msg); |
142 | GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); | 148 | GNUNET_assert(ntohs(context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); |
143 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "listen cb called\n"); | 149 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "listen cb called\n"); |
144 | oh2 = GNUNET_SET_accept (request, | 150 | oh2 = GNUNET_SET_accept(request, |
145 | GNUNET_SET_RESULT_ADDED, | 151 | GNUNET_SET_RESULT_ADDED, |
146 | (struct GNUNET_SET_Option[]){0}, | 152 | (struct GNUNET_SET_Option[]){ 0 }, |
147 | &result_cb_set2, | 153 | &result_cb_set2, |
148 | NULL); | 154 | NULL); |
149 | GNUNET_SET_commit (oh2, set2); | 155 | GNUNET_SET_commit(oh2, set2); |
150 | } | 156 | } |
151 | 157 | ||
152 | 158 | ||
@@ -156,26 +162,26 @@ listen_cb (void *cls, | |||
156 | * @param cls closure, unused | 162 | * @param cls closure, unused |
157 | */ | 163 | */ |
158 | static void | 164 | static void |
159 | start (void *cls) | 165 | start(void *cls) |
160 | { | 166 | { |
161 | struct GNUNET_MessageHeader context_msg; | 167 | struct GNUNET_MessageHeader context_msg; |
162 | 168 | ||
163 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting reconciliation\n"); | 169 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Starting reconciliation\n"); |
164 | context_msg.size = htons (sizeof context_msg); | 170 | context_msg.size = htons(sizeof context_msg); |
165 | context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY); | 171 | context_msg.type = htons(GNUNET_MESSAGE_TYPE_DUMMY); |
166 | listen_handle = GNUNET_SET_listen (config, | 172 | listen_handle = GNUNET_SET_listen(config, |
167 | GNUNET_SET_OPERATION_UNION, | 173 | GNUNET_SET_OPERATION_UNION, |
168 | &app_id, | 174 | &app_id, |
169 | &listen_cb, | 175 | &listen_cb, |
170 | NULL); | 176 | NULL); |
171 | oh1 = GNUNET_SET_prepare (&local_id, | 177 | oh1 = GNUNET_SET_prepare(&local_id, |
172 | &app_id, | 178 | &app_id, |
173 | &context_msg, | 179 | &context_msg, |
174 | GNUNET_SET_RESULT_ADDED, | 180 | GNUNET_SET_RESULT_ADDED, |
175 | (struct GNUNET_SET_Option[]){0}, | 181 | (struct GNUNET_SET_Option[]){ 0 }, |
176 | &result_cb_set1, | 182 | &result_cb_set1, |
177 | NULL); | 183 | NULL); |
178 | GNUNET_SET_commit (oh1, set1); | 184 | GNUNET_SET_commit(oh1, set1); |
179 | } | 185 | } |
180 | 186 | ||
181 | 187 | ||
@@ -185,22 +191,22 @@ start (void *cls) | |||
185 | * @param cls closure, unused | 191 | * @param cls closure, unused |
186 | */ | 192 | */ |
187 | static void | 193 | static void |
188 | init_set2 (void *cls) | 194 | init_set2(void *cls) |
189 | { | 195 | { |
190 | struct GNUNET_SET_Element element; | 196 | struct GNUNET_SET_Element element; |
191 | 197 | ||
192 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initializing set 2\n"); | 198 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "initializing set 2\n"); |
193 | 199 | ||
194 | element.element_type = 0; | 200 | element.element_type = 0; |
195 | element.data = "hello"; | 201 | element.data = "hello"; |
196 | element.size = strlen (element.data); | 202 | element.size = strlen(element.data); |
197 | GNUNET_SET_add_element (set2, &element, NULL, NULL); | 203 | GNUNET_SET_add_element(set2, &element, NULL, NULL); |
198 | element.data = "quux"; | 204 | element.data = "quux"; |
199 | element.size = strlen (element.data); | 205 | element.size = strlen(element.data); |
200 | GNUNET_SET_add_element (set2, &element, NULL, NULL); | 206 | GNUNET_SET_add_element(set2, &element, NULL, NULL); |
201 | element.data = "baz"; | 207 | element.data = "baz"; |
202 | element.size = strlen (element.data); | 208 | element.size = strlen(element.data); |
203 | GNUNET_SET_add_element (set2, &element, &start, NULL); | 209 | GNUNET_SET_add_element(set2, &element, &start, NULL); |
204 | } | 210 | } |
205 | 211 | ||
206 | 212 | ||
@@ -208,63 +214,63 @@ init_set2 (void *cls) | |||
208 | * Initialize the first set, continue. | 214 | * Initialize the first set, continue. |
209 | */ | 215 | */ |
210 | static void | 216 | static void |
211 | init_set1 (void) | 217 | init_set1(void) |
212 | { | 218 | { |
213 | struct GNUNET_SET_Element element; | 219 | struct GNUNET_SET_Element element; |
214 | 220 | ||
215 | element.element_type = 0; | 221 | element.element_type = 0; |
216 | element.data = "hello"; | 222 | element.data = "hello"; |
217 | element.size = strlen (element.data); | 223 | element.size = strlen(element.data); |
218 | GNUNET_SET_add_element (set1, &element, NULL, NULL); | 224 | GNUNET_SET_add_element(set1, &element, NULL, NULL); |
219 | element.data = "bar"; | 225 | element.data = "bar"; |
220 | element.size = strlen (element.data); | 226 | element.size = strlen(element.data); |
221 | GNUNET_SET_add_element (set1, &element, &init_set2, NULL); | 227 | GNUNET_SET_add_element(set1, &element, &init_set2, NULL); |
222 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized set 1\n"); | 228 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "initialized set 1\n"); |
223 | } | 229 | } |
224 | 230 | ||
225 | 231 | ||
226 | static int | 232 | static int |
227 | iter_cb (void *cls, const struct GNUNET_SET_Element *element) | 233 | iter_cb(void *cls, const struct GNUNET_SET_Element *element) |
228 | { | 234 | { |
229 | struct GNUNET_SET_Handle *set = cls; | 235 | struct GNUNET_SET_Handle *set = cls; |
230 | 236 | ||
231 | if (NULL == element) | 237 | if (NULL == element) |
232 | { | 238 | { |
233 | GNUNET_assert (3 == iter_count); | 239 | GNUNET_assert(3 == iter_count); |
234 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 240 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
235 | "Iteration finished, destroying set %p\n", | 241 | "Iteration finished, destroying set %p\n", |
236 | set); | 242 | set); |
237 | GNUNET_SET_destroy (set); | 243 | GNUNET_SET_destroy(set); |
238 | return GNUNET_YES; | 244 | return GNUNET_YES; |
239 | } | 245 | } |
240 | iter_count++; | 246 | iter_count++; |
241 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "iter: got element %u\n", iter_count); | 247 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "iter: got element %u\n", iter_count); |
242 | return GNUNET_YES; | 248 | return GNUNET_YES; |
243 | } | 249 | } |
244 | 250 | ||
245 | 251 | ||
246 | static void | 252 | static void |
247 | test_iter () | 253 | test_iter() |
248 | { | 254 | { |
249 | struct GNUNET_SET_Element element; | 255 | struct GNUNET_SET_Element element; |
250 | struct GNUNET_SET_Handle *iter_set; | 256 | struct GNUNET_SET_Handle *iter_set; |
251 | 257 | ||
252 | iter_set = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION); | 258 | iter_set = GNUNET_SET_create(config, GNUNET_SET_OPERATION_UNION); |
253 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 259 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
254 | "Testing iteration over 3 elements on set %p\n", | 260 | "Testing iteration over 3 elements on set %p\n", |
255 | iter_set); | 261 | iter_set); |
256 | element.element_type = 0; | 262 | element.element_type = 0; |
257 | 263 | ||
258 | element.data = "hello"; | 264 | element.data = "hello"; |
259 | element.size = strlen (element.data); | 265 | element.size = strlen(element.data); |
260 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); | 266 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); |
261 | element.data = "bar"; | 267 | element.data = "bar"; |
262 | element.size = strlen (element.data); | 268 | element.size = strlen(element.data); |
263 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); | 269 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); |
264 | element.data = "quux"; | 270 | element.data = "quux"; |
265 | element.size = strlen (element.data); | 271 | element.size = strlen(element.data); |
266 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); | 272 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); |
267 | GNUNET_SET_iterate (iter_set, &iter_cb, iter_set); | 273 | GNUNET_SET_iterate(iter_set, &iter_cb, iter_set); |
268 | } | 274 | } |
269 | 275 | ||
270 | 276 | ||
@@ -274,11 +280,11 @@ test_iter () | |||
274 | * @param cls closure | 280 | * @param cls closure |
275 | */ | 281 | */ |
276 | static void | 282 | static void |
277 | timeout_fail (void *cls) | 283 | timeout_fail(void *cls) |
278 | { | 284 | { |
279 | tt = NULL; | 285 | tt = NULL; |
280 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Testcase failed with timeout\n"); | 286 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, "Testcase failed with timeout\n"); |
281 | GNUNET_SCHEDULER_shutdown (); | 287 | GNUNET_SCHEDULER_shutdown(); |
282 | ret = 1; | 288 | ret = 1; |
283 | } | 289 | } |
284 | 290 | ||
@@ -289,38 +295,38 @@ timeout_fail (void *cls) | |||
289 | * @param cls closure | 295 | * @param cls closure |
290 | */ | 296 | */ |
291 | static void | 297 | static void |
292 | do_shutdown (void *cls) | 298 | do_shutdown(void *cls) |
293 | { | 299 | { |
294 | if (NULL != tt) | 300 | if (NULL != tt) |
295 | { | 301 | { |
296 | GNUNET_SCHEDULER_cancel (tt); | 302 | GNUNET_SCHEDULER_cancel(tt); |
297 | tt = NULL; | 303 | tt = NULL; |
298 | } | 304 | } |
299 | if (NULL != oh1) | 305 | if (NULL != oh1) |
300 | { | 306 | { |
301 | GNUNET_SET_operation_cancel (oh1); | 307 | GNUNET_SET_operation_cancel(oh1); |
302 | oh1 = NULL; | 308 | oh1 = NULL; |
303 | } | 309 | } |
304 | if (NULL != oh2) | 310 | if (NULL != oh2) |
305 | { | 311 | { |
306 | GNUNET_SET_operation_cancel (oh2); | 312 | GNUNET_SET_operation_cancel(oh2); |
307 | oh2 = NULL; | 313 | oh2 = NULL; |
308 | } | 314 | } |
309 | if (NULL != set1) | 315 | if (NULL != set1) |
310 | { | 316 | { |
311 | GNUNET_SET_destroy (set1); | 317 | GNUNET_SET_destroy(set1); |
312 | set1 = NULL; | 318 | set1 = NULL; |
313 | } | 319 | } |
314 | if (NULL != set2) | 320 | if (NULL != set2) |
315 | { | 321 | { |
316 | GNUNET_SET_destroy (set2); | 322 | GNUNET_SET_destroy(set2); |
317 | set2 = NULL; | 323 | set2 = NULL; |
318 | } | 324 | } |
319 | if (NULL != listen_handle) | 325 | if (NULL != listen_handle) |
320 | { | 326 | { |
321 | GNUNET_SET_listen_cancel (listen_handle); | 327 | GNUNET_SET_listen_cancel(listen_handle); |
322 | listen_handle = NULL; | 328 | listen_handle = NULL; |
323 | } | 329 | } |
324 | } | 330 | } |
325 | 331 | ||
326 | 332 | ||
@@ -333,66 +339,65 @@ do_shutdown (void *cls) | |||
333 | * @param peer identity of the peer that was created | 339 | * @param peer identity of the peer that was created |
334 | */ | 340 | */ |
335 | static void | 341 | static void |
336 | run (void *cls, | 342 | run(void *cls, |
337 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 343 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
338 | struct GNUNET_TESTING_Peer *peer) | 344 | struct GNUNET_TESTING_Peer *peer) |
339 | { | 345 | { |
340 | |||
341 | struct GNUNET_SET_OperationHandle *my_oh; | 346 | struct GNUNET_SET_OperationHandle *my_oh; |
342 | 347 | ||
343 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running preparatory tests\n"); | 348 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Running preparatory tests\n"); |
344 | tt = GNUNET_SCHEDULER_add_delayed ( | 349 | tt = GNUNET_SCHEDULER_add_delayed( |
345 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5), | 350 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), |
346 | &timeout_fail, | 351 | &timeout_fail, |
347 | NULL); | 352 | NULL); |
348 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); | 353 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL); |
349 | 354 | ||
350 | config = cfg; | 355 | config = cfg; |
351 | GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_get_peer_identity (cfg, &local_id)); | 356 | GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_get_peer_identity(cfg, &local_id)); |
352 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 357 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
353 | "my id (from CRYPTO): %s\n", | 358 | "my id (from CRYPTO): %s\n", |
354 | GNUNET_i2s (&local_id)); | 359 | GNUNET_i2s(&local_id)); |
355 | GNUNET_TESTING_peer_get_identity (peer, &local_id); | 360 | GNUNET_TESTING_peer_get_identity(peer, &local_id); |
356 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 361 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
357 | "my id (from TESTING): %s\n", | 362 | "my id (from TESTING): %s\n", |
358 | GNUNET_i2s (&local_id)); | 363 | GNUNET_i2s(&local_id)); |
359 | test_iter (); | 364 | test_iter(); |
360 | 365 | ||
361 | set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION); | 366 | set1 = GNUNET_SET_create(cfg, GNUNET_SET_OPERATION_UNION); |
362 | set2 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION); | 367 | set2 = GNUNET_SET_create(cfg, GNUNET_SET_OPERATION_UNION); |
363 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 368 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
364 | "Created sets %p and %p for union operation\n", | 369 | "Created sets %p and %p for union operation\n", |
365 | set1, | 370 | set1, |
366 | set2); | 371 | set2); |
367 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id); | 372 | GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &app_id); |
368 | 373 | ||
369 | /* test if canceling an uncommited request works! */ | 374 | /* test if canceling an uncommited request works! */ |
370 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 375 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
371 | "Launching and instantly stopping set operation\n"); | 376 | "Launching and instantly stopping set operation\n"); |
372 | my_oh = GNUNET_SET_prepare (&local_id, | 377 | my_oh = GNUNET_SET_prepare(&local_id, |
373 | &app_id, | 378 | &app_id, |
374 | NULL, | 379 | NULL, |
375 | GNUNET_SET_RESULT_ADDED, | 380 | GNUNET_SET_RESULT_ADDED, |
376 | (struct GNUNET_SET_Option[]){0}, | 381 | (struct GNUNET_SET_Option[]){ 0 }, |
377 | NULL, | 382 | NULL, |
378 | NULL); | 383 | NULL); |
379 | GNUNET_SET_operation_cancel (my_oh); | 384 | GNUNET_SET_operation_cancel(my_oh); |
380 | 385 | ||
381 | /* test the real set reconciliation */ | 386 | /* test the real set reconciliation */ |
382 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running real set-reconciliation\n"); | 387 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Running real set-reconciliation\n"); |
383 | init_set1 (); | 388 | init_set1(); |
384 | } | 389 | } |
385 | 390 | ||
386 | 391 | ||
387 | int | 392 | int |
388 | main (int argc, char **argv) | 393 | main(int argc, char **argv) |
389 | { | 394 | { |
390 | GNUNET_log_setup ("test_set_api", "WARNING", NULL); | 395 | GNUNET_log_setup("test_set_api", "WARNING", NULL); |
391 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Launching peer\n"); | 396 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Launching peer\n"); |
392 | if (0 != | 397 | if (0 != |
393 | GNUNET_TESTING_peer_run ("test_set_api", "test_set.conf", &run, NULL)) | 398 | GNUNET_TESTING_peer_run("test_set_api", "test_set.conf", &run, NULL)) |
394 | { | 399 | { |
395 | return 1; | 400 | return 1; |
396 | } | 401 | } |
397 | return ret; | 402 | return ret; |
398 | } | 403 | } |