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	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_asynchronous (const struct GNUNET_TESTING_Command cmd)
void	GNUNET_TESTING_interpreter_fail (struct GNUNET_TESTING_Interpreter *is)
	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

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 81 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 GNUNET_TESTING_cmd_finish(), hello_world_run(), peer_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 361 of file testing_api_loop.c.

References GNUNET_TESTING_Command::asynchronous_finish, GNUNET_TESTING_Command::cls, FinishTaskClosure::cmd, GNUNET_TESTING_Interpreter::commands, GNUNET_TESTING_Command::finish, GNUNET_TESTING_Command::finish_task, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), 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_DEBUG,
                "Running command END\n");
    is->result = GNUNET_OK;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Running command `%s'\n",
              cmd->label);
  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))
  {
    ftc = GNUNET_new (struct FinishTaskClosure);
    ftc->cmd = cmd;
    ftc->is = is;
    cmd->finish_task = GNUNET_SCHEDULER_add_now (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 151 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(), and run_finish_task_next().

{
  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 186 of file testing_api_loop.c.

References GNUNET_TESTING_Command::cls, FinishTaskClosure::cmd, GNUNET_TESTING_Command::finish, GNUNET_TESTING_Interpreter::finish_task, GNUNET_SCHEDULER_add_now(), interpreter_next(), and FinishTaskClosure::is.

Referenced by interpreter_run(), and run_finish_task_sync().

{
  struct FinishTaskClosure *ftc = cls;
  const struct GNUNET_TESTING_Command *cmd = ftc->cmd;
  struct GNUNET_TESTING_Interpreter *is = ftc->is;

  if (cmd->finish (cmd->cls, &interpreter_next, is))
  {
    is->finish_task = GNUNET_SCHEDULER_add_now (&run_finish_task_next, ftc);
  }
  else
  {
    is->finish_task = NULL;
  }

}

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 205 of file testing_api_loop.c.

References GNUNET_TIME_Absolute::abs_value_us, SyncTaskClosure::async_cmd, 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_ERROR, GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), SyncTaskClosure::is, FinishTaskClosure::is, GNUNET_TESTING_Command::label, GNUNET_TIME_Relative::rel_value_us, GNUNET_TESTING_Interpreter::result, run_finish_task_next(), 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;

  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);
    is->result = GNUNET_SYSERR;
    GNUNET_SCHEDULER_shutdown ();
  }

  if (cmd->finish (cmd->cls, run_finish_task_next, ftc))
  {
    finish_task = GNUNET_SCHEDULER_add_now (&run_finish_task_sync, stc);
  }
  else
  {
    finish_task = NULL;
  }
}

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 241 of file testing_api_loop.c.

References SyncTaskClosure::async_cmd, SyncState::async_cmd, SyncState::cls, SyncState::finish_task, GNUNET_new, GNUNET_SCHEDULER_add_now(), 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_now (&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 261 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_asynchronous()

const struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_make_asynchronous

(

const struct GNUNET_TESTING_Command

cmd

)

Definition at line 284 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

(

struct GNUNET_TESTING_Interpreter *

is

)

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

Parameters

is	interpreter of the test

Definition at line 308 of file testing_api_loop.c.

References GNUNET_TESTING_Interpreter::commands, 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.

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

  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Failed at command `%s'\n",
              cmd->label);
  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);
  }
  is->result = GNUNET_SYSERR;
  GNUNET_SCHEDULER_shutdown ();
}

Here is the call 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 333 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 346 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 410 of file testing_api_loop.c.

References GNUNET_TESTING_Command::cleanup, GNUNET_TESTING_Command::cls, GNUNET_TESTING_Interpreter::commands, 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 != cmd->finish_task)
    {
      GNUNET_SCHEDULER_cancel (cmd->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 456 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 478 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.

{
  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:

Variable Documentation

is

struct GNUNET_TESTING_Interpreter* is

Definition at line 33 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().