summaryrefslogtreecommitdiff
path: root/src/testbed/test_testbed_api_operations.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/testbed/test_testbed_api_operations.c')
-rw-r--r--src/testbed/test_testbed_api_operations.c469
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 */
124enum Test 124enum 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 */
244static void 243static void
245start_cb (void *cls); 244start_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 */
257static void 256static void
258release_cb (void *cls); 257release_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 */
266static void 265static void
267step (void *cls) 266step(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 */
338static void 347static void
339start_cb (void *cls) 348start_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 */
409static void 425static void
410release_cb (void *cls) 426release_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 */
488static void 513static void
489run (void *cls, char *const *args, const char *cfgfile, 514run(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 */
512int 537int
513main (int argc, char **argv) 538main(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;