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 "gnunet_testing_plugin.h"
#include "gnunet_testing_barrier.h"
#include "gnunet_testing_netjail_lib.h"
#include "testing.h"

Include dependency graph for testing_api_loop.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_TESTING_Interpreter
	Global state of the interpreter, used by a command to access information about other commands. More...
struct	FreeBarrierNodeCbCls
	Closure for free_barrier_node_cb(). More...
struct	MainParams
	Closure for loop_run(). More...

Functions
static const struct GNUNET_TESTING_Command *	get_command (struct GNUNET_TESTING_Interpreter *is, const char *label, bool future)
	Lookup command by label. More...
const struct GNUNET_TESTING_Command *	GNUNET_TESTING_interpreter_lookup_future_command (struct GNUNET_TESTING_Interpreter *is, const char *label)
	Lookup command by label. More...
const struct GNUNET_TESTING_Command *	GNUNET_TESTING_interpreter_lookup_command (struct GNUNET_TESTING_Interpreter *is, const char *label)
	Lookup command by label. More...
const struct GNUNET_TESTING_Command *	GNUNET_TESTING_interpreter_lookup_command_all (struct GNUNET_TESTING_Interpreter *is, const char *label)
	Lookup command by label. More...
static void	clear_msg (void *cls, enum GNUNET_GenericReturnValue result)
	Continuation function from GNUNET_HELPER_send() More...
static void	send_barrier_crossable (struct GNUNET_TESTING_Interpreter *is, const char *barrier_name, unsigned int global_node_number)
	Send message to a netjail node that a barrier can be crossed. More...
static enum GNUNET_GenericReturnValue	free_barrier_node_cb (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static void	free_barrier_nodes (struct GNUNET_TESTING_Interpreter *is, struct GNUNET_TESTING_Barrier *barrier)
static enum GNUNET_GenericReturnValue	free_barriers_cb (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static void	finish_test (void *cls)
	Finish the test run, return the final result. 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...
void	GNUNET_TESTING_interpreter_fail (struct GNUNET_TESTING_Interpreter *is)
	Current command failed, clean up and fail the test case. More...
void	GNUNET_TESTING_async_fail (struct GNUNET_TESTING_AsyncContext *ac)
	The asynchronous command of ac has failed. More...
void	GNUNET_TESTING_async_finish (struct GNUNET_TESTING_AsyncContext *ac)
	The asynchronous command of ac has finished. More...
struct GNUNET_TESTING_Command *	GNUNET_TESTING_interpreter_get_current_command (struct GNUNET_TESTING_Interpreter *is)
	Returns the actual running command. More...
static void	do_timeout (void *cls)
	Function run when the test terminates (good or bad) with timeout. More...
struct GNUNET_TESTING_Interpreter *	GNUNET_TESTING_run (const struct GNUNET_TESTING_Command *commands, struct GNUNET_TIME_Relative timeout, GNUNET_TESTING_ResultCallback rc, void *rc_cls)
	Run the testsuite. More...
struct GNUNET_TESTING_Command	GNUNET_TESTING_command_new (void *cls, const char *label, GNUNET_TESTING_CommandRunRoutine run, GNUNET_TESTING_CommandCleanupRoutine cleanup, GNUNET_TESTING_CommandGetTraits traits, struct GNUNET_TESTING_AsyncContext *ac)
	Create a new command. More...
void	GNUNET_TESTING_set_label (struct GNUNET_TESTING_CommandLabel *label, const char *value)
	Set label to value. More...
struct GNUNET_TESTING_Command	GNUNET_TESTING_cmd_end (void)
	Create command array terminator. More...
static void	handle_result (void *cls, enum GNUNET_GenericReturnValue rv)
	Function called with the final result of the test. More...
static void	loop_run (void *cls)
	Main function to run the test cases. More...
int	GNUNET_TESTING_main (struct GNUNET_TESTING_Command *commands, struct GNUNET_TIME_Relative timeout)
	Start a GNUnet scheduler event loop and run the testsuite. More...
void	GNUNET_TESTING_add_netjail_helper_ (struct GNUNET_TESTING_Interpreter *is, const struct GNUNET_HELPER_Handle *helper)
	Adding a helper handle to the interpreter. More...
struct GNUNET_TESTING_Barrier *	GNUNET_TESTING_get_barrier_ (struct GNUNET_TESTING_Interpreter *is, const char *barrier_name)
	Getting a barrier from the interpreter. More...
void	GNUNET_TESTING_add_barrier_ (struct GNUNET_TESTING_Interpreter *is, struct GNUNET_TESTING_Barrier *barrier)
	Add a barrier to the interpreter. More...
void	GNUNET_TESTING_finish_barrier_ (struct GNUNET_TESTING_Interpreter *is, const char *barrier_name)
	Finish all "barrier reached" commands attached to this barrier. More...

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.

Function Documentation

get_command()

static const struct GNUNET_TESTING_Command * get_command ( struct GNUNET_TESTING_Interpreter *  is, const char *  label, bool  future  )

static

Lookup command by label.

Parameters

is	interpreter to lookup command in
label	label of the command to lookup.
future	true to look into the future, false to look into the past

Returns

the command, if it is found, or NULL.

Definition at line 126 of file testing_api_loop.c.

{
  int start_i = future ? is->cmds_n - 1 : is->ip;
  int end_i = future ? is->ip + 1 : 0;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "start_i: %u end_i: %u\n",
              start_i,
              end_i);
  if (NULL == label)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Attempt to lookup command for empty label\n");
    return NULL;
  }
  for (int i = start_i; i >= end_i; i--)
  {
    const struct GNUNET_TESTING_Command *cmd = &is->commands[i];
 
    if (NULL != cmd->run)
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "label to compare %s\n",
                  cmd->label.value);
    /* Give precedence to top-level commands.  */
    if ( (NULL != cmd->run) &&
         (0 == strcmp (cmd->label.value,
                       label)) )
      return cmd;
 
    if (GNUNET_TESTING_cmd_is_batch_ (cmd))
    {
      struct GNUNET_TESTING_Command **batch;
      struct GNUNET_TESTING_Command *current;
      const 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_batch_cmds (cmd,
                                                          &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])->run;
           j++)
      {
        if (current == icmd)
          break; /* do not go past current command */
        if ( (NULL != icmd->run) &&
             (0 == strcmp (icmd->label.value,
                           label)) )
          match = icmd;
      }
      if (NULL != match)
        return match;
    }
  }
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Command `%s' not found\n",
              label);
  return NULL;
}

References GNUNET_TESTING_Interpreter::cmds_n, GNUNET_TESTING_Interpreter::commands, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, 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_batch_cmds(), GNUNET_TESTING_Interpreter::ip, is, GNUNET_TESTING_Command::label, run(), GNUNET_TESTING_Command::run, and GNUNET_TESTING_CommandLabel::value.

Referenced by GNUNET_TESTING_interpreter_lookup_command(), GNUNET_TESTING_interpreter_lookup_command_all(), and GNUNET_TESTING_interpreter_lookup_future_command().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_interpreter_lookup_future_command()

const struct GNUNET_TESTING_Command * GNUNET_TESTING_interpreter_lookup_future_command	(	struct GNUNET_TESTING_Interpreter *	is,
		const char *	label
	)

Lookup command by label.

Only future commands are looked up.

Parameters

is	interpreter to lookup command in
label	label of the command to lookup.

Returns

the command, if it is found, or NULL.

Deprecated:

(still in use in a very odd way)

Definition at line 193 of file testing_api_loop.c.

{
  return get_command (is,
                      label,
                      true);
}

References get_command(), is, and GNUNET_TESTING_Command::label.

Here is the call graph for this function:

GNUNET_TESTING_interpreter_lookup_command()

const struct GNUNET_TESTING_Command * GNUNET_TESTING_interpreter_lookup_command	(	struct GNUNET_TESTING_Interpreter *	is,
		const char *	label
	)

Lookup command by label.

Parameters

is	interpreter to lookup command in
label	label of the command to lookup.

Returns

the command, if it is found, or NULL.

Definition at line 204 of file testing_api_loop.c.

{
  return get_command (is,
                      label,
                      false);
}

References get_command(), is, and GNUNET_TESTING_Command::label.

Referenced by backchannel_check_run(), connect_peers_run(), join_room_run(), run_finish(), send_simple_run(), start_peer_run(), start_service_run(), stop_peer_run(), stop_service_run(), stop_testing_system_run(), and system_destroy_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_interpreter_lookup_command_all()

const struct GNUNET_TESTING_Command * GNUNET_TESTING_interpreter_lookup_command_all	(	struct GNUNET_TESTING_Interpreter *	is,
		const char *	label
	)

Lookup command by label.

All commands, first into the past, then into the future are looked up.

Parameters

is	interpreter to lookup command in
label	label of the command to lookup.

Returns

the command, if it is found, or NULL.

Deprecated:

(still in use in a very odd way)

Definition at line 215 of file testing_api_loop.c.

{
  const struct GNUNET_TESTING_Command *cmd;
 
  cmd = get_command (is,
                     label,
                     false);
  if (NULL == cmd)
    cmd = get_command (is,
                       label,
                       true);
  return cmd;
}

References get_command(), is, and GNUNET_TESTING_Command::label.

Referenced by notify_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_msg()

static void clear_msg ( void *  cls, enum GNUNET_GenericReturnValue  result  )

static

Continuation function from GNUNET_HELPER_send()

Parameters

cls	closure
result	GNUNET_OK on success, GNUNET_NO if helper process died GNUNET_SYSERR during GNUNET_HELPER_stop()

Definition at line 241 of file testing_api_loop.c.

{
  GNUNET_assert (GNUNET_YES == result);
}

References GNUNET_assert, GNUNET_YES, and result.

Referenced by send_barrier_crossable().

Here is the caller graph for this function:

send_barrier_crossable()

static void send_barrier_crossable ( struct GNUNET_TESTING_Interpreter *  is, const char *  barrier_name, unsigned int  global_node_number  )

static

Send message to a netjail node that a barrier can be crossed.

Parameters

is	The interpreter loop.
barrier_name	The name of the barrier to cross.
global_node_number	The global number of the node to inform.

FIXME: This should probably be put into a linked list inside is and cleaned up at some point.

Definition at line 256 of file testing_api_loop.c.

{
  struct CommandBarrierCrossable *adm;
  size_t msg_length;
  size_t name_len;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "send barrier crossable for barrier `%s'\n",
              barrier_name);
  name_len = strlen (barrier_name);
  msg_length = sizeof(struct CommandBarrierCrossable) + name_len + 1;
  adm = GNUNET_malloc (msg_length);
  adm->header.type = htons (GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_CROSSABLE);
  adm->header.size = htons ((uint16_t) msg_length);
  memcpy (&adm[1], barrier_name, name_len);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "send message of type %u to locals\n",
              ntohs (adm->header.type));
  is->send_handle = GNUNET_HELPER_send (
    (struct GNUNET_HELPER_Handle *) is->helper[global_node_number - 1],
    &adm->header,
    GNUNET_NO,
    &clear_msg,
    NULL);
  GNUNET_free (adm);
}

References clear_msg(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELPER_send(), GNUNET_log, GNUNET_malloc, GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_CROSSABLE, GNUNET_NO, CommandBarrierCrossable::header, GNUNET_TESTING_Interpreter::helper, is, GNUNET_TESTING_Interpreter::send_handle, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by free_barrier_node_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

free_barrier_node_cb()

static enum GNUNET_GenericReturnValue free_barrier_node_cb ( void *  cls, const struct GNUNET_ShortHashCode *  key, void *  value  )

static

Definition at line 308 of file testing_api_loop.c.

{
  struct FreeBarrierNodeCbCls *free_barrier_node_cb_cls = cls;
  struct GNUNET_TESTING_NetjailNode *node = value;
  struct GNUNET_TESTING_Barrier *barrier = free_barrier_node_cb_cls->barrier;
  struct GNUNET_TESTING_Interpreter *is = free_barrier_node_cb_cls->is;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "free_barrier_node_cb\n");
  if (! is->finishing)
  {
    send_barrier_crossable (is,
                            barrier->name,
                            node->node_number);
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multishortmap_remove (
                   barrier->nodes,
                   key,
                   node));
  return GNUNET_YES;
}

References FreeBarrierNodeCbCls::barrier, GNUNET_TESTING_Interpreter::finishing, GNUNET_assert, GNUNET_CONTAINER_multishortmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_YES, is, FreeBarrierNodeCbCls::is, key, GNUNET_TESTING_Barrier::name, GNUNET_TESTING_NetjailNode::node_number, GNUNET_TESTING_Barrier::nodes, send_barrier_crossable(), and value.

Referenced by free_barrier_nodes().

Here is the call graph for this function:

Here is the caller graph for this function:

free_barrier_nodes()

static void free_barrier_nodes ( struct GNUNET_TESTING_Interpreter *  is, struct GNUNET_TESTING_Barrier *  barrier  )

static

Definition at line 335 of file testing_api_loop.c.

{
  struct FreeBarrierNodeCbCls free_barrier_node_cb_cls = {
    .barrier = barrier,
    .is = is
  };
 
  if (NULL == barrier->nodes)
    return;
  GNUNET_CONTAINER_multishortmap_iterate (barrier->nodes,
                                          free_barrier_node_cb,
                                          &free_barrier_node_cb_cls);
  GNUNET_CONTAINER_multishortmap_destroy (barrier->nodes);
  barrier->nodes = NULL;
}

References FreeBarrierNodeCbCls::barrier, free_barrier_node_cb(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_iterate(), is, and GNUNET_TESTING_Barrier::nodes.

Referenced by free_barriers_cb(), and GNUNET_TESTING_finish_barrier_().

Here is the call graph for this function:

Here is the caller graph for this function:

free_barriers_cb()

static enum GNUNET_GenericReturnValue free_barriers_cb ( void *  cls, const struct GNUNET_ShortHashCode *  key, void *  value  )

static

Definition at line 354 of file testing_api_loop.c.

{
  struct GNUNET_TESTING_Interpreter *is = cls;
  struct GNUNET_TESTING_Barrier *barrier = value;
  struct CommandListEntry *pos;
 
  free_barrier_nodes (is,
                      barrier);
  while (NULL != (pos = barrier->cmds_head))
  {
    GNUNET_CONTAINER_DLL_remove (barrier->cmds_head,
                                 barrier->cmds_tail,
                                 pos);
    GNUNET_free (pos);
  }
  GNUNET_free (barrier);
  return GNUNET_YES;
}

References GNUNET_TESTING_Barrier::cmds_head, GNUNET_TESTING_Barrier::cmds_tail, free_barrier_nodes(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_YES, is, and value.

Referenced by finish_test().

Here is the call graph for this function:

Here is the caller graph for this function:

finish_test()

static void finish_test ( void *  cls )

static

Finish the test run, return the final result.

Parameters

cls	the struct GNUNET_TESTING_Interpreter

Definition at line 382 of file testing_api_loop.c.

{
  struct GNUNET_TESTING_Interpreter *is = cls;
  struct GNUNET_TESTING_Command *cmd;
  const char *label;
 
  is->finishing = true;
  is->final_task = NULL;
  label = is->commands[is->ip].label.value;
  if (NULL == is->commands[is->ip].run)
    label = "END";
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Interpreter finishes at `%s' with status %d\n",
              label,
              is->result);
  for (unsigned int j = 0;
       NULL != (cmd = &is->commands[j])->run;
       j++)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Cleaning up cmd %s\n",
                cmd->label.value);
    cmd->cleanup (cmd->cls);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Cleaned up cmd %s\n",
                cmd->label.value);
  }
  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;
  }
  if (NULL != is->send_handle)
  {
    GNUNET_HELPER_send_cancel (is->send_handle);
    is->send_handle = NULL;
  }
  GNUNET_free (is->commands);
  is->rc (is->rc_cls,
          is->result);
  GNUNET_CONTAINER_multishortmap_iterate (is->barriers,
                                          free_barriers_cb,
                                          is);
  GNUNET_CONTAINER_multishortmap_destroy (is->barriers);
  GNUNET_free (is->helper);
  GNUNET_free (is);
}

References GNUNET_TESTING_Interpreter::barriers, GNUNET_TESTING_Command::cleanup, GNUNET_TESTING_Command::cls, GNUNET_TESTING_Interpreter::commands, GNUNET_TESTING_Interpreter::final_task, GNUNET_TESTING_Interpreter::finishing, free_barriers_cb(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_HELPER_send_cancel(), GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_TESTING_Interpreter::helper, GNUNET_TESTING_Interpreter::ip, is, GNUNET_TESTING_Command::label, GNUNET_TESTING_Interpreter::rc, GNUNET_TESTING_Interpreter::rc_cls, GNUNET_TESTING_Interpreter::result, run(), GNUNET_TESTING_Command::run, GNUNET_TESTING_Interpreter::send_handle, GNUNET_TESTING_Interpreter::task, GNUNET_TESTING_Interpreter::timeout_task, and GNUNET_TESTING_CommandLabel::value.

Referenced by do_timeout(), GNUNET_TESTING_interpreter_fail(), and interpreter_run().

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

{
  struct GNUNET_TESTING_Interpreter *is = cls;
  struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip];
 
  is->task = NULL;
  if (NULL == cmd->run)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Running command END\n");
    is->result = GNUNET_OK;
    finish_test (is);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Running command `%s'\n",
              cmd->label.value);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "start time of %p expected 0 is `%" PRIu64 "'\n",
              cmd,
              cmd->start_time.abs_value_us);
  cmd->start_time
    = cmd->last_req_time
      = GNUNET_TIME_absolute_get ();
  cmd->num_tries = 1;
  if (NULL != cmd->ac)
  {
    cmd->ac->is = is;
    cmd->ac->cont = &interpreter_next;
    cmd->ac->cont_cls = is;
    cmd->ac->finished = false;
  }
  cmd->run (cmd->cls,
            is);
  if (NULL == cmd->ac)
  {
    interpreter_next (is);
  }
  else if ( (cmd->asynchronous_finish) &&
            (NULL != cmd->ac->cont) )
  {
    cmd->ac->cont = NULL;
    interpreter_next (is);
  }
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_TESTING_Command::ac, GNUNET_TESTING_Command::asynchronous_finish, GNUNET_TESTING_Command::cls, GNUNET_TESTING_Interpreter::commands, GNUNET_TESTING_AsyncContext::cont, GNUNET_TESTING_AsyncContext::cont_cls, finish_test(), GNUNET_TESTING_AsyncContext::finished, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_OK, GNUNET_TIME_absolute_get(), interpreter_next(), GNUNET_TESTING_Interpreter::ip, GNUNET_TESTING_AsyncContext::is, is, GNUNET_TESTING_Command::label, GNUNET_TESTING_Command::last_req_time, GNUNET_TESTING_Command::num_tries, GNUNET_TESTING_Interpreter::result, GNUNET_TESTING_Command::run, GNUNET_TESTING_Command::start_time, GNUNET_TESTING_Interpreter::task, and GNUNET_TESTING_CommandLabel::value.

Referenced by GNUNET_TESTING_run(), and interpreter_next().

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

{
  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! */
  cmd->finish_time = GNUNET_TIME_absolute_get ();
  if ( (! GNUNET_TESTING_cmd_is_batch_ (cmd)) ||
       (! GNUNET_TESTING_cmd_batch_next_ (cmd->cls)) )
    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);
}

References GNUNET_TESTING_Command::cls, 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, is, GNUNET_TESTING_Interpreter::result, and GNUNET_TESTING_Interpreter::task.

Referenced by interpreter_run().

Here is the call graph for this function:

Here is the caller graph for this function:

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 state.

Definition at line 479 of file testing_api_loop.c.

{
  struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip];
 
  if (GNUNET_SYSERR == is->result)
  {
    GNUNET_break (0);
    return; /* ignore, we already failed! */
  }
  if (NULL != cmd)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed at command `%s'\n",
                cmd->label.value);
    while (GNUNET_TESTING_cmd_is_batch_ (cmd))
    {
      cmd = GNUNET_TESTING_cmd_batch_get_current_ (cmd);
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed in batch at command `%s'\n",
                  cmd->label.value);
    }
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed with CMD being NULL!\n");
  }
  is->result = GNUNET_SYSERR;
  GNUNET_assert (NULL == is->final_task);
  is->final_task = GNUNET_SCHEDULER_add_now (&finish_test,
                                             is);
}

References GNUNET_TESTING_Interpreter::commands, GNUNET_TESTING_Interpreter::final_task, finish_test(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, GNUNET_TESTING_cmd_batch_get_current_(), GNUNET_TESTING_cmd_is_batch_(), GNUNET_TESTING_Interpreter::ip, is, GNUNET_TESTING_Command::label, GNUNET_TESTING_Interpreter::result, and GNUNET_TESTING_CommandLabel::value.

Referenced by connect_peers_run(), exec_bash_script_run(), GNUNET_TESTING_async_fail(), join_room_run(), netjail_start_run(), netjail_stop_run(), on_message_cb(), run_finish(), start_helper(), start_peer_run(), and start_service_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_async_fail()

void GNUNET_TESTING_async_fail

(

struct GNUNET_TESTING_AsyncContext *

ac

)

The asynchronous command of ac has failed.

Parameters

ac	command-specific context

Definition at line 514 of file testing_api_loop.c.

{
  GNUNET_assert (GNUNET_NO == ac->finished);
  ac->finished = GNUNET_SYSERR;
  GNUNET_TESTING_interpreter_fail (ac->is);
  if (NULL != ac->cont)
  {
    ac->cont (ac->cont_cls);
    ac->cont = NULL;
  }
}

References GNUNET_TESTING_Command::ac, GNUNET_TESTING_AsyncContext::cont, GNUNET_TESTING_AsyncContext::cont_cls, GNUNET_TESTING_AsyncContext::finished, GNUNET_assert, GNUNET_NO, GNUNET_SYSERR, GNUNET_TESTING_interpreter_fail(), and GNUNET_TESTING_AsyncContext::is.

Referenced by child_completed_callback(), exp_cb(), helper_mst(), and timeout_finish().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_async_finish()

void GNUNET_TESTING_async_finish

(

struct GNUNET_TESTING_AsyncContext *

ac

)

The asynchronous command of ac has finished.

Parameters

ac	command-specific context

Definition at line 528 of file testing_api_loop.c.

{
  GNUNET_assert (GNUNET_NO == ac->finished);
  ac->finished = GNUNET_OK;
  if (NULL != ac->cont)
  {
    ac->cont (ac->cont_cls);
    ac->cont = NULL;
  }
}

References GNUNET_TESTING_Command::ac, GNUNET_TESTING_AsyncContext::cont, GNUNET_TESTING_AsyncContext::cont_cls, GNUNET_TESTING_AsyncContext::finished, GNUNET_assert, GNUNET_NO, and GNUNET_OK.

Referenced by backchannel_check_run(), child_completed_callback(), do_timeout(), done_finish(), GNUNET_TESTING_finish_barrier_(), hello_iter_cb(), helper_mst(), notify_connect(), read_from_log(), run_finish(), send_run(), and send_simple_single().

Here is the caller graph for this function:

GNUNET_TESTING_interpreter_get_current_command()

struct GNUNET_TESTING_Command * GNUNET_TESTING_interpreter_get_current_command

(

struct GNUNET_TESTING_Interpreter *

is

)

Returns the actual running command.

Parameters

is	Global state of the interpreter, used by a command to access information about other commands.

Returns

The actual running command.

Definition at line 548 of file testing_api_loop.c.

{
  return &is->commands[is->ip];
}

References GNUNET_TESTING_Interpreter::commands, GNUNET_TESTING_Interpreter::ip, and is.

Referenced by barrier_reached_run(), block_until_all_peers_started_run(), and do_timeout().

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	the interpreter state

Definition at line 614 of file testing_api_loop.c.

{
  struct GNUNET_TESTING_Interpreter *is = cls;
 
  is->timeout_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Terminating test due to global timeout\n");
  is->result = GNUNET_SYSERR;
  finish_test (is);
}

References finish_test(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SYSERR, is, GNUNET_TESTING_Interpreter::result, and GNUNET_TESTING_Interpreter::timeout_task.

Referenced by GNUNET_TESTING_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_run()

struct GNUNET_TESTING_Interpreter * GNUNET_TESTING_run	(	const struct GNUNET_TESTING_Command *	commands,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_TESTING_ResultCallback	rc,
		void *	rc_cls
	)

Run the testsuite.

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

commands	the array of command to execute
timeout	how long to wait for each command to execute
rc	function to call with the final result
rc_cls	closure for rc

Returns

The interpreter.

Definition at line 627 of file testing_api_loop.c.

{
  struct GNUNET_TESTING_Interpreter *is;
  unsigned int i;
 
  is = GNUNET_new (struct GNUNET_TESTING_Interpreter);
  is->rc = rc;
  is->rc_cls = rc_cls;
  is->barriers = GNUNET_CONTAINER_multishortmap_create (1,
                                                        false);
  /* get the number of commands */
  for (i = 0; NULL != commands[i].run; i++)
    ;
  is->cmds_n = i + 1;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got %u commands\n",
              i);
  is->commands = GNUNET_malloc_large ( (i + 1)
                                       * sizeof (struct
                                                 GNUNET_TESTING_Command));
  GNUNET_assert (NULL != is->commands);
  memcpy (is->commands,
          commands,
          sizeof (struct GNUNET_TESTING_Command) * i);
  is->timeout_task
    = GNUNET_SCHEDULER_add_delayed (timeout,
                                    &do_timeout,
                                    is);
  is->task = GNUNET_SCHEDULER_add_now (&interpreter_run,
                                       is);
 
  return is;
}

References GNUNET_TESTING_Interpreter::barriers, GNUNET_TESTING_Interpreter::cmds_n, commands, GNUNET_TESTING_Interpreter::commands, do_timeout(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc_large, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), interpreter_run(), is, GNUNET_TESTING_Interpreter::rc, GNUNET_TESTING_Interpreter::rc_cls, GNUNET_TESTING_Interpreter::task, timeout, and GNUNET_TESTING_Interpreter::timeout_task.

Referenced by loop_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_command_new()

struct GNUNET_TESTING_Command GNUNET_TESTING_command_new	(	void *	cls,
		const char *	label,
		GNUNET_TESTING_CommandRunRoutine	run,
		GNUNET_TESTING_CommandCleanupRoutine	cleanup,
		GNUNET_TESTING_CommandGetTraits	traits,
		struct GNUNET_TESTING_AsyncContext *	ac
	)

Create a new command.

Parameters

cls	the closure
label	the Label. Maximum length is GNUNET_TESTING_CMD_MAX_LABEL_LENGTH
run	the run routing
cleanup	the cleanup function
traits	the traits function (optional)
the	async context

Returns

the command the function cannot fail

Definition at line 666 of file testing_api_loop.c.

{
  struct GNUNET_TESTING_Command cmd = {
    .cls = cls,
    .run = run,
    .ac = ac,
    .cleanup = cleanup,
    .traits = traits
  };
 
  GNUNET_assert (NULL != run);
  if (NULL != label)
    GNUNET_TESTING_set_label (&cmd.label,
                              label);
  return cmd;
}

References GNUNET_TESTING_Command::ac, cleanup(), GNUNET_TESTING_Command::cls, GNUNET_assert, GNUNET_TESTING_set_label(), GNUNET_TESTING_Command::label, run(), and GNUNET_TESTING_Command::traits.

Referenced by GNUNET_CORE_cmd_connect_peers(), GNUNET_MESSENGER_cmd_join_room(), GNUNET_MESSENGER_cmd_start_service(), GNUNET_MESSENGER_cmd_stop_service(), GNUNET_TESTING_cmd_barrier_create(), GNUNET_TESTING_cmd_barrier_reached(), GNUNET_TESTING_cmd_batch(), GNUNET_TESTING_cmd_block_until_external_trigger(), GNUNET_TESTING_cmd_exec_bash_script(), GNUNET_TESTING_cmd_finish(), GNUNET_TESTING_cmd_local_test_prepared(), GNUNET_TESTING_cmd_netjail_start(), GNUNET_TESTING_cmd_netjail_start_cmds_helper(), GNUNET_TESTING_cmd_netjail_stop(), GNUNET_TESTING_cmd_send_peer_ready(), GNUNET_TESTING_cmd_start_peer(), GNUNET_TESTING_cmd_stop_cmds_helper(), GNUNET_TESTING_cmd_stop_peer(), GNUNET_TESTING_cmd_system_create(), GNUNET_TESTING_cmd_system_destroy(), GNUNET_TRANSPORT_cmd_backchannel_check(), GNUNET_TRANSPORT_cmd_connect_peers(), GNUNET_TRANSPORT_cmd_send_simple(), GNUNET_TRANSPORT_cmd_send_simple_performance(), GNUNET_TRANSPORT_cmd_start_peer(), and GNUNET_TRANSPORT_cmd_stop_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_set_label()

void GNUNET_TESTING_set_label	(	struct GNUNET_TESTING_CommandLabel *	label,
		const char *	value
	)

Set label to value.

Asserts that value is not longer than GNUNET_TESTING_CMD_MAX_LABEL_LENGTH.

Parameters

[out]	label	label to initialize
	value	value to store into label

Definition at line 690 of file testing_api_loop.c.

{
  size_t len;
 
  len = strlen (value);
  GNUNET_assert (len <=
                 GNUNET_TESTING_CMD_MAX_LABEL_LENGTH);
  memcpy (label->value,
          value,
          len + 1);
}

References GNUNET_assert, GNUNET_TESTING_CMD_MAX_LABEL_LENGTH, GNUNET_TESTING_Command::label, value, and GNUNET_TESTING_CommandLabel::value.

Referenced by GNUNET_TESTING_cmd_batch(), GNUNET_TESTING_command_new(), and GNUNET_TESTING_DHTU_cmd_send().

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

{
  struct GNUNET_TESTING_Command cmd = {
    .run = NULL
  };
 
  return cmd;
}

References GNUNET_TESTING_Command::run.

handle_result()

static void handle_result ( void *  cls, enum GNUNET_GenericReturnValue  rv  )

static

Function called with the final result of the test.

Parameters

cls	the struct MainParams
rv	GNUNET_OK if the test passed

Definition at line 746 of file testing_api_loop.c.

{
  struct MainParams *mp = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Test exits with status %d\n",
              rv);
  if (GNUNET_OK != rv)
    mp->rv = EXIT_FAILURE;
  GNUNET_SCHEDULER_shutdown ();
}

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), and MainParams::rv.

Referenced by loop_run().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_run()

static void loop_run ( void *  cls )

static

Main function to run the test cases.

Parameters

cls	a struct MainParams *

Definition at line 766 of file testing_api_loop.c.

{
  struct MainParams *mp = cls;
 
  GNUNET_TESTING_run (mp->commands,
                      mp->timeout,
                      &handle_result,
                      mp);
}

References MainParams::commands, GNUNET_TESTING_run(), handle_result(), and MainParams::timeout.

Referenced by GNUNET_TESTING_main().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_main()

int GNUNET_TESTING_main	(	struct GNUNET_TESTING_Command *	commands,
		struct GNUNET_TIME_Relative	timeout
	)

Start a GNUnet scheduler event loop and run the testsuite.

Return 0 upon success. Expected to be called directly from main(). FIXME: Why is this commands array here not const?

Parameters

commands	the list of command to execute
timeout	how long to wait for each command to execute

Returns

EXIT_SUCCESS on success, EXIT_FAILURE on failure

Definition at line 778 of file testing_api_loop.c.

{
  struct MainParams mp = {
    .commands = commands,
    .timeout = timeout,
    .rv = EXIT_SUCCESS
  };
 
  GNUNET_SCHEDULER_run (&loop_run,
                        &mp);
  return mp.rv;
}

References commands, MainParams::commands, GNUNET_SCHEDULER_run(), loop_run(), MainParams::rv, and timeout.

Here is the call graph for this function:

GNUNET_TESTING_add_netjail_helper_()

void GNUNET_TESTING_add_netjail_helper_	(	struct GNUNET_TESTING_Interpreter *	is,
		const struct GNUNET_HELPER_Handle *	helper
	)

Adding a helper handle to the interpreter.

Parameters

is	The interpreter.
helper	The helper handle.

Definition at line 794 of file testing_api_loop.c.

{
  GNUNET_array_append (is->helper,
                       is->n_helper,
                       helper);
}

References GNUNET_array_append, GNUNET_TESTING_Interpreter::helper, is, and GNUNET_TESTING_Interpreter::n_helper.

Referenced by start_helper().

Here is the caller graph for this function:

GNUNET_TESTING_get_barrier_()

struct GNUNET_TESTING_Barrier * GNUNET_TESTING_get_barrier_	(	struct GNUNET_TESTING_Interpreter *	is,
		const char *	barrier_name
	)

Getting a barrier from the interpreter.

Parameters

is	The interpreter.
barrier_name	The name of the barrier.

Returns

The barrier.

Definition at line 804 of file testing_api_loop.c.

{
  struct GNUNET_HashCode hc;
  struct GNUNET_ShortHashCode create_key;
 
  GNUNET_CRYPTO_hash (barrier_name,
                      strlen (barrier_name),
                      &hc);
  memcpy (&create_key,
          &hc,
          sizeof (create_key));
  return GNUNET_CONTAINER_multishortmap_get (is->barriers,
                                             &create_key);
}

References GNUNET_TESTING_Interpreter::barriers, GNUNET_CONTAINER_multishortmap_get(), GNUNET_CRYPTO_hash(), and is.

Referenced by barrier_attached(), barrier_reached(), barrier_reached_run(), GNUNET_TESTING_finish_barrier_(), and start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_add_barrier_()

void GNUNET_TESTING_add_barrier_	(	struct GNUNET_TESTING_Interpreter *	is,
		struct GNUNET_TESTING_Barrier *	barrier
	)

Add a barrier to the interpreter.

Add a barrier to the loop.

Parameters

is	The interpreter.
barrier	The barrier to add.

Definition at line 828 of file testing_api_loop.c.

{
  struct GNUNET_HashCode hc;
  struct GNUNET_ShortHashCode create_key;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding barrier %s locally\n",
              barrier->name);
  GNUNET_CRYPTO_hash (barrier->name,
                      strlen (barrier->name),
                      &hc);
  memcpy (&create_key,
          &hc,
          sizeof (create_key));
  GNUNET_CONTAINER_multishortmap_put (is->barriers,
                                      &create_key,
                                      barrier,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
}

References GNUNET_TESTING_Interpreter::barriers, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multishortmap_put(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, is, and GNUNET_TESTING_Barrier::name.

Referenced by barrier_reached_run(), barrier_run(), and start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_finish_barrier_()

void GNUNET_TESTING_finish_barrier_	(	struct GNUNET_TESTING_Interpreter *	is,
		const char *	barrier_name
	)

Finish all "barrier reached" commands attached to this barrier.

Parameters

barrier

The barrier in question.

Definition at line 851 of file testing_api_loop.c.

{
  struct CommandListEntry *pos;
  struct GNUNET_TESTING_Barrier *barrier;
 
  barrier = GNUNET_TESTING_get_barrier_ (is,
                                         barrier_name);
  if (NULL == barrier)
    return;
  while (NULL != (pos = barrier->cmds_head))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "command label %s\n",
                pos->command->label.value);
    if ( (GNUNET_NO == pos->command->ac->finished) &&
         (GNUNET_NO == pos->command->asynchronous_finish) )
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "command label %s finish\n",
                  pos->command->label.value);
      GNUNET_TESTING_async_finish (pos->command->ac);
    }
    else if (GNUNET_NO == pos->command->ac->finished)
    {
      pos->command->asynchronous_finish = GNUNET_YES;
    }
    GNUNET_CONTAINER_DLL_remove (barrier->cmds_head,
                                 barrier->cmds_tail,
                                 pos);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "command entry label %s removed\n",
                pos->command->label.value);
    GNUNET_free (pos);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "command entry freed\n");
  }
  free_barrier_nodes (is,
                      barrier);
}

References GNUNET_TESTING_Command::ac, GNUNET_TESTING_Command::asynchronous_finish, GNUNET_TESTING_Barrier::cmds_head, GNUNET_TESTING_Barrier::cmds_tail, CommandListEntry::command, GNUNET_TESTING_AsyncContext::finished, free_barrier_nodes(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_TESTING_async_finish(), GNUNET_TESTING_get_barrier_(), GNUNET_YES, is, GNUNET_TESTING_Command::label, and GNUNET_TESTING_CommandLabel::value.

Referenced by barrier_reached(), barrier_reached_run(), and tokenizer_cb().

Here is the call graph for this function:

Here is the caller graph for this function: