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
struct	MainParams
	Closure for loop_run(). More...

Functions
static const struct GNUNET_TESTING_Command *	get_command (struct GNUNET_TESTING_Interpreter *is, const char *label, unsigned int future)
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...
int	free_barrier_node_cb (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static int	free_barriers_cb (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static void	interpreter_delete_barriers (struct GNUNET_TESTING_Interpreter *is)
	Deleting all barriers create in the context of this interpreter. More...
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...
struct GNUNET_TESTING_Command *	GNUNET_TESTING_interpreter_get_current_command (struct GNUNET_TESTING_Interpreter *is)
	Returns the actual running command. More...
const char *	GNUNET_TESTING_interpreter_get_current_label (struct GNUNET_TESTING_Interpreter *is)
	Obtain label of the command being now run. More...
static void	do_timeout (void *cls)
	Function run when the test terminates (good or bad) with timeout. More...
enum GNUNET_GenericReturnValue	GNUNET_TESTING_running (const struct GNUNET_TESTING_Command *command)
	Check if the command is running. More...
enum GNUNET_GenericReturnValue	GNUNET_TESTING_finished (const struct GNUNET_TESTING_Command *command)
	Check if a command is finished. 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...
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...
static void	clear_msg (void *cls, int result)
	Continuation function from GNUNET_HELPER_send() 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...
void	send_message_to_netjail (struct GNUNET_TESTING_Interpreter *is, unsigned int global_node_number, struct GNUNET_MessageHeader *header)
	Send Message to netjail nodes. More...
void	TST_interpreter_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...
struct GNUNET_TESTING_Barrier *	TST_interpreter_get_barrier (struct GNUNET_TESTING_Interpreter *is, const char *barrier_name)
	Getting a barrier from the interpreter. More...
void	TST_interpreter_finish_attached_cmds (struct GNUNET_TESTING_Interpreter *is, const char *barrier_name)
	Finish all "barrier reached" comands attached to this barrier. More...
void	TST_interpreter_add_barrier (struct GNUNET_TESTING_Interpreter *is, struct GNUNET_TESTING_Barrier *barrier)
	Add a barrier to the loop. 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_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...

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, unsigned int  future  )

static

Definition at line 127 of file testing_api_loop.c.

{
  int start_i = GNUNET_NO == future ? is->ip : is->cmds_n - 1;
  int end_i = GNUNET_NO == future ? 0 : is->ip + 1;
 
  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);
    /* Give precedence to top-level commands.  */
    if ( (NULL != cmd->run) &&
         (0 == strcmp (cmd->label,
                       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,
                           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_NO, 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(), and GNUNET_TESTING_Command::run.

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.

Definition at line 203 of file testing_api_loop.c.

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

References get_command(), GNUNET_YES, 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.

Only commands from current command to commands in the past 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.

Definition at line 220 of file testing_api_loop.c.

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

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

Referenced by backchannel_check_run(), connect_peers_run(), run_finish(), send_simple_run(), start_peer_run(), stop_peer_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.

Definition at line 229 of file testing_api_loop.c.

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

References get_command(), GNUNET_NO, GNUNET_YES, 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:

free_barrier_node_cb()

int free_barrier_node_cb	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

Definition at line 243 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 (GNUNET_NO == is->finishing)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "TST_interpreter_send_barrier_crossable\n");
    TST_interpreter_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_NO, GNUNET_YES, is, FreeBarrierNodeCbCls::is, key, GNUNET_TESTING_Barrier::name, GNUNET_TESTING_NetjailNode::node_number, GNUNET_TESTING_Barrier::nodes, TST_interpreter_send_barrier_crossable(), and value.

Referenced by free_barriers_cb(), and TST_interpreter_finish_attached_cmds().

Here is the call graph for this function:

Here is the caller graph for this function:

free_barriers_cb()

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

static

Definition at line 269 of file testing_api_loop.c.

{
  struct GNUNET_TESTING_Interpreter *is = cls;
  struct GNUNET_TESTING_Barrier *barrier = value;
  struct CommandListEntry *pos;
  struct FreeBarrierNodeCbCls *free_barrier_node_cb_cls;
 
  if (NULL != barrier->nodes)
  {
    free_barrier_node_cb_cls = GNUNET_new (struct FreeBarrierNodeCbCls);
    free_barrier_node_cb_cls->barrier = barrier;
    free_barrier_node_cb_cls->is = is;
    GNUNET_CONTAINER_multishortmap_iterate (barrier->nodes,
                                            free_barrier_node_cb,
                                            free_barrier_node_cb_cls);
    GNUNET_CONTAINER_multishortmap_destroy (barrier->nodes);
    barrier->nodes = NULL;
  }
 
  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 FreeBarrierNodeCbCls::barrier, GNUNET_TESTING_Barrier::cmds_head, GNUNET_TESTING_Barrier::cmds_tail, free_barrier_node_cb(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_free, GNUNET_new, GNUNET_YES, is, FreeBarrierNodeCbCls::is, GNUNET_TESTING_Barrier::nodes, and value.

Referenced by interpreter_delete_barriers().

Here is the call graph for this function:

Here is the caller graph for this function:

interpreter_delete_barriers()

static void interpreter_delete_barriers ( struct GNUNET_TESTING_Interpreter *  is )

static

Deleting all barriers create in the context of this interpreter.

Parameters

is	The interpreter.

Definition at line 308 of file testing_api_loop.c.

{
  GNUNET_CONTAINER_multishortmap_iterate (is->barriers,
                                          free_barriers_cb,
                                          is);
  GNUNET_CONTAINER_multishortmap_destroy (is->barriers);
}

References GNUNET_TESTING_Interpreter::barriers, free_barriers_cb(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_iterate(), and is.

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

{
  struct GNUNET_TESTING_Interpreter *is = cls;
  struct GNUNET_TESTING_Command *cmd;
  const char *label;
 
  is->finishing = GNUNET_YES;
  is->final_task = NULL;
  label = is->commands[is->ip].label;
  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);
    cmd->cleanup (cmd->cls);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Cleaned up cmd %s\n",
                cmd->label);
  }
  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);
  is->rc (is->rc_cls,
          is->result);
  interpreter_delete_barriers (is);
  GNUNET_free (is->helper);
  GNUNET_free (is);
}

References GNUNET_TESTING_Command::cleanup, GNUNET_TESTING_Command::cls, GNUNET_TESTING_Interpreter::commands, GNUNET_TESTING_Interpreter::final_task, GNUNET_TESTING_Interpreter::finishing, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_TESTING_Interpreter::helper, interpreter_delete_barriers(), 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::task, and GNUNET_TESTING_Interpreter::timeout_task.

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 477 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);
  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 ();
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "start time of %p expected something is `%" PRIu64 "'\n",
              cmd,
              cmd->start_time.abs_value_us);
  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 = GNUNET_NO;
  }
  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_NO, 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, and GNUNET_TESTING_Interpreter::task.

Referenced by GNUNET_TESTING_cmd_end(), 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 382 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 412 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);
    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);
    }
  }
  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, and GNUNET_TESTING_Interpreter::result.

Referenced by GNUNET_TESTING_async_fail(), netjail_stop_run(), run_finish(), start_helper(), and start_peer_run().

Here is the call graph for this function:

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

GNUNET_TESTING_interpreter_get_current_label()

const char* GNUNET_TESTING_interpreter_get_current_label

(

struct GNUNET_TESTING_Interpreter *

is

)

Obtain label of the command being now run.

Parameters

is	interpreter state.

Returns

the label.

Definition at line 462 of file testing_api_loop.c.

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

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

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 534 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_cmd_end().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_running()

enum GNUNET_GenericReturnValue GNUNET_TESTING_running

(

const struct GNUNET_TESTING_Command *

command

)

Check if the command is running.

FIXME: Unused function.

Parameters

command

The command to check.

Returns

GNUNET_NO if the command is not running, GNUNET_YES if it is running.

Definition at line 534 of file testing_api_loop.c.

{
  return 0 != command->start_time.abs_value_us && 0 ==
         command->finish_time.abs_value_us;
}

GNUNET_TESTING_finished()

enum GNUNET_GenericReturnValue GNUNET_TESTING_finished

(

const struct GNUNET_TESTING_Command *

command

)

Check if a command is finished.

FIXME: Unused function

Parameters

command

The command to check.

Returns

GNUNET_NO if the command is not finished, GNUNET_YES if it is finished.

Definition at line 534 of file testing_api_loop.c.

{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  struct GNUNET_TIME_Relative diff = GNUNET_TIME_absolute_get_difference (
    command->finish_time,
    now);
  return 0 < diff.rel_value_us;
}

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 566 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;
}

Referenced by loop_run().

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 566 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_assert (strlen (label) <=
                   GNUNET_TESTING_CMD_MAX_LABEL_LENGTH);
    strncpy (cmd.label,
             label,
             GNUNET_TESTING_CMD_MAX_LABEL_LENGTH);
  }
  return cmd;
}

GNUNET_TESTING_cmd_end()

struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_end

(

void

)

Create command array terminator.

Returns

a end-command.

Definition at line 566 of file testing_api_loop.c.

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

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.

Here is the call graph for this function:

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 674 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 694 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:

clear_msg()

static void clear_msg ( void *  cls, int  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 714 of file testing_api_loop.c.

{
  GNUNET_assert (GNUNET_YES == result);
}

References GNUNET_assert, GNUNET_YES, and result.

Referenced by send_message_to_netjail().

Here is the caller 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 727 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:

send_message_to_netjail()

void send_message_to_netjail	(	struct GNUNET_TESTING_Interpreter *	is,
		unsigned int	global_node_number,
		struct GNUNET_MessageHeader *	header
	)

Send Message to netjail nodes.

Parameters

is	The interpreter.
global_node_number	The netjail node to inform.
header	The message to send.

Definition at line 742 of file testing_api_loop.c.

{
  const struct GNUNET_HELPER_Handle *helper;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "send message of type %u to locals\n",
              ntohs (header->type));
  helper = is->helper[global_node_number - 1];
  struct GNUNET_HELPER_SendHandle *sh = GNUNET_HELPER_send (
    (struct GNUNET_HELPER_Handle *) helper,
    header,
    GNUNET_NO,
    &clear_msg,
    NULL);
}

References clear_msg(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELPER_send(), GNUNET_log, GNUNET_NO, GNUNET_TESTING_Interpreter::helper, is, sh, and GNUNET_MessageHeader::type.

Referenced by TST_interpreter_send_barrier_crossable().

Here is the call graph for this function:

Here is the caller graph for this function:

TST_interpreter_send_barrier_crossable()

void TST_interpreter_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.

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.

Definition at line 762 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 name %s barrier_name\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);
  send_message_to_netjail (is,
                           global_node_number,
                           &adm->header);
  GNUNET_free (adm);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_CROSSABLE, CommandBarrierCrossable::header, is, send_message_to_netjail(), 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:

TST_interpreter_get_barrier()

struct GNUNET_TESTING_Barrier* TST_interpreter_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 794 of file testing_api_loop.c.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

TST_interpreter_finish_attached_cmds()

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

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

Parameters

barrier

The barrier in question.

Definition at line 816 of file testing_api_loop.c.

{
  struct CommandListEntry *pos;
  struct GNUNET_TESTING_Barrier *barrier = TST_interpreter_get_barrier (is,
                                                                        barrier_name);
 
  while (NULL != barrier && NULL != (pos = barrier->cmds_head))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "command label %s\n",
                pos->command->label);
    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);
      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);
    GNUNET_free (pos);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "command entry freed\n");
  }
  if (NULL != barrier->nodes)
  {
    struct FreeBarrierNodeCbCls free_barrier_node_cb_cls = {
      .barrier = barrier,
      .is = is
    };
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "freeing nodes\n");
    GNUNET_CONTAINER_multishortmap_iterate (barrier->nodes,
                                            &free_barrier_node_cb,
                                            &free_barrier_node_cb_cls);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "nodes freed\n");
    GNUNET_CONTAINER_multishortmap_destroy (barrier->nodes);
    barrier->nodes = NULL;
  }
}

References GNUNET_TESTING_Command::ac, GNUNET_TESTING_Command::asynchronous_finish, FreeBarrierNodeCbCls::barrier, GNUNET_TESTING_Barrier::cmds_head, GNUNET_TESTING_Barrier::cmds_tail, CommandListEntry::command, GNUNET_TESTING_AsyncContext::finished, free_barrier_node_cb(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_TESTING_async_finish(), GNUNET_YES, is, GNUNET_TESTING_Command::label, GNUNET_TESTING_Barrier::nodes, and TST_interpreter_get_barrier().

Referenced by barrier_reached(), and barrier_reached_run().

Here is the call graph for this function:

Here is the caller graph for this function:

TST_interpreter_add_barrier()

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

Add a barrier to the loop.

Parameters

is	The interpreter.
barrier	The barrier to add.

Definition at line 877 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));
  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(), 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_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 895 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_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 911 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 ac, GNUNET_assert, GNUNET_NO, GNUNET_SYSERR, and GNUNET_TESTING_interpreter_fail().

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 925 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 ac, GNUNET_assert, GNUNET_NO, and GNUNET_OK.

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

Here is the caller graph for this function: