testing_api_loop.c File Reference

main interpreter loop for testcases More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testing_ng_lib.h"
#include "testing.h"

Include dependency graph for testing_api_loop.c:

Go to the source code of this file.

Data Structures
struct	SyncTaskClosure
	Closure used to sync an asynchronous with an synchronous command. More...
struct	FinishTaskClosure
	Closure used to run the finish task. More...

Macros
#define	CHECK_FINISHED_PERIOD   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
#define	BATCH_INDEX   1

Functions
const struct GNUNET_TESTING_Command *	GNUNET_TESTING_interpreter_lookup_command (const char *label)
	Lookup command by label. More...
static void	interpreter_run (void *cls)
	Run the main interpreter loop that performs exchange operations. More...
static void	interpreter_next (void *cls)
	Current command is done, run the next one. More...
static void	run_finish_task_next (void *cls)
static void	run_finish_task_sync (void *cls)
static void	start_finish_on_ref (void *cls, const struct GNUNET_TESTING_Command *cmd, struct GNUNET_TESTING_Interpreter *is)
const struct GNUNET_TESTING_Command	GNUNET_TESTING_cmd_finish (const char *finish_label, const char *cmd_ref, struct GNUNET_TIME_Relative timeout)
	Create (synchronous) command that waits for another command to finish. More...
const struct GNUNET_TESTING_Command	GNUNET_TESTING_cmd_make_unblocking (const struct GNUNET_TESTING_Command cmd)
	Turn asynchronous command into non blocking command by setting asynchronous_finish to true. More...
void	GNUNET_TESTING_interpreter_fail ()
	Current command failed, clean up and fail the test case. More...
struct GNUNET_TESTING_Command	GNUNET_TESTING_cmd_end (void)
	Create command array terminator. More...
const char *	GNUNET_TESTING_interpreter_get_current_label (struct GNUNET_TESTING_Interpreter *is)
	Obtain current label. More...
static void	do_shutdown (void *cls)
	Function run when the test terminates (good or bad). More...
static void	do_timeout (void *cls)
	Function run when the test terminates (good or bad) with timeout. More...
int	GNUNET_TESTING_run (const char *cfg_filename, struct GNUNET_TESTING_Command *commands, struct GNUNET_TIME_Relative timeout)
	Run the testsuite. More...

Variables
struct GNUNET_TESTING_Interpreter *	is

Detailed Description

main interpreter loop for testcases

Author

Christian Grothoff (GNU Taler testing)

Marcello Stanisci (GNU Taler testing)

t3sserakt

Definition in file testing_api_loop.c.

Macro Definition Documentation

CHECK_FINISHED_PERIOD

#define CHECK_FINISHED_PERIOD   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)

Definition at line 33 of file testing_api_loop.c.

Referenced by interpreter_run(), run_finish_task_next(), run_finish_task_sync(), and start_finish_on_ref().

BATCH_INDEX

#define BATCH_INDEX   1

Referenced by GNUNET_TESTING_interpreter_lookup_command().

Function Documentation

GNUNET_TESTING_interpreter_lookup_command()

const struct GNUNET_TESTING_Command* GNUNET_TESTING_interpreter_lookup_command

(

const char *

label

)

Lookup command by label.

Parameters

label

label to look for

Returns

NULL if command was not found

Definition at line 84 of file testing_api_loop.c.

References BATCH_INDEX, GNUNET_TESTING_Command::cls, GNUNET_TESTING_Interpreter::commands, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OK, GNUNET_TESTING_cmd_batch_get_current(), GNUNET_TESTING_cmd_is_batch(), GNUNET_TESTING_get_trait_cmd(), interpreter_run(), GNUNET_TESTING_Interpreter::ip, and GNUNET_TESTING_Command::label.

Referenced by connect_peers_run(), GNUNET_TESTING_cmd_finish(), hello_world_run(), peer_run(), send_simple_run(), start_peer_run(), stop_testbed_run(), and tng_service_run().

