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/testbed/test_testbed_api_operations.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/testbed/test_testbed_api_operations.c')
-rw-r--r-- | src/testbed/test_testbed_api_operations.c | 469 |
1 files changed, 247 insertions, 222 deletions
diff --git a/src/testbed/test_testbed_api_operations.c b/src/testbed/test_testbed_api_operations.c index dfa8abc99..f88f85304 100644 --- a/src/testbed/test_testbed_api_operations.c +++ b/src/testbed/test_testbed_api_operations.c | |||
@@ -11,7 +11,7 @@ | |||
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 | ||
@@ -31,14 +31,14 @@ | |||
31 | /** | 31 | /** |
32 | * Generic logging shortcut | 32 | * Generic logging shortcut |
33 | */ | 33 | */ |
34 | #define LOG(kind,...) \ | 34 | #define LOG(kind, ...) \ |
35 | GNUNET_log (kind, __VA_ARGS__) | 35 | GNUNET_log(kind, __VA_ARGS__) |
36 | 36 | ||
37 | /** | 37 | /** |
38 | * Delay to start step task | 38 | * Delay to start step task |
39 | */ | 39 | */ |
40 | #define STEP_DELAY \ | 40 | #define STEP_DELAY \ |
41 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500) | 41 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 500) |
42 | 42 | ||
43 | /** | 43 | /** |
44 | * Queue A. Initially the max active is set to 2 and then reduced to 0 - this | 44 | * Queue A. Initially the max active is set to 2 and then reduced to 0 - this |
@@ -121,21 +121,20 @@ struct GNUNET_SCHEDULER_Task * step_task; | |||
121 | /** | 121 | /** |
122 | * Enumeration of test stages | 122 | * Enumeration of test stages |
123 | */ | 123 | */ |
124 | enum Test | 124 | enum Test { |
125 | { | 125 | /** |
126 | /** | 126 | * Initial stage |
127 | * Initial stage | 127 | */ |
128 | */ | ||
129 | TEST_INIT, | 128 | TEST_INIT, |
130 | 129 | ||
131 | /** | 130 | /** |
132 | * op1 has been started | 131 | * op1 has been started |
133 | */ | 132 | */ |
134 | TEST_OP1_STARTED, | 133 | TEST_OP1_STARTED, |
135 | 134 | ||
136 | /** | 135 | /** |
137 | * op1 has been released | 136 | * op1 has been released |
138 | */ | 137 | */ |
139 | TEST_OP1_RELEASED, | 138 | TEST_OP1_RELEASED, |
140 | 139 | ||
141 | /** | 140 | /** |
@@ -144,14 +143,14 @@ enum Test | |||
144 | */ | 143 | */ |
145 | TEST_PAUSE, | 144 | TEST_PAUSE, |
146 | 145 | ||
147 | /** | 146 | /** |
148 | * op2 has started | 147 | * op2 has started |
149 | */ | 148 | */ |
150 | TEST_OP2_STARTED, | 149 | TEST_OP2_STARTED, |
151 | 150 | ||
152 | /** | 151 | /** |
153 | * op2 released | 152 | * op2 released |
154 | */ | 153 | */ |
155 | TEST_OP2_RELEASED, | 154 | TEST_OP2_RELEASED, |
156 | 155 | ||
157 | /** | 156 | /** |
@@ -242,7 +241,7 @@ enum Test result; | |||
242 | * operation can be activated. | 241 | * operation can be activated. |
243 | */ | 242 | */ |
244 | static void | 243 | static void |
245 | start_cb (void *cls); | 244 | start_cb(void *cls); |
246 | 245 | ||
247 | 246 | ||
248 | /** | 247 | /** |
@@ -255,7 +254,7 @@ start_cb (void *cls); | |||
255 | * in 'cls' and release all resources associated with the operation. | 254 | * in 'cls' and release all resources associated with the operation. |
256 | */ | 255 | */ |
257 | static void | 256 | static void |
258 | release_cb (void *cls); | 257 | release_cb(void *cls); |
259 | 258 | ||
260 | 259 | ||
261 | /** | 260 | /** |
@@ -264,69 +263,79 @@ release_cb (void *cls); | |||
264 | * @param cls NULL | 263 | * @param cls NULL |
265 | */ | 264 | */ |
266 | static void | 265 | static void |
267 | step (void *cls) | 266 | step(void *cls) |
268 | { | 267 | { |
269 | GNUNET_assert (NULL != step_task); | 268 | GNUNET_assert(NULL != step_task); |
270 | step_task = NULL; | 269 | step_task = NULL; |
271 | switch (result) | 270 | switch (result) |
272 | { | 271 | { |
273 | case TEST_OP1_STARTED: | 272 | case TEST_OP1_STARTED: |
274 | GNUNET_TESTBED_operation_release_ (op1); | 273 | GNUNET_TESTBED_operation_release_(op1); |
275 | GNUNET_TESTBED_operation_queue_reset_max_active_ (q1, 0); | 274 | GNUNET_TESTBED_operation_queue_reset_max_active_(q1, 0); |
276 | op3 = GNUNET_TESTBED_operation_create_ (&op3, &start_cb, &release_cb); | 275 | op3 = GNUNET_TESTBED_operation_create_(&op3, &start_cb, &release_cb); |
277 | GNUNET_TESTBED_operation_queue_insert2_ (q1, op3, 2); | 276 | GNUNET_TESTBED_operation_queue_insert2_(q1, op3, 2); |
278 | GNUNET_TESTBED_operation_queue_insert2_ (q2, op3, 2); | 277 | GNUNET_TESTBED_operation_queue_insert2_(q2, op3, 2); |
279 | GNUNET_TESTBED_operation_begin_wait_ (op3); | 278 | GNUNET_TESTBED_operation_begin_wait_(op3); |
280 | op4 = GNUNET_TESTBED_operation_create_ (&op4, &start_cb, &release_cb); | 279 | op4 = GNUNET_TESTBED_operation_create_(&op4, &start_cb, &release_cb); |
281 | GNUNET_TESTBED_operation_queue_insert2_ (q1, op4, 2); | 280 | GNUNET_TESTBED_operation_queue_insert2_(q1, op4, 2); |
282 | GNUNET_TESTBED_operation_queue_insert2_ (q2, op4, 2); | 281 | GNUNET_TESTBED_operation_queue_insert2_(q2, op4, 2); |
283 | GNUNET_TESTBED_operation_begin_wait_ (op4); | 282 | GNUNET_TESTBED_operation_begin_wait_(op4); |
284 | break; | 283 | break; |
285 | case TEST_OP1_RELEASED: | 284 | |
286 | result = TEST_PAUSE; | 285 | case TEST_OP1_RELEASED: |
287 | GNUNET_TESTBED_operation_queue_reset_max_active_ (q1, 2); | 286 | result = TEST_PAUSE; |
288 | break; | 287 | GNUNET_TESTBED_operation_queue_reset_max_active_(q1, 2); |
289 | case TEST_OP2_STARTED: | 288 | break; |
290 | GNUNET_TESTBED_operation_release_ (op2); | 289 | |
291 | break; | 290 | case TEST_OP2_STARTED: |
292 | case TEST_OP3_STARTED: | 291 | GNUNET_TESTBED_operation_release_(op2); |
293 | GNUNET_TESTBED_operation_release_ (op3); | 292 | break; |
294 | break; | 293 | |
295 | case TEST_OP4_STARTED: | 294 | case TEST_OP3_STARTED: |
296 | GNUNET_TESTBED_operation_release_ (op4); | 295 | GNUNET_TESTBED_operation_release_(op3); |
297 | break; | 296 | break; |
298 | case TEST_OP6_RELEASED: | 297 | |
299 | op8 = GNUNET_TESTBED_operation_create_ (&op8, &start_cb, &release_cb); | 298 | case TEST_OP4_STARTED: |
300 | GNUNET_TESTBED_operation_queue_insert2_ (q1, op8, 2); | 299 | GNUNET_TESTBED_operation_release_(op4); |
301 | GNUNET_TESTBED_operation_queue_insert2_ (q2, op8, 2); | 300 | break; |
302 | result = TEST_OP8_WAITING; | 301 | |
303 | GNUNET_TESTBED_operation_begin_wait_ (op8); | 302 | case TEST_OP6_RELEASED: |
304 | break; | 303 | op8 = GNUNET_TESTBED_operation_create_(&op8, &start_cb, &release_cb); |
305 | case TEST_OP8_STARTED: | 304 | GNUNET_TESTBED_operation_queue_insert2_(q1, op8, 2); |
306 | GNUNET_TESTBED_operation_inactivate_ (op8); | 305 | GNUNET_TESTBED_operation_queue_insert2_(q2, op8, 2); |
307 | result = TEST_OP8_INACTIVE_1; | 306 | result = TEST_OP8_WAITING; |
308 | step_task = GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); | 307 | GNUNET_TESTBED_operation_begin_wait_(op8); |
309 | break; | 308 | break; |
310 | case TEST_OP8_INACTIVE_1: | 309 | |
311 | GNUNET_TESTBED_operation_activate_ (op8); | 310 | case TEST_OP8_STARTED: |
312 | result = TEST_OP8_ACTIVE; | 311 | GNUNET_TESTBED_operation_inactivate_(op8); |
313 | op9 = GNUNET_TESTBED_operation_create_ (&op9, &start_cb, &release_cb); | 312 | result = TEST_OP8_INACTIVE_1; |
314 | GNUNET_TESTBED_operation_queue_insert2_ (q1, op9, 1); | 313 | step_task = GNUNET_SCHEDULER_add_delayed(STEP_DELAY, &step, NULL); |
315 | GNUNET_TESTBED_operation_queue_insert2_ (q2, op9, 1); | 314 | break; |
316 | GNUNET_TESTBED_operation_begin_wait_ (op9); | 315 | |
317 | step_task = GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); | 316 | case TEST_OP8_INACTIVE_1: |
318 | break; | 317 | GNUNET_TESTBED_operation_activate_(op8); |
319 | case TEST_OP8_ACTIVE: | 318 | result = TEST_OP8_ACTIVE; |
320 | GNUNET_TESTBED_operation_inactivate_ (op8); | 319 | op9 = GNUNET_TESTBED_operation_create_(&op9, &start_cb, &release_cb); |
321 | /* op8 should be released by now due to above call */ | 320 | GNUNET_TESTBED_operation_queue_insert2_(q1, op9, 1); |
322 | GNUNET_assert (TEST_OP8_RELEASED == result); | 321 | GNUNET_TESTBED_operation_queue_insert2_(q2, op9, 1); |
323 | break; | 322 | GNUNET_TESTBED_operation_begin_wait_(op9); |
324 | case TEST_OP9_STARTED: | 323 | step_task = GNUNET_SCHEDULER_add_delayed(STEP_DELAY, &step, NULL); |
325 | GNUNET_TESTBED_operation_release_ (op9); | 324 | break; |
326 | break; | 325 | |
327 | default: | 326 | case TEST_OP8_ACTIVE: |
328 | GNUNET_assert (0); | 327 | GNUNET_TESTBED_operation_inactivate_(op8); |
329 | } | 328 | /* op8 should be released by now due to above call */ |
329 | GNUNET_assert(TEST_OP8_RELEASED == result); | ||
330 | break; | ||
331 | |||
332 | case TEST_OP9_STARTED: | ||
333 | GNUNET_TESTBED_operation_release_(op9); | ||
334 | break; | ||
335 | |||
336 | default: | ||
337 | GNUNET_assert(0); | ||
338 | } | ||
330 | } | 339 | } |
331 | 340 | ||
332 | 341 | ||
@@ -336,64 +345,71 @@ step (void *cls) | |||
336 | * operation can be activated. | 345 | * operation can be activated. |
337 | */ | 346 | */ |
338 | static void | 347 | static void |
339 | start_cb (void *cls) | 348 | start_cb(void *cls) |
340 | { | 349 | { |
341 | switch (result) | 350 | switch (result) |
342 | { | ||
343 | case TEST_INIT: | ||
344 | GNUNET_assert (&op1 == cls); | ||
345 | result = TEST_OP1_STARTED; | ||
346 | GNUNET_assert (NULL == step_task); | ||
347 | step_task = | ||
348 | GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); | ||
349 | break; | ||
350 | case TEST_PAUSE: | ||
351 | GNUNET_assert (&op2 == cls); | ||
352 | result = TEST_OP2_STARTED; | ||
353 | GNUNET_assert (NULL == step_task); | ||
354 | step_task = | ||
355 | GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); | ||
356 | break; | ||
357 | case TEST_OP2_RELEASED: | ||
358 | GNUNET_assert (&op3 == cls); | ||
359 | result = TEST_OP3_STARTED; | ||
360 | GNUNET_assert (NULL == step_task); | ||
361 | step_task = | ||
362 | GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); | ||
363 | break; | ||
364 | case TEST_OP3_RELEASED: | ||
365 | GNUNET_assert (&op4 == cls); | ||
366 | result = TEST_OP4_STARTED; | ||
367 | GNUNET_assert (NULL == step_task); | ||
368 | step_task = | ||
369 | GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); | ||
370 | break; | ||
371 | case TEST_OP4_RELEASED: | ||
372 | { | ||
373 | static int nops; | ||
374 | |||
375 | nops++; | ||
376 | if (nops == 3) | ||
377 | { | 351 | { |
378 | result = TEST_OP5_6_7_STARTED; | 352 | case TEST_INIT: |
379 | GNUNET_TESTBED_operation_release_ (op5); | 353 | GNUNET_assert(&op1 == cls); |
380 | op5 = NULL; | 354 | result = TEST_OP1_STARTED; |
355 | GNUNET_assert(NULL == step_task); | ||
356 | step_task = | ||
357 | GNUNET_SCHEDULER_add_delayed(STEP_DELAY, &step, NULL); | ||
358 | break; | ||
359 | |||
360 | case TEST_PAUSE: | ||
361 | GNUNET_assert(&op2 == cls); | ||
362 | result = TEST_OP2_STARTED; | ||
363 | GNUNET_assert(NULL == step_task); | ||
364 | step_task = | ||
365 | GNUNET_SCHEDULER_add_delayed(STEP_DELAY, &step, NULL); | ||
366 | break; | ||
367 | |||
368 | case TEST_OP2_RELEASED: | ||
369 | GNUNET_assert(&op3 == cls); | ||
370 | result = TEST_OP3_STARTED; | ||
371 | GNUNET_assert(NULL == step_task); | ||
372 | step_task = | ||
373 | GNUNET_SCHEDULER_add_delayed(STEP_DELAY, &step, NULL); | ||
374 | break; | ||
375 | |||
376 | case TEST_OP3_RELEASED: | ||
377 | GNUNET_assert(&op4 == cls); | ||
378 | result = TEST_OP4_STARTED; | ||
379 | GNUNET_assert(NULL == step_task); | ||
380 | step_task = | ||
381 | GNUNET_SCHEDULER_add_delayed(STEP_DELAY, &step, NULL); | ||
382 | break; | ||
383 | |||
384 | case TEST_OP4_RELEASED: | ||
385 | { | ||
386 | static int nops; | ||
387 | |||
388 | nops++; | ||
389 | if (nops == 3) | ||
390 | { | ||
391 | result = TEST_OP5_6_7_STARTED; | ||
392 | GNUNET_TESTBED_operation_release_(op5); | ||
393 | op5 = NULL; | ||
394 | } | ||
381 | } | 395 | } |
382 | } | ||
383 | break; | 396 | break; |
384 | case TEST_OP7_RELEASED: | 397 | |
385 | GNUNET_assert (&op8 == cls); | 398 | case TEST_OP7_RELEASED: |
386 | result = TEST_OP8_STARTED; | 399 | GNUNET_assert(&op8 == cls); |
387 | step_task = GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); | 400 | result = TEST_OP8_STARTED; |
388 | break; | 401 | step_task = GNUNET_SCHEDULER_add_delayed(STEP_DELAY, &step, NULL); |
389 | case TEST_OP8_RELEASED: | 402 | break; |
390 | GNUNET_assert (&op9 == cls); | 403 | |
391 | result = TEST_OP9_STARTED; | 404 | case TEST_OP8_RELEASED: |
392 | step_task = GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); | 405 | GNUNET_assert(&op9 == cls); |
393 | break; | 406 | result = TEST_OP9_STARTED; |
394 | default: | 407 | step_task = GNUNET_SCHEDULER_add_delayed(STEP_DELAY, &step, NULL); |
395 | GNUNET_assert (0); | 408 | break; |
396 | } | 409 | |
410 | default: | ||
411 | GNUNET_assert(0); | ||
412 | } | ||
397 | } | 413 | } |
398 | 414 | ||
399 | 415 | ||
@@ -407,73 +423,82 @@ start_cb (void *cls) | |||
407 | * in 'cls' and release all resources associated with the operation. | 423 | * in 'cls' and release all resources associated with the operation. |
408 | */ | 424 | */ |
409 | static void | 425 | static void |
410 | release_cb (void *cls) | 426 | release_cb(void *cls) |
411 | { | 427 | { |
412 | switch (result) | 428 | switch (result) |
413 | { | 429 | { |
414 | case TEST_OP1_STARTED: | 430 | case TEST_OP1_STARTED: |
415 | GNUNET_assert (&op1 == cls); | 431 | GNUNET_assert(&op1 == cls); |
416 | result = TEST_OP1_RELEASED; | 432 | result = TEST_OP1_RELEASED; |
417 | op1 = NULL; | 433 | op1 = NULL; |
418 | step_task = | 434 | step_task = |
419 | GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); | 435 | GNUNET_SCHEDULER_add_delayed(STEP_DELAY, &step, NULL); |
420 | break; | 436 | break; |
421 | case TEST_OP2_STARTED: | 437 | |
422 | GNUNET_assert (&op2 == cls); | 438 | case TEST_OP2_STARTED: |
423 | result = TEST_OP2_RELEASED; | 439 | GNUNET_assert(&op2 == cls); |
424 | GNUNET_assert (NULL == step_task); | 440 | result = TEST_OP2_RELEASED; |
425 | break; | 441 | GNUNET_assert(NULL == step_task); |
426 | case TEST_OP3_STARTED: | 442 | break; |
427 | GNUNET_assert (&op3 == cls); | 443 | |
428 | result = TEST_OP3_RELEASED; | 444 | case TEST_OP3_STARTED: |
429 | GNUNET_assert (NULL == step_task); | 445 | GNUNET_assert(&op3 == cls); |
430 | break; | 446 | result = TEST_OP3_RELEASED; |
431 | case TEST_OP4_STARTED: | 447 | GNUNET_assert(NULL == step_task); |
432 | GNUNET_assert (&op4 == cls); | 448 | break; |
433 | result = TEST_OP4_RELEASED; | 449 | |
434 | GNUNET_assert (NULL == step_task); | 450 | case TEST_OP4_STARTED: |
435 | op5 = GNUNET_TESTBED_operation_create_ (&op5, &start_cb, &release_cb); | 451 | GNUNET_assert(&op4 == cls); |
436 | GNUNET_TESTBED_operation_queue_insert2_ (q1, op5, 1); | 452 | result = TEST_OP4_RELEASED; |
437 | GNUNET_TESTBED_operation_begin_wait_ (op5); | 453 | GNUNET_assert(NULL == step_task); |
438 | op6 = GNUNET_TESTBED_operation_create_ (&op6, &start_cb, &release_cb); | 454 | op5 = GNUNET_TESTBED_operation_create_(&op5, &start_cb, &release_cb); |
439 | GNUNET_TESTBED_operation_queue_insert2_ (q2, op6, 1); | 455 | GNUNET_TESTBED_operation_queue_insert2_(q1, op5, 1); |
440 | GNUNET_TESTBED_operation_begin_wait_ (op6); | 456 | GNUNET_TESTBED_operation_begin_wait_(op5); |
441 | op7 = GNUNET_TESTBED_operation_create_ (&op7, &start_cb, &release_cb); | 457 | op6 = GNUNET_TESTBED_operation_create_(&op6, &start_cb, &release_cb); |
442 | GNUNET_TESTBED_operation_queue_insert2_ (q1, op7, 1); | 458 | GNUNET_TESTBED_operation_queue_insert2_(q2, op6, 1); |
443 | GNUNET_TESTBED_operation_queue_insert2_ (q2, op7, 1); | 459 | GNUNET_TESTBED_operation_begin_wait_(op6); |
444 | GNUNET_TESTBED_operation_begin_wait_ (op7); | 460 | op7 = GNUNET_TESTBED_operation_create_(&op7, &start_cb, &release_cb); |
445 | break; | 461 | GNUNET_TESTBED_operation_queue_insert2_(q1, op7, 1); |
446 | case TEST_OP5_6_7_STARTED: | 462 | GNUNET_TESTBED_operation_queue_insert2_(q2, op7, 1); |
447 | result = TEST_OP5_RELEASED; | 463 | GNUNET_TESTBED_operation_begin_wait_(op7); |
448 | op5 = NULL; | 464 | break; |
449 | GNUNET_TESTBED_operation_release_ (op6); | 465 | |
450 | break; | 466 | case TEST_OP5_6_7_STARTED: |
451 | case TEST_OP5_RELEASED: | 467 | result = TEST_OP5_RELEASED; |
452 | op6 = NULL; | 468 | op5 = NULL; |
453 | result = TEST_OP6_RELEASED; | 469 | GNUNET_TESTBED_operation_release_(op6); |
454 | GNUNET_TESTBED_operation_inactivate_ (op7); | 470 | break; |
455 | step_task = GNUNET_SCHEDULER_add_now (&step, NULL); | 471 | |
456 | break; | 472 | case TEST_OP5_RELEASED: |
457 | case TEST_OP8_WAITING: | 473 | op6 = NULL; |
458 | GNUNET_assert (&op7 == cls); | 474 | result = TEST_OP6_RELEASED; |
459 | op7 = NULL; | 475 | GNUNET_TESTBED_operation_inactivate_(op7); |
460 | result = TEST_OP7_RELEASED; | 476 | step_task = GNUNET_SCHEDULER_add_now(&step, NULL); |
461 | break; | 477 | break; |
462 | case TEST_OP8_ACTIVE: | 478 | |
463 | result = TEST_OP8_RELEASED; | 479 | case TEST_OP8_WAITING: |
464 | op8 = NULL; | 480 | GNUNET_assert(&op7 == cls); |
465 | break; | 481 | op7 = NULL; |
466 | case TEST_OP9_STARTED: | 482 | result = TEST_OP7_RELEASED; |
467 | GNUNET_assert (&op9 == cls); | 483 | break; |
468 | result = TEST_OP9_RELEASED; | 484 | |
469 | GNUNET_TESTBED_operation_queue_destroy_ (q1); | 485 | case TEST_OP8_ACTIVE: |
470 | GNUNET_TESTBED_operation_queue_destroy_ (q2); | 486 | result = TEST_OP8_RELEASED; |
471 | q1 = NULL; | 487 | op8 = NULL; |
472 | q2 = NULL; | 488 | break; |
473 | break; | 489 | |
474 | default: | 490 | case TEST_OP9_STARTED: |
475 | GNUNET_assert (0); | 491 | GNUNET_assert(&op9 == cls); |
476 | } | 492 | result = TEST_OP9_RELEASED; |
493 | GNUNET_TESTBED_operation_queue_destroy_(q1); | ||
494 | GNUNET_TESTBED_operation_queue_destroy_(q2); | ||
495 | q1 = NULL; | ||
496 | q2 = NULL; | ||
497 | break; | ||
498 | |||
499 | default: | ||
500 | GNUNET_assert(0); | ||
501 | } | ||
477 | } | 502 | } |
478 | 503 | ||
479 | 504 | ||
@@ -486,22 +511,22 @@ release_cb (void *cls) | |||
486 | * @param cfg the configuration file handle | 511 | * @param cfg the configuration file handle |
487 | */ | 512 | */ |
488 | static void | 513 | static void |
489 | run (void *cls, char *const *args, const char *cfgfile, | 514 | run(void *cls, char *const *args, const char *cfgfile, |
490 | const struct GNUNET_CONFIGURATION_Handle *config) | 515 | const struct GNUNET_CONFIGURATION_Handle *config) |
491 | { | 516 | { |
492 | q1 = GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_FIXED, 1); | 517 | q1 = GNUNET_TESTBED_operation_queue_create_(OPERATION_QUEUE_TYPE_FIXED, 1); |
493 | GNUNET_assert (NULL != q1); | 518 | GNUNET_assert(NULL != q1); |
494 | q2 = GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_FIXED, 2); | 519 | q2 = GNUNET_TESTBED_operation_queue_create_(OPERATION_QUEUE_TYPE_FIXED, 2); |
495 | GNUNET_assert (NULL != q2); | 520 | GNUNET_assert(NULL != q2); |
496 | op1 = GNUNET_TESTBED_operation_create_ (&op1, start_cb, release_cb); | 521 | op1 = GNUNET_TESTBED_operation_create_(&op1, start_cb, release_cb); |
497 | GNUNET_assert (NULL != op1); | 522 | GNUNET_assert(NULL != op1); |
498 | op2 = GNUNET_TESTBED_operation_create_ (&op2, start_cb, release_cb); | 523 | op2 = GNUNET_TESTBED_operation_create_(&op2, start_cb, release_cb); |
499 | GNUNET_TESTBED_operation_queue_insert_ (q1, op1); | 524 | GNUNET_TESTBED_operation_queue_insert_(q1, op1); |
500 | GNUNET_TESTBED_operation_queue_insert_ (q2, op1); | 525 | GNUNET_TESTBED_operation_queue_insert_(q2, op1); |
501 | GNUNET_TESTBED_operation_begin_wait_ (op1); | 526 | GNUNET_TESTBED_operation_begin_wait_(op1); |
502 | GNUNET_TESTBED_operation_queue_insert_ (q1, op2); | 527 | GNUNET_TESTBED_operation_queue_insert_(q1, op2); |
503 | GNUNET_TESTBED_operation_queue_insert_ (q2, op2); | 528 | GNUNET_TESTBED_operation_queue_insert_(q2, op2); |
504 | GNUNET_TESTBED_operation_begin_wait_ (op2); | 529 | GNUNET_TESTBED_operation_begin_wait_(op2); |
505 | result = TEST_INIT; | 530 | result = TEST_INIT; |
506 | } | 531 | } |
507 | 532 | ||
@@ -510,18 +535,18 @@ run (void *cls, char *const *args, const char *cfgfile, | |||
510 | * Main function | 535 | * Main function |
511 | */ | 536 | */ |
512 | int | 537 | int |
513 | main (int argc, char **argv) | 538 | main(int argc, char **argv) |
514 | { | 539 | { |
515 | int ret; | 540 | int ret; |
516 | char *const argv2[] = | 541 | char *const argv2[] = |
517 | { "test_testbed_api_operations", "-c", "test_testbed_api.conf", NULL }; | 542 | { "test_testbed_api_operations", "-c", "test_testbed_api.conf", NULL }; |
518 | struct GNUNET_GETOPT_CommandLineOption options[] = | 543 | struct GNUNET_GETOPT_CommandLineOption options[] = |
519 | { GNUNET_GETOPT_OPTION_END }; | 544 | { GNUNET_GETOPT_OPTION_END }; |
520 | 545 | ||
521 | ret = | 546 | ret = |
522 | GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2, | 547 | GNUNET_PROGRAM_run((sizeof(argv2) / sizeof(char *)) - 1, argv2, |
523 | "test_testbed_api_operations", "nohelp", options, | 548 | "test_testbed_api_operations", "nohelp", options, |
524 | &run, NULL); | 549 | &run, NULL); |
525 | if ((GNUNET_OK != ret) || (TEST_OP9_RELEASED != result)) | 550 | if ((GNUNET_OK != ret) || (TEST_OP9_RELEASED != result)) |
526 | return 1; | 551 | return 1; |
527 | op1 = NULL; | 552 | op1 = NULL; |