/*
This file is part of GNUnet
- (C) 2008--2012 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2008--2013 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
#define LOG(kind,...) \
GNUNET_log (kind, __VA_ARGS__)
+/**
+ * Delay to start step task
+ */
+#define STEP_DELAY \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500)
+
/**
* Queue A. Initially the max active is set to 2 and then reduced to 0 - this
* should block op2 even after op1 has finished. Later the max active is set to
/**
* This operation is started after op6 is finished in step task. It consumes 2
- * resources on both queues q1 and q1.
+ * resources on both queues q1 and q2. This operation should evict op7. After
+ * starting, it should be made inactive, active and inactive again in the step task.
*/
struct GNUNET_TESTBED_Operation *op8;
+/**
+ * This opration is started after activating op8. It should consume a resource
+ * on queues q1 and q2. It should not be started until op8 is again made
+ * inactive at which point it should be released. It can be released as soon as
+ * it begins.
+ */
+struct GNUNET_TESTBED_Operation *op9;
+
/**
* The delay task identifier
*/
-GNUNET_SCHEDULER_TaskIdentifier step_task;
+struct GNUNET_SCHEDULER_Task * step_task;
/**
*/
TEST_OP8_STARTED,
+ /**
+ * op8 is inactive
+ */
+ TEST_OP8_INACTIVE_1,
+
+ /**
+ * op8 is active
+ */
+ TEST_OP8_ACTIVE,
+
/**
* op8 has been released
*/
- TEST_OP8_RELEASED
+ TEST_OP8_RELEASED,
+
+ /**
+ * op9 has started
+ */
+ TEST_OP9_STARTED,
+
+ /**
+ * op9 has been released
+ */
+ TEST_OP9_RELEASED
};
/**
* Task to simulate artificial delay and change the test stage
*
* @param cls NULL
- * @param tc the task context
*/
static void
-step (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+step (void *cls)
{
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != step_task);
- step_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_assert (NULL != step_task);
+ step_task = NULL;
switch (result)
{
case TEST_OP1_STARTED:
case TEST_OP4_STARTED:
GNUNET_TESTBED_operation_release_ (op4);
break;
- case TEST_OP6_RELEASED:
- op8 = GNUNET_TESTBED_operation_create_ (&op8, &start_cb, &release_cb);
+ case TEST_OP6_RELEASED:
+ op8 = GNUNET_TESTBED_operation_create_ (&op8, &start_cb, &release_cb);
GNUNET_TESTBED_operation_queue_insert2_ (q1, op8, 2);
GNUNET_TESTBED_operation_queue_insert2_ (q2, op8, 2);
result = TEST_OP8_WAITING;
GNUNET_TESTBED_operation_begin_wait_ (op8);
break;
case TEST_OP8_STARTED:
- GNUNET_TESTBED_operation_release_ (op8);
+ GNUNET_TESTBED_operation_inactivate_ (op8);
+ result = TEST_OP8_INACTIVE_1;
+ step_task = GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
+ break;
+ case TEST_OP8_INACTIVE_1:
+ GNUNET_TESTBED_operation_activate_ (op8);
+ result = TEST_OP8_ACTIVE;
+ op9 = GNUNET_TESTBED_operation_create_ (&op9, &start_cb, &release_cb);
+ GNUNET_TESTBED_operation_queue_insert2_ (q1, op9, 1);
+ GNUNET_TESTBED_operation_queue_insert2_ (q2, op9, 1);
+ GNUNET_TESTBED_operation_begin_wait_ (op9);
+ step_task = GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
+ break;
+ case TEST_OP8_ACTIVE:
+ GNUNET_TESTBED_operation_inactivate_ (op8);
+ /* op8 should be released by now due to above call */
+ GNUNET_assert (TEST_OP8_RELEASED == result);
+ break;
+ case TEST_OP9_STARTED:
+ GNUNET_TESTBED_operation_release_ (op9);
break;
default:
GNUNET_assert (0);
case TEST_INIT:
GNUNET_assert (&op1 == cls);
result = TEST_OP1_STARTED;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task);
+ GNUNET_assert (NULL == step_task);
step_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &step, NULL);
+ GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
break;
case TEST_PAUSE:
GNUNET_assert (&op2 == cls);
result = TEST_OP2_STARTED;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task);
+ GNUNET_assert (NULL == step_task);
step_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &step, NULL);
+ GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
break;
case TEST_OP2_RELEASED:
GNUNET_assert (&op3 == cls);
result = TEST_OP3_STARTED;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task);
+ GNUNET_assert (NULL == step_task);
step_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &step, NULL);
+ GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
break;
case TEST_OP3_RELEASED:
GNUNET_assert (&op4 == cls);
result = TEST_OP4_STARTED;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task);
+ GNUNET_assert (NULL == step_task);
step_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &step, NULL);
+ GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
break;
case TEST_OP4_RELEASED:
{
case TEST_OP7_RELEASED:
GNUNET_assert (&op8 == cls);
result = TEST_OP8_STARTED;
- step_task = GNUNET_SCHEDULER_add_now (&step, NULL);
+ step_task = GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
+ break;
+ case TEST_OP8_RELEASED:
+ GNUNET_assert (&op9 == cls);
+ result = TEST_OP9_STARTED;
+ step_task = GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
break;
default:
GNUNET_assert (0);
result = TEST_OP1_RELEASED;
op1 = NULL;
step_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &step, NULL);
+ GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
break;
case TEST_OP2_STARTED:
GNUNET_assert (&op2 == cls);
result = TEST_OP2_RELEASED;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task);
- //step_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &step, NULL);
+ GNUNET_assert (NULL == step_task);
break;
case TEST_OP3_STARTED:
GNUNET_assert (&op3 == cls);
result = TEST_OP3_RELEASED;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task);
+ GNUNET_assert (NULL == step_task);
break;
case TEST_OP4_STARTED:
GNUNET_assert (&op4 == cls);
result = TEST_OP4_RELEASED;
- GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task);
+ GNUNET_assert (NULL == step_task);
op5 = GNUNET_TESTBED_operation_create_ (&op5, &start_cb, &release_cb);
GNUNET_TESTBED_operation_queue_insert2_ (q1, op5, 1);
GNUNET_TESTBED_operation_begin_wait_ (op5);
op7 = NULL;
result = TEST_OP7_RELEASED;
break;
- case TEST_OP8_STARTED:
+ case TEST_OP8_ACTIVE:
result = TEST_OP8_RELEASED;
op8 = NULL;
+ break;
+ case TEST_OP9_STARTED:
+ GNUNET_assert (&op9 == cls);
+ result = TEST_OP9_RELEASED;
GNUNET_TESTBED_operation_queue_destroy_ (q1);
GNUNET_TESTBED_operation_queue_destroy_ (q2);
q1 = NULL;
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *config)
{
- q1 = GNUNET_TESTBED_operation_queue_create_ (1);
+ q1 = GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_FIXED, 1);
GNUNET_assert (NULL != q1);
- q2 = GNUNET_TESTBED_operation_queue_create_ (2);
+ q2 = GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_FIXED, 2);
GNUNET_assert (NULL != q2);
op1 = GNUNET_TESTBED_operation_create_ (&op1, start_cb, release_cb);
GNUNET_assert (NULL != op1);
GNUNET_PROGRAM_run ((sizeof (argv2) / sizeof (char *)) - 1, argv2,
"test_testbed_api_operations", "nohelp", options,
&run, NULL);
- if ((GNUNET_OK != ret) || (TEST_OP8_RELEASED != result))
+ if ((GNUNET_OK != ret) || (TEST_OP9_RELEASED != result))
return 1;
op1 = NULL;
op2 = NULL;
op6 = NULL;
op7 = NULL;
op8 = NULL;
+ op9 = NULL;
q1 = NULL;
q2 = NULL;
return 0;