{
  if (NULL == label)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Attempt to lookup command for empty label\n");
    return NULL;
  }
  /* Search backwards as we most likely reference recent commands */
  for (int i = is->ip; i >= 0; i--)
  {
    const struct GNUNET_TESTING_Command *cmd = &is->commands[i];

    /* Give precedence to top-level commands.  */
    if ( (NULL != cmd->label) &&
         (0 == strcmp (cmd->label,
                       label)) )
      return cmd;

    if (GNUNET_TESTING_cmd_is_batch (cmd))
    {
#define BATCH_INDEX 1
      struct GNUNET_TESTING_Command *batch;
      struct GNUNET_TESTING_Command *current;
      struct GNUNET_TESTING_Command *icmd;
      const struct GNUNET_TESTING_Command *match;

      current = GNUNET_TESTING_cmd_batch_get_current (cmd);
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_TESTING_get_trait_cmd (cmd,
                                                   BATCH_INDEX,
                                                   &batch));
      /* We must do the loop forward, but we can find the last match */
      match = NULL;
      for (unsigned int j = 0;
           NULL != (icmd = &batch[j])->label;
           j++)
      {
        if (current == icmd)
          break; /* do not go past current command */
        if ( (NULL != icmd->label) &&
             (0 == strcmp (icmd->label,
                           label)) )
          match = icmd;
      }
      if (NULL != match)
        return match;
    }
  }
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Command not found: %s\n",
              label);
  return NULL;

}

Here is the call graph for this function:

Here is the caller graph for this function:

interpreter_run()

static void interpreter_run ( void *  cls )

static

Run the main interpreter loop that performs exchange operations.

Run the main interpreter loop.

Parameters

cls	contains the struct InterpreterState
cls	contains the struct GNUNET_TESTING_Interpreter

Definition at line 407 of file testing_api_loop.c.

References GNUNET_TESTING_Command::asynchronous_finish, CHECK_FINISHED_PERIOD, GNUNET_TESTING_Command::cls, FinishTaskClosure::cmd, GNUNET_TESTING_Interpreter::commands, GNUNET_TESTING_Command::finish, GNUNET_TESTING_Interpreter::finish_task, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_absolute_get(), interpreter_next(), GNUNET_TESTING_Interpreter::ip, SyncTaskClosure::is, FinishTaskClosure::is, GNUNET_TESTING_Command::label, GNUNET_TESTING_Command::last_req_time, GNUNET_TESTING_Command::num_tries, GNUNET_TESTING_Interpreter::result, GNUNET_TESTING_Command::run, run_finish_task_next(), GNUNET_TESTING_Command::start_time, and GNUNET_TESTING_Interpreter::task.

Referenced by GNUNET_TESTING_interpreter_lookup_command(), GNUNET_TESTING_run(), and interpreter_next().

{
  struct FinishTaskClosure *ftc;
  struct GNUNET_TESTING_Interpreter *is = cls;
  struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip];

  is->task = NULL;

  if (NULL == cmd->label)
  {

    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Running command END %p\n",
                is);
    is->result = GNUNET_OK;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  else if (NULL != cmd)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Running command `%s' %p\n",
                cmd->label,
                is);
  }
  cmd->start_time
    = cmd->last_req_time
      = GNUNET_TIME_absolute_get ();
  cmd->num_tries = 1;
  cmd->run (cmd->cls,
            cmd,
            is);
  if ((NULL != cmd->finish) && (GNUNET_NO == cmd->asynchronous_finish))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Next task will not be called directly!\n");
    ftc = GNUNET_new (struct FinishTaskClosure);
    ftc->cmd = cmd;
    ftc->is = is;
    is->finish_task = GNUNET_SCHEDULER_add_delayed (CHECK_FINISHED_PERIOD,
                                                    &run_finish_task_next,
                                                    ftc);
  }
  else
  {
    interpreter_next (is);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

interpreter_next()

static void interpreter_next ( void *  cls )

static

Current command is done, run the next one.

Definition at line 154 of file testing_api_loop.c.

References GNUNET_TESTING_Interpreter::commands, GNUNET_TESTING_Command::finish_time, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TESTING_cmd_batch_next(), GNUNET_TESTING_cmd_is_batch(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, interpreter_run(), GNUNET_TESTING_Interpreter::ip, GNUNET_TESTING_Interpreter::result, and GNUNET_TESTING_Interpreter::task.

Referenced by interpreter_run(), run_finish_task_next(), and run_finish_task_sync().

{
  struct GNUNET_TESTING_Interpreter *is = cls;
  static unsigned long long ipc;
  static struct GNUNET_TIME_Absolute last_report;
  struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip];

  if (GNUNET_SYSERR == is->result)
    return; /* ignore, we already failed! */
  if (GNUNET_TESTING_cmd_is_batch (cmd))
  {
    GNUNET_TESTING_cmd_batch_next (is);
  }
  else
  {
    cmd->finish_time = GNUNET_TIME_absolute_get ();
    is->ip++;
  }
  if (0 == (ipc % 1000))
  {
    if (0 != ipc)
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  "Interpreter executed 1000 instructions in %s\n",
                  GNUNET_STRINGS_relative_time_to_string (
                    GNUNET_TIME_absolute_get_duration (last_report),
                    GNUNET_YES));
    last_report = GNUNET_TIME_absolute_get ();
  }
  ipc++;
  is->task = GNUNET_SCHEDULER_add_now (&interpreter_run,
                                       is);
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_finish_task_next()

static void run_finish_task_next ( void *  cls )

static

Definition at line 189 of file testing_api_loop.c.

References CHECK_FINISHED_PERIOD, GNUNET_TESTING_Command::cls, FinishTaskClosure::cmd, GNUNET_TESTING_Command::finish, GNUNET_TESTING_Interpreter::finish_task, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTING_interpreter_fail(), GNUNET_YES, interpreter_next(), and FinishTaskClosure::is.

Referenced by interpreter_run().

{
  struct FinishTaskClosure *ftc = cls;
  const struct GNUNET_TESTING_Command *cmd = ftc->cmd;
  struct GNUNET_TESTING_Interpreter *is = ftc->is;
  unsigned int finished = cmd->finish (cmd->cls, &interpreter_next, is);

  if (GNUNET_YES == finished)
  {
    is->finish_task = NULL;
  }
  else if (GNUNET_NO == finished)
  {
    is->finish_task = GNUNET_SCHEDULER_add_delayed (CHECK_FINISHED_PERIOD,
                                                    &run_finish_task_next, ftc);
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Next task finished with an error.\n");
    GNUNET_TESTING_interpreter_fail ();
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

run_finish_task_sync()

static void run_finish_task_sync ( void *  cls )

static

Definition at line 216 of file testing_api_loop.c.

References GNUNET_TIME_Absolute::abs_value_us, SyncTaskClosure::async_cmd, CHECK_FINISHED_PERIOD, GNUNET_TESTING_Command::cls, FinishTaskClosure::cmd, GNUNET_TESTING_Command::default_timeout, GNUNET_TESTING_Command::finish, SyncState::finish_task, finish_task(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTING_interpreter_fail(), GNUNET_TIME_absolute_get(), GNUNET_YES, interpreter_next(), SyncTaskClosure::is, FinishTaskClosure::is, GNUNET_TESTING_Command::label, GNUNET_TIME_Relative::rel_value_us, SyncState::start_finish_time, and SyncTaskClosure::sync_cmd.

Referenced by start_finish_on_ref().

{
  struct SyncTaskClosure *stc = cls;
  const struct GNUNET_TESTING_Command *cmd = stc->async_cmd;
  const struct GNUNET_TESTING_Command *sync_cmd = stc->sync_cmd;
  struct FinishTaskClosure *ftc;
  struct SyncState *sync_state = sync_cmd->cls;
  struct GNUNET_SCHEDULER_Task *finish_task = sync_state->finish_task;
  unsigned int finished = cmd->finish (cmd->cls, &interpreter_next, is);

  GNUNET_assert (NULL != finish_task);
  ftc = GNUNET_new (struct FinishTaskClosure);
  ftc->cmd = stc->sync_cmd;
  ftc->is = stc->is;
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  if (cmd->default_timeout.rel_value_us < now.abs_value_us
      - sync_state->start_finish_time.abs_value_us)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "The command with label %s did not finish its asynchronous task in time.\n",
                cmd->label);
    GNUNET_TESTING_interpreter_fail ();
  }

  if (GNUNET_YES == finished)
  {
    finish_task = NULL;
  }
  else if (GNUNET_NO == finished)
  {
    finish_task = GNUNET_SCHEDULER_add_delayed (CHECK_FINISHED_PERIOD,
                                                &run_finish_task_sync, stc);
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sync task finished with an error.\n");
    GNUNET_TESTING_interpreter_fail ();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_finish_on_ref()

static void start_finish_on_ref ( void *  cls, const struct GNUNET_TESTING_Command *  cmd, struct GNUNET_TESTING_Interpreter *  is  )

static

Definition at line 259 of file testing_api_loop.c.

References SyncTaskClosure::async_cmd, SyncState::async_cmd, CHECK_FINISHED_PERIOD, SyncState::cls, SyncState::finish_task, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_absolute_get(), SyncTaskClosure::is, run_finish_task_sync(), SyncState::start_finish_time, and SyncTaskClosure::sync_cmd.

Referenced by GNUNET_TESTING_cmd_finish().

{
  struct SyncState *sync_state = cls;
  struct SyncTaskClosure *stc;
  const struct GNUNET_TESTING_Command *async_cmd;

  async_cmd = sync_state->async_cmd;
  stc = GNUNET_new (struct SyncTaskClosure);
  stc->async_cmd = async_cmd;
  stc->sync_cmd = cmd;
  stc->is = is;
  sync_state->start_finish_time = GNUNET_TIME_absolute_get ();
  sync_state->finish_task = GNUNET_SCHEDULER_add_delayed (
    CHECK_FINISHED_PERIOD,
    &run_finish_task_sync,
    stc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_cmd_finish()

const struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_finish	(	const char *	finish_label,
		const char *	cmd_ref,
		struct GNUNET_TIME_Relative	timeout
	)

Create (synchronous) command that waits for another command to finish.

If cmd_ref did not finish after timeout, this command will fail the test case.

Parameters

finish_label	label for this command
cmd_ref	reference to a previous command which we should wait for (call finish() on)
timeout	how long to wait at most for cmd_ref to finish

Returns

a finish-command.

Definition at line 281 of file testing_api_loop.c.

References SyncTaskClosure::async_cmd, SyncState::async_cmd, GNUNET_TESTING_Command::cls, GNUNET_new, GNUNET_NO, GNUNET_TESTING_interpreter_lookup_command(), GNUNET_TESTING_Command::run, and start_finish_on_ref().

{
  const struct GNUNET_TESTING_Command *async_cmd;
  struct SyncState *sync_state;

  async_cmd = GNUNET_TESTING_interpreter_lookup_command (cmd_ref);
  sync_state = GNUNET_new (struct SyncState);
  sync_state->async_cmd = async_cmd;

  struct GNUNET_TESTING_Command cmd = {
    .cls = sync_state,
    .label = finish_label,
    .run = &start_finish_on_ref,
    .asynchronous_finish = GNUNET_NO
  };

  return cmd;
}

Here is the call graph for this function:

GNUNET_TESTING_cmd_make_unblocking()

const struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_make_unblocking

(

const struct GNUNET_TESTING_Command

cmd

)

Turn asynchronous command into non blocking command by setting asynchronous_finish to true.

Parameters

cmd	command to make synchronous.

Returns

a finish-command.

Definition at line 304 of file testing_api_loop.c.

References SyncTaskClosure::async_cmd, GNUNET_TESTING_Command::cls, GNUNET_assert, and GNUNET_YES.

{

  GNUNET_assert (NULL != cmd.finish);
  const struct GNUNET_TESTING_Command async_cmd = {
    .cls = cmd.cls,
    .label = cmd.label,
    .run = cmd.run,
    .cleanup = cmd.cleanup,
    .traits = cmd.traits,
    .finish = cmd.finish,
    .asynchronous_finish = GNUNET_YES
  };

  return async_cmd;
}

GNUNET_TESTING_interpreter_fail()

void GNUNET_TESTING_interpreter_fail

(

)

Current command failed, clean up and fail the test case.

Parameters

is	interpreter of the test

Definition at line 328 of file testing_api_loop.c.

References GNUNET_TESTING_Interpreter::commands, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_TESTING_cmd_batch_get_current(), GNUNET_TESTING_cmd_is_batch(), GNUNET_TESTING_Interpreter::ip, GNUNET_TESTING_Command::label, and GNUNET_TESTING_Interpreter::result.

Referenced by exp_cb(), run_finish_task_next(), run_finish_task_sync(), start_peer_run(), and start_testbed().

{
  struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip];

  if (GNUNET_SYSERR == is->result)
    return; /* ignore, we already failed! */

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "interpreter_fail!\n");

  if (NULL != cmd)
  {
    while (GNUNET_TESTING_cmd_is_batch (cmd))
    {
      cmd = GNUNET_TESTING_cmd_batch_get_current (cmd);
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Batch is at command `%s'\n",
                  cmd->label);
    }

  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "cmd is NULL.\n");
  }

  if (NULL == cmd->label)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed at command `%s'\n",
                cmd->label);

  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "cmd->label is NULL.\n");
  }

  is->result = GNUNET_SYSERR;
  GNUNET_SCHEDULER_shutdown ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_cmd_end()

struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_end

(

void

)

Create command array terminator.

Returns

a end-command.

Definition at line 379 of file testing_api_loop.c.

References GNUNET_TESTING_Command::label.

{
  static struct GNUNET_TESTING_Command cmd;
  cmd.label = NULL;

  return cmd;
}

GNUNET_TESTING_interpreter_get_current_label()

const char* GNUNET_TESTING_interpreter_get_current_label

(

struct GNUNET_TESTING_Interpreter *

is

)

Obtain current label.

Obtain label of the command being now run.

Definition at line 392 of file testing_api_loop.c.

References GNUNET_TESTING_Interpreter::commands, GNUNET_TESTING_Interpreter::ip, and GNUNET_TESTING_Command::label.

{
  struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip];

  return cmd->label;
}

do_shutdown()

static void do_shutdown ( void *  cls )

static

Function run when the test terminates (good or bad).

Cleans up our state.

Parameters

cls	the interpreter state.

Definition at line 464 of file testing_api_loop.c.

References GNUNET_TESTING_Command::cleanup, GNUNET_TESTING_Command::cls, GNUNET_TESTING_Interpreter::commands, GNUNET_TESTING_Interpreter::finish_task, GNUNET_TESTING_Command::finish_task, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_TESTING_Interpreter::ip, GNUNET_TESTING_Command::label, GNUNET_TESTING_Interpreter::task, and GNUNET_TESTING_Interpreter::timeout_task.

Referenced by GNUNET_TESTING_run().

{
  (void) cls;
  struct GNUNET_TESTING_Command *cmd;
  const char *label;

  label = is->commands[is->ip].label;
  if (NULL == label)
    label = "END";

  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Executing shutdown at `%s'\n",
              label);

  for (unsigned int j = 0;
       NULL != (cmd = &is->commands[j])->label;
       j++) {
    cmd->cleanup (cmd->cls,
                  cmd);
  }

  if (NULL != is->finish_task)
  {
    GNUNET_SCHEDULER_cancel (is->finish_task);
    cmd->finish_task = NULL;
  }

  if (NULL != is->task)
  {
    GNUNET_SCHEDULER_cancel (is->task);
    is->task = NULL;
  }
  if (NULL != is->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (is->timeout_task);
    is->timeout_task = NULL;
  }
  GNUNET_free (is->commands);
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_timeout()

static void do_timeout ( void *  cls )

static

Function run when the test terminates (good or bad) with timeout.

Parameters

cls

NULL

Definition at line 511 of file testing_api_loop.c.

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_shutdown(), and GNUNET_TESTING_Interpreter::timeout_task.

Referenced by GNUNET_TESTING_run().

{
  (void) cls;

  is->timeout_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Terminating test due to timeout\n");
  GNUNET_SCHEDULER_shutdown ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_run()

int GNUNET_TESTING_run	(	const char *	cfg_filename,
		struct GNUNET_TESTING_Command *	commands,
		struct GNUNET_TIME_Relative	timeout
	)

Run the testsuite.

Wait until we receive SIGCHLD signal.

Note, CMDs are copied into the interpreter state because they are usually defined into the "run" method that returns after having scheduled the test interpreter.

Parameters

is	the interpreter state
commands	the list of command to execute
timeout	how long to wait

Definition at line 533 of file testing_api_loop.c.

References GNUNET_TESTING_Interpreter::commands, do_shutdown(), do_timeout(), GNUNET_new, GNUNET_new_array, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_cancel(), interpreter_run(), GNUNET_TESTING_Command::label, GNUNET_TESTING_Interpreter::task, and GNUNET_TESTING_Interpreter::timeout_task.

Referenced by start_testcase().

{
  unsigned int i;

  is = GNUNET_new (struct GNUNET_TESTING_Interpreter);

  if (NULL != is->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (is->timeout_task);
    is->timeout_task = NULL;
  }
  /* get the number of commands */
  for (i = 0; NULL != commands[i].label; i++)
    ;
  is->commands = GNUNET_new_array (i + 1,
                                   struct GNUNET_TESTING_Command);
  memcpy (is->commands,
          commands,
          sizeof (struct GNUNET_TESTING_Command) * i);

  is->timeout_task = GNUNET_SCHEDULER_add_delayed
                       (timeout,
                       &do_timeout,
                       is);
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, is);
  is->task = GNUNET_SCHEDULER_add_now (&interpreter_run, is);
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

is

struct GNUNET_TESTING_Interpreter* is

Definition at line 36 of file testing_api_loop.c.

Referenced by check_backchannel_encapsulation(), check_communicator_backchannel(), controller_run(), get_addresses(), GNUNET_NT_scanner_init(), handle_communicator_backchannel(), interface_proc(), peer_run(), and tng_service_run().