main interpreter loop for testcases More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testing_lib.h"
#include "testing_api_loop.h"
#include "testing_api_cmd_batch.h"

Include dependency graph for testing_api_loop.c:

Data Structures
struct	SendContext

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

struct	RewindIpState
	State for a "rewind" CMD. More...

Functions
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_get_command (struct GNUNET_TESTING_Interpreter is, const char name)
	Get command from hash map by variable name. More...

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

void	GNUNET_TESTING_loop_notify_children_ (struct GNUNET_TESTING_Interpreter is, const struct GNUNET_MessageHeader hdr)
	Send message to all netjail children (if there are any). More...

void	GNUNET_TESTING_loop_notify_parent_ (struct GNUNET_TESTING_Interpreter is, const struct GNUNET_MessageHeader hdr)
	Send message to our parent. 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...

void	GNUNET_TESTING_interpreter_next_ (void *cls)
	Current command is done, run the next one. More...

void	GNUNET_TESTING_interpreter_run_cmd_ (struct GNUNET_TESTING_Interpreter is, 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...

void	GNUNET_TESTING_interpreter_skip (struct GNUNET_TESTING_Interpreter *is)
	Skips the current test, the environment is not prepared correctly. 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...

static void	do_timeout (void *cls)
	Function run when the test terminates (good or bad) with timeout. More...

static void	setup_is (struct GNUNET_TESTING_Interpreter is, const struct GNUNET_TESTING_Command bcommand, const struct GNUNET_TESTING_Command *commands)

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

static struct GNUNET_TESTING_Interpreter *	start_testcase (void cls, const char topology_data, uint32_t inherited_barrier_count, const struct GNUNET_ShortHashCode inherited_barriers, GNUNET_TESTING_cmd_helper_write_cb parent_writer, GNUNET_TESTING_ResultCallback finish_cb, void finish_cb_cls)

struct GNUNET_TESTING_PluginFunctions *	GNUNET_TESTING_make_plugin (const struct GNUNET_TESTING_Command *commands)

void	GNUNET_TESTING_add_netjail_helper_ (struct GNUNET_TESTING_Interpreter is, struct GNUNET_HELPER_Handle helper)
	Adding a helper handle to the interpreter. More...

struct GNUNET_TESTING_Barrier *	GNUNET_TESTING_get_barrier2_ (struct GNUNET_TESTING_Interpreter is, const struct GNUNET_ShortHashCode create_key)

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

void	GNUNET_TESTING_add_barrier_ (struct GNUNET_TESTING_Interpreter is, struct GNUNET_TESTING_Barrier barrier)
	Add a barrier to the interpreter to share it with all children as an inherited barrier. More...

unsigned int	GNUNET_TESTING_barrier_count_ (struct GNUNET_TESTING_Interpreter *is)

void	GNUNET_TESTING_barrier_iterate_ (struct GNUNET_TESTING_Interpreter is, GNUNET_CONTAINER_ShortmapIterator cb, void cb_cls)

void	GNUNET_TESTING_interpreter_commands_iterate (struct GNUNET_TESTING_Interpreter is, bool asc, GNUNET_TESTING_CommandIterator cb, void cb_cls)
	Iterates over all of the top-level commands of an interpreter. More...

void	GNUNET_TESTING_interpreter_current_cmd_touch (struct GNUNET_TESTING_Interpreter *is)
	Update the last request time of the current command to the current time. More...

void	GNUNET_TESTING_interpreter_current_cmd_inc_tries (struct GNUNET_TESTING_Interpreter *is)
	Increment the 'num_tries' counter for the current command. More...

const char *	GNUNET_TESTING_interpreter_current_cmd_get_label (struct GNUNET_TESTING_Interpreter *is)
	Obtain label of the command being now run. More...

static enum GNUNET_GenericReturnValue	seek_batch (struct GNUNET_TESTING_Interpreter is, const struct GNUNET_TESTING_Command cmd, const struct GNUNET_TESTING_Command *target)
	Seek for the target command in batch (and rewind to it if successful). More...

static void	rewind_ip_run (void cls, struct GNUNET_TESTING_Interpreter is)
	Run the "rewind" CMD. More...

static void	rewind_ip_free (void *cls)

struct GNUNET_TESTING_Command	GNUNET_TESTING_cmd_rewind_ip (const char label, const char target_label, unsigned int counter)
	Make the instruction pointer point to target_label only if counter is greater than zero. 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

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

{
  if (NULL == label)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Attempt to lookup command for empty label\n");
    return NULL;
  }
  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->run) &&
         (0 == strcmp (cmd->label.value,
                       label)) )
      return cmd;
 
    if (GNUNET_TESTING_cmd_is_batch_ (cmd))
    {
      struct GNUNET_TESTING_Command **batch;
      const struct GNUNET_TESTING_Command *current;
      const struct GNUNET_TESTING_Command *icmd;
      const struct GNUNET_TESTING_Command *match;
 
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_TESTING_get_trait_cmd (cmd,
                                                   &current));
      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::commands, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OK, GNUNET_TESTING_cmd_is_batch_(), GNUNET_TESTING_get_trait_batch_cmds(), GNUNET_TESTING_get_trait_cmd(), GNUNET_TESTING_Interpreter::ip, is, GNUNET_TESTING_Command::label, run(), GNUNET_TESTING_Command::run, and GNUNET_TESTING_CommandLabel::value.

Referenced by backchannel_check_run(), connect_peers_run(), join_room_run(), netjail_exec_run(), netjail_start_run(), rewind_ip_run(), run_finish(), send_simple_run(), signal_run(), start_peer_run(), start_service_run(), stop_peer_run(), and stop_service_run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_interpreter_get_command()

const struct GNUNET_TESTING_Command * GNUNET_TESTING_interpreter_get_command	(	struct GNUNET_TESTING_Interpreter *	is,
		const char *	name
	)

Get command from hash map by variable name.

Parameters

is	interpreter state.
name	name of the variable to get command by

Returns: the command, if it is found, or NULL.

Definition at line 203 of file testing_api_loop.c.

{
  const struct GNUNET_TESTING_Command *cmd;
  struct GNUNET_HashCode h_name = {0};
 
  GNUNET_CRYPTO_hash (name,
                      strlen (name),
                      &h_name);
  cmd = GNUNET_CONTAINER_multihashmap_get (is->vars,
                                           &h_name);
  if (NULL == cmd)
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Command not found by variable name: %s\n",
                name);
  return cmd;
}

References GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, is, name, and GNUNET_TESTING_Interpreter::vars.

Here is the call graph for this function:

◆ send_finished()

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

static

Definition at line 224 of file testing_api_loop.c.

{
  struct SendContext *sctx = cls;
  struct GNUNET_TESTING_Interpreter *is = sctx->is;
 
  GNUNET_break (GNUNET_OK == result);
  GNUNET_CONTAINER_DLL_remove (is->sender_head,
                               is->sender_tail,
                               sctx);
  GNUNET_free (sctx);
}

References GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_OK, is, SendContext::is, result, GNUNET_TESTING_Interpreter::sender_head, and GNUNET_TESTING_Interpreter::sender_tail.

Referenced by GNUNET_TESTING_loop_notify_children_().

Here is the caller graph for this function:

◆ GNUNET_TESTING_loop_notify_children_()

void GNUNET_TESTING_loop_notify_children_	(	struct GNUNET_TESTING_Interpreter *	is,
		const struct GNUNET_MessageHeader *	hdr
	)

Send message to all netjail children (if there are any).

Parameters

is	The interpreter loop.

Definition at line 239 of file testing_api_loop.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Send notification to children of type %u\n",
              (unsigned int) ntohs (hdr->type));
  for (unsigned int i = 0; i<is->n_helpers; i++)
  {
    struct SendContext *sctx;
 
    sctx = GNUNET_new (struct SendContext);
    sctx->is = is;
    GNUNET_CONTAINER_DLL_insert (is->sender_head,
                                 is->sender_tail,
                                 sctx);
    sctx->send_handle
      = GNUNET_HELPER_send (is->helpers[i],
                            hdr,
                            false, /* never drop */
                            &send_finished,
                            sctx);
  }
}

References GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELPER_send(), GNUNET_log, GNUNET_new, GNUNET_TESTING_Interpreter::helpers, is, SendContext::is, GNUNET_TESTING_Interpreter::n_helpers, send_finished(), SendContext::send_handle, GNUNET_TESTING_Interpreter::sender_head, GNUNET_TESTING_Interpreter::sender_tail, and GNUNET_MessageHeader::type.

Referenced by barrier_reached_run(), handle_helper_barrier_crossable(), and handle_helper_barrier_reached().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_loop_notify_parent_()

void GNUNET_TESTING_loop_notify_parent_	(	struct GNUNET_TESTING_Interpreter *	is,
		const struct GNUNET_MessageHeader *	hdr
	)

Send message to our parent.

Fails very hard if we do not have one.

Parameters

is	The interpreter loop.

Definition at line 265 of file testing_api_loop.c.

{
  /* We must have a parent */
  if (NULL == is->parent_writer)
    GNUNET_TESTING_FAIL (is);
  is->parent_writer (hdr);
}

References GNUNET_TESTING_FAIL, is, and GNUNET_TESTING_Interpreter::parent_writer.

Referenced by barrier_reached_run(), and handle_helper_barrier_reached().

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 281 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++)
    if (NULL != cmd->cleanup)
      cmd->cleanup (cmd->cls);
  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;
  }
  {
    struct SendContext *sctx;
 
    while (NULL != (sctx = is->sender_head))
    {
      GNUNET_CONTAINER_DLL_remove (is->sender_head,
                                   is->sender_tail,
                                   sctx);
      GNUNET_HELPER_send_cancel (sctx->send_handle);
      GNUNET_free (sctx);
    }
  }
  GNUNET_free (is->commands);
  is->rc (is->rc_cls,
          is->skip ? GNUNET_NO : is->result);
  if (NULL != is->barriers)
  {
    GNUNET_CONTAINER_multishortmap_destroy (is->barriers);
    is->barriers = NULL;
  }
  if (NULL != is->vars)
  {
    GNUNET_CONTAINER_multihashmap_destroy (is->vars);
    is->vars = NULL;
  }
  GNUNET_free (is->helpers);
  GNUNET_free (is);
}

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 440 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_INFO,
                "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_TESTING_interpreter_run_cmd_ (is,
                                       cmd);
}

References GNUNET_TESTING_Interpreter::commands, finish_test(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_OK, GNUNET_TESTING_interpreter_run_cmd_(), GNUNET_TESTING_Interpreter::ip, is, GNUNET_TESTING_Command::label, GNUNET_TESTING_Interpreter::result, GNUNET_TESTING_Command::run, GNUNET_TESTING_Interpreter::task, and GNUNET_TESTING_CommandLabel::value.

Referenced by GNUNET_TESTING_interpreter_next_(), and setup_is().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_interpreter_next_()

void GNUNET_TESTING_interpreter_next_ ( void * cls )

Current command is done, run the next one.

Definition at line 351 of file testing_api_loop.c.

{
  static unsigned long long ipc;
  static struct GNUNET_TIME_Absolute last_report;
  struct GNUNET_TESTING_Interpreter *is = cls;
  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))
  {
    if (GNUNET_TESTING_cmd_batch_next_ (cmd->cls))
    {
      /* batch is done */
      cmd->finish_time = GNUNET_TIME_absolute_get ();
      is->ip++;
    }
  }
  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),
                    true));
    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(), interpreter_run(), GNUNET_TESTING_Interpreter::ip, is, GNUNET_TESTING_Interpreter::result, and GNUNET_TESTING_Interpreter::task.

Referenced by batch_run(), GNUNET_TESTING_async_finish(), and GNUNET_TESTING_interpreter_run_cmd_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_interpreter_run_cmd_()

void GNUNET_TESTING_interpreter_run_cmd_	(	struct GNUNET_TESTING_Interpreter *	is,
		struct GNUNET_TESTING_Command *	cmd
	)

Definition at line 393 of file testing_api_loop.c.

{
  cmd->last_req_time
    = GNUNET_TIME_absolute_get ();
  if (0 == cmd->num_tries)
    cmd->start_time = cmd->last_req_time;
  cmd->num_tries = 1;
  if (NULL != cmd->name)
  {
    struct GNUNET_HashCode h_name = {0};
 
    GNUNET_CRYPTO_hash (cmd->name,
                        strlen (cmd->name),
                        &h_name);
    (void) GNUNET_CONTAINER_multihashmap_put (
      is->vars,
      &h_name,
      cmd,
      GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
  }
  if (NULL != cmd->ac)
  {
    cmd->ac->is = is;
    cmd->ac->finished = GNUNET_NO;
    cmd->ac->next_called = false;
  }
  cmd->run (cmd->cls,
            is);
  if ( (! GNUNET_TESTING_cmd_is_batch_ (cmd)) &&
       ( (NULL == cmd->ac) ||
         (cmd->asynchronous_finish) ) )
  {
    if (NULL != cmd->ac)
      cmd->ac->next_called = true;
    GNUNET_TESTING_interpreter_next_ (is);
  }
}

Referenced by batch_run(), and 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 463 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 with CMD being NULL!\n");
  }
  else
  {
    const struct GNUNET_TESTING_Command *pos = cmd;
 
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed during command `%s'\n",
                cmd->label.value);
    while (GNUNET_TESTING_cmd_is_batch_ (pos))
    {
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_TESTING_get_trait_cmd (pos,
                                                   &pos));
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed in batch during command `%s'\n",
                  pos->label.value);
    }
  }
  if (NULL != is->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (is->timeout_task);
    is->timeout_task = NULL;
  }
  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_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_TESTING_cmd_is_batch_(), GNUNET_TESTING_get_trait_cmd(), GNUNET_TESTING_Interpreter::ip, is, GNUNET_TESTING_Command::label, GNUNET_TESTING_Interpreter::result, GNUNET_TESTING_Interpreter::timeout_task, and GNUNET_TESTING_CommandLabel::value.

Referenced by connect_peers_run(), do_shutdown(), GNUNET_TESTING_async_fail(), GNUNET_TESTING_interpreter_skip(), join_room_run(), on_message_cb(), rewind_ip_run(), seek_batch(), 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_interpreter_skip()

void GNUNET_TESTING_interpreter_skip ( struct GNUNET_TESTING_Interpreter * is )

Skips the current test, the environment is not prepared correctly.

Parameters

is	interpreter state.

Definition at line 508 of file testing_api_loop.c.

{
  is->skip = true;
  GNUNET_TESTING_interpreter_fail (is);
}

References GNUNET_TESTING_interpreter_fail(), is, and GNUNET_TESTING_Interpreter::skip.

Referenced by netjail_start_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 517 of file testing_api_loop.c.

{
  GNUNET_assert (GNUNET_NO == ac->finished);
  ac->finished = GNUNET_SYSERR;
  GNUNET_TESTING_interpreter_fail (ac->is);
}

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

Referenced by barrier_reached_run(), child_completed_callback(), conn_status(), exp_cb(), handle_helper_barrier_reached(), handle_helper_local_finished(), helper_mst(), stop_cb(), 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 526 of file testing_api_loop.c.

{
  GNUNET_assert (GNUNET_NO == ac->finished);
  ac->finished = GNUNET_OK;
  if (NULL != ac->notify_finished)
  {
    ac->notify_finished (ac->notify_finished_cls);
    ac->notify_finished = NULL;
  }
  if (! ac->next_called)
  {
    ac->next_called = true;
    GNUNET_TESTING_interpreter_next_ (ac->is);
  }
}

References GNUNET_TESTING_Command::ac, GNUNET_TESTING_AsyncContext::finished, GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_TESTING_interpreter_next_(), GNUNET_TESTING_AsyncContext::is, GNUNET_TESTING_AsyncContext::next_called, GNUNET_TESTING_AsyncContext::notify_finished, and GNUNET_TESTING_AsyncContext::notify_finished_cls.

Referenced by backchannel_check_run(), barrier_reached_run(), child_completed_callback(), conn_status(), do_timeout(), done_finish(), handle_helper_barrier_crossable(), handle_helper_barrier_reached(), handle_helper_local_finished(), hello_iter_cb(), notify_connect(), read_from_log(), run_finish(), send_run(), send_simple_single(), and stop_cb().

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

Definition at line 549 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:

◆ setup_is()

static void setup_is	(	struct GNUNET_TESTING_Interpreter *	is,
		const struct GNUNET_TESTING_Command *	bcommand,
		const struct GNUNET_TESTING_Command *	commands
	)

static

Definition at line 562 of file testing_api_loop.c.

{
  unsigned int i;
 
  is->vars = GNUNET_CONTAINER_multihashmap_create (1024,
                                                   false);
  /* get the number of commands */
  for (i = 0; NULL != commands[i].run; i++)
    ;
  if (NULL != bcommand)
    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);
  if (NULL == bcommand)
  {
    memcpy (is->commands,
            commands,
            sizeof (struct GNUNET_TESTING_Command) * i);
  }
  else
  {
    is->commands[0] = *bcommand;
    memcpy (&is->commands[1],
            commands,
            sizeof (struct GNUNET_TESTING_Command) * i);
  }
  is->task = GNUNET_SCHEDULER_add_now (&interpreter_run,
                                       is);
}

References GNUNET_TESTING_Interpreter::cmds_n, commands, GNUNET_TESTING_Interpreter::commands, GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc_large, GNUNET_SCHEDULER_add_now(), interpreter_run(), is, GNUNET_TESTING_Interpreter::task, and GNUNET_TESTING_Interpreter::vars.

Referenced by GNUNET_TESTING_run(), and start_testcase().

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

{
  struct GNUNET_TESTING_Interpreter *is;
 
  is = GNUNET_new (struct GNUNET_TESTING_Interpreter);
  is->timeout_task
    = GNUNET_SCHEDULER_add_delayed (timeout,
                                    &do_timeout,
                                    is);
  is->rc = rc;
  is->rc_cls = rc_cls;
  setup_is (is,
            NULL,
            commands);
  return is;
}

References commands, do_timeout(), GNUNET_new, GNUNET_SCHEDULER_add_delayed(), is, GNUNET_TESTING_Interpreter::rc, GNUNET_TESTING_Interpreter::rc_cls, setup_is(), 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:

◆ start_testcase()

static struct GNUNET_TESTING_Interpreter * start_testcase	(	void *	cls,
		const char *	topology_data,
		uint32_t	inherited_barrier_count,
		const struct GNUNET_ShortHashCode *	inherited_barriers,
		GNUNET_TESTING_cmd_helper_write_cb	parent_writer,
		GNUNET_TESTING_ResultCallback	finish_cb,
		void *	finish_cb_cls
	)

static

Definition at line 624 of file testing_api_loop.c.

{
  const struct GNUNET_TESTING_Command *commands = cls;
  struct GNUNET_TESTING_Interpreter *is;
 
  is = GNUNET_new (struct GNUNET_TESTING_Interpreter);
  if (0 != inherited_barrier_count)
  {
    is->barriers
      = GNUNET_CONTAINER_multishortmap_create (inherited_barrier_count * 4 / 3,
                                               true);
    for (unsigned int j = 0; j<inherited_barrier_count; j++)
    {
      struct GNUNET_TESTING_Barrier *barrier;
 
      barrier = GNUNET_new (struct GNUNET_TESTING_Barrier);
      barrier->barrier_id = inherited_barriers[j];
      barrier->inherited = true;
      (void) GNUNET_CONTAINER_multishortmap_put (
        is->barriers,
        &barrier->barrier_id,
        barrier,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
    }
  }
  is->parent_writer = parent_writer;
  is->rc = finish_cb;
  is->rc_cls = finish_cb_cls;
  {
    struct GNUNET_TESTING_Command bcmd;
 
    bcmd = GNUNET_TESTING_cmd_set_var (
      "topology",
      GNUNET_TESTING_cmd_load_topology_from_string (
        "_boot_",
        topology_data));
    setup_is (is,
              &bcmd,
              commands);
  }
  return is;
 
}

References GNUNET_TESTING_Barrier::barrier_id, GNUNET_TESTING_Interpreter::barriers, GNUNET_TESTING_Command::cls, commands, GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_new, GNUNET_TESTING_cmd_load_topology_from_string(), GNUNET_TESTING_cmd_set_var(), GNUNET_TESTING_Barrier::inherited, is, GNUNET_TESTING_Interpreter::parent_writer, GNUNET_TESTING_Interpreter::rc, GNUNET_TESTING_Interpreter::rc_cls, and setup_is().

Referenced by GNUNET_TESTING_make_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_make_plugin()

struct GNUNET_TESTING_PluginFunctions * GNUNET_TESTING_make_plugin ( const struct GNUNET_TESTING_Command * commands )

Definition at line 677 of file testing_api_loop.c.

{
  struct GNUNET_TESTING_PluginFunctions *api;
  struct GNUNET_TESTING_Command *commands_copy;
  unsigned int i;
 
  for (i = 0; NULL != commands[i].run; i++)
    ;
  commands_copy = GNUNET_malloc_large ( (i + 1)
                                       * sizeof (struct
                                                 GNUNET_TESTING_Command));
  memcpy (commands_copy,
          commands,
          sizeof (struct GNUNET_TESTING_Command) * i + 1);
 
  api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions);
  api->cls = (void *) commands_copy;
  api->start_testcase = &start_testcase;
  return api;
}

References GNUNET_TESTING_PluginFunctions::cls, commands, GNUNET_malloc_large, GNUNET_new, start_testcase(), and GNUNET_TESTING_PluginFunctions::start_testcase.

Here is the call graph for this function:

◆ GNUNET_TESTING_add_netjail_helper_()

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

Adding a helper handle to the interpreter.

Parameters

is	The interpreter.
helper	The helper handle.

Definition at line 701 of file testing_api_loop.c.

{
  GNUNET_array_append (is->helpers,
                       is->n_helpers,
                       helper);
}

References GNUNET_array_append, GNUNET_TESTING_Interpreter::helpers, is, and GNUNET_TESTING_Interpreter::n_helpers.

Referenced by start_helper().

Here is the caller graph for this function:

◆ GNUNET_TESTING_get_barrier2_()

struct GNUNET_TESTING_Barrier * GNUNET_TESTING_get_barrier2_	(	struct GNUNET_TESTING_Interpreter *	is,
		const struct GNUNET_ShortHashCode *	create_key
	)

Definition at line 711 of file testing_api_loop.c.

{
  return GNUNET_CONTAINER_multishortmap_get (is->barriers,
                                             create_key);
}

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

Referenced by GNUNET_TESTING_get_barrier_(), handle_helper_barrier_crossable(), and handle_helper_barrier_reached().

Here is the call graph for this function:

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
	)

Definition at line 720 of file testing_api_loop.c.

{
  struct GNUNET_ShortHashCode create_key;
 
  if (NULL == is->barriers)
    return NULL;
  GNUNET_TESTING_barrier_name_hash_ (barrier_name,
                                     &create_key);
  return GNUNET_TESTING_get_barrier2_ (is,
                                       &create_key);
}

References GNUNET_TESTING_Interpreter::barriers, GNUNET_TESTING_barrier_name_hash_(), GNUNET_TESTING_get_barrier2_(), and is.

Referenced by barrier_reached_run().

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 to share it with all children as an inherited barrier.

Parameters

is	The interpreter.
barrier	The barrier to add.

Definition at line 735 of file testing_api_loop.c.

{
  if (NULL == is->barriers)
    is->barriers
      = GNUNET_CONTAINER_multishortmap_create (1,
                                               true);
  /* We always use the barrier we encountered
     most recently under a given label, thus replace */
  (void) GNUNET_CONTAINER_multishortmap_put (
    is->barriers,
    &barrier->barrier_id,
    barrier,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
}

References GNUNET_TESTING_Barrier::barrier_id, GNUNET_TESTING_Interpreter::barriers, GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_put(), and is.

Referenced by barrier_run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_barrier_count_()

unsigned int GNUNET_TESTING_barrier_count_ ( struct GNUNET_TESTING_Interpreter * is )

Definition at line 753 of file testing_api_loop.c.

{
  return NULL != is->barriers ? GNUNET_CONTAINER_multishortmap_size (is->barriers) : 0;
}

References GNUNET_TESTING_Interpreter::barriers, GNUNET_CONTAINER_multishortmap_size(), and is.

Referenced by send_start_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_barrier_iterate_()

void GNUNET_TESTING_barrier_iterate_	(	struct GNUNET_TESTING_Interpreter *	is,
		GNUNET_CONTAINER_ShortmapIterator	cb,
		void *	cb_cls
	)

Definition at line 761 of file testing_api_loop.c.

{
  if (NULL != is->barriers)
    GNUNET_CONTAINER_multishortmap_iterate (is->barriers,
                                          cb,
                                          cb_cls);
}

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

Referenced by send_start_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_interpreter_commands_iterate()

void GNUNET_TESTING_interpreter_commands_iterate	(	struct GNUNET_TESTING_Interpreter *	is,
		bool	asc,
		GNUNET_TESTING_CommandIterator	cb,
		void *	cb_cls
	)

Iterates over all of the top-level commands of an interpreter.

Parameters

[in]	is	interpreter to iterate over
	asc	true in execution order, false for reverse execution order
	cb	function to call on each command
	cb_cls	closure for cb

Definition at line 774 of file testing_api_loop.c.

{
  unsigned int start;
  unsigned int end;
  int inc;
 
  if (asc)
  {
    inc = 1;
    start = 0;
    end = is->ip;
  }
  else
  {
    inc = -1;
    start = is->ip;
    end = 0;
  }
  for (unsigned int off = start; off != end + inc; off += inc)
  {
    const struct GNUNET_TESTING_Command *cmd
      = &is->commands[off];
 
    cb (cb_cls,
        cmd);
  }
}

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

Referenced by stat_run().

Here is the caller graph for this function:

◆ GNUNET_TESTING_interpreter_current_cmd_touch()

void GNUNET_TESTING_interpreter_current_cmd_touch ( struct GNUNET_TESTING_Interpreter * is )

Update the last request time of the current command to the current time.

Parameters

[in,out] is interpreter state where to show that we are doing something

Definition at line 808 of file testing_api_loop.c.

{
  is->commands[is->ip].last_req_time
    = GNUNET_TIME_absolute_get ();
}

References GNUNET_TESTING_Interpreter::commands, GNUNET_TIME_absolute_get(), GNUNET_TESTING_Interpreter::ip, is, and GNUNET_TESTING_Command::last_req_time.

Here is the call graph for this function:

◆ GNUNET_TESTING_interpreter_current_cmd_inc_tries()

void GNUNET_TESTING_interpreter_current_cmd_inc_tries ( struct GNUNET_TESTING_Interpreter * is )

Increment the 'num_tries' counter for the current command.

Parameters

[in,out] is interpreter state where to increment the counter

Definition at line 817 of file testing_api_loop.c.

{
  is->commands[is->ip].num_tries++;
}

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

◆ GNUNET_TESTING_interpreter_current_cmd_get_label()

const char * GNUNET_TESTING_interpreter_current_cmd_get_label ( struct GNUNET_TESTING_Interpreter * is )

Obtain label of the command being now run.

Parameters

is	interpreter state.

Returns: the label.

Definition at line 825 of file testing_api_loop.c.

{
  return is->commands[is->ip].label.value;
}

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

◆ seek_batch()

static enum GNUNET_GenericReturnValue seek_batch	(	struct GNUNET_TESTING_Interpreter *	is,
		const struct GNUNET_TESTING_Command *	cmd,
		const struct GNUNET_TESTING_Command *	target
	)

static

Seek for the target command in batch (and rewind to it if successful).

Parameters

is	the interpreter state (for failures)
cmd	batch to search for target
target	command to search for

Returns: GNUNET_OK on success, GNUNET_NO if target was not found, GNUNET_SYSERR if target is in the future and we failed

Definition at line 862 of file testing_api_loop.c.

{
  unsigned int new_ip;
  struct GNUNET_TESTING_Command **batch;
  const struct GNUNET_TESTING_Command *current;
  const struct GNUNET_TESTING_Command *icmd;
  bool found = false;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_TESTING_get_trait_cmd (cmd,
                                               &current));
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_TESTING_get_trait_batch_cmds (cmd,
                                                      &batch));
  for (new_ip = 0;
       NULL != (icmd = &((*batch)[new_ip]))->run;
       new_ip++)
  {
    if (current == target)
      current = NULL;
    if (icmd == target)
    {
      found = true;
      break;
    }
    if (GNUNET_TESTING_cmd_is_batch_ (icmd))
    {
      enum GNUNET_GenericReturnValue ret
        = seek_batch (is,
                      icmd,
                      target);
      if (GNUNET_SYSERR == ret)
        return GNUNET_SYSERR; /* failure! */
      if (GNUNET_OK == ret)
      {
        found = true;
        break;
      }
    }
  }
  if (! found)
    return GNUNET_NO; /* not found */
  if (NULL == current)
  {
    /* refuse to jump forward */
    GNUNET_break (0);
    GNUNET_TESTING_interpreter_fail (is);
    return GNUNET_SYSERR;
  }
  GNUNET_TESTING_cmd_batch_set_current_ (cmd,
                                         new_ip);
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTING_cmd_batch_set_current_(), GNUNET_TESTING_cmd_is_batch_(), GNUNET_TESTING_get_trait_batch_cmds(), GNUNET_TESTING_get_trait_cmd(), GNUNET_TESTING_interpreter_fail(), is, ret, and seek_batch().

Referenced by rewind_ip_run(), and seek_batch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rewind_ip_run()

static void rewind_ip_run	(	void *	cls,
		struct GNUNET_TESTING_Interpreter *	is
	)

static

Run the "rewind" CMD.

Parameters

cls	closure.
cmd	command being executed now.
is	the interpreter state.

Definition at line 927 of file testing_api_loop.c.

{
  struct RewindIpState *ris = cls;
  const struct GNUNET_TESTING_Command *target;
  const struct GNUNET_TESTING_Command *icmd;
  unsigned int new_ip;
  bool found = false;
 
  if (0 == ris->counter)
    return;
  target
    = GNUNET_TESTING_interpreter_lookup_command (is,
                                                 ris->target_label);
  if (NULL == target)
  {
    GNUNET_break (0);
    GNUNET_TESTING_interpreter_fail (is);
    return;
  }
  ris->counter--;
  for (new_ip = 0;
       NULL != (icmd = &is->commands[new_ip])->run;
       new_ip++)
  {
    if (icmd == target)
    {
      found = true;
      break;
    }
    if (GNUNET_TESTING_cmd_is_batch_ (icmd))
    {
      enum GNUNET_GenericReturnValue ret
        = seek_batch (is,
                      icmd,
                      target);
      if (GNUNET_SYSERR == ret)
      {
        /* failure! */
        GNUNET_break (0);
        GNUNET_TESTING_interpreter_fail (is);
        return;
      }
      if (GNUNET_OK == ret)
      {
        /* counter subtraction below for batch */
        found = true;
        break;
      }
    }
  }
  if (! found)
  {
    GNUNET_break (0);
    GNUNET_TESTING_interpreter_fail (is);
    return;
  }
  if (new_ip > (unsigned int) is->ip)
  {
    /* refuse to jump forward */
    GNUNET_break (0);
    GNUNET_TESTING_interpreter_fail (is);
    return;
  }
  is->ip = new_ip;
}

References GNUNET_TESTING_Interpreter::commands, RewindIpState::counter, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTING_cmd_is_batch_(), GNUNET_TESTING_interpreter_fail(), GNUNET_TESTING_interpreter_lookup_command(), GNUNET_TESTING_Interpreter::ip, is, ret, run(), seek_batch(), and RewindIpState::target_label.

Referenced by GNUNET_TESTING_cmd_rewind_ip().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rewind_ip_free()

static void rewind_ip_free ( void * cls )

static

Definition at line 996 of file testing_api_loop.c.

{
  struct RewindIpState *ris = cls;
 
  GNUNET_free (ris);
}

References GNUNET_free.

Referenced by GNUNET_TESTING_cmd_rewind_ip().

Here is the caller graph for this function:

◆ GNUNET_TESTING_cmd_rewind_ip()

struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_rewind_ip	(	const char *	label,
		const char *	target_label,
		unsigned int	counter
	)

Make the instruction pointer point to target_label only if counter is greater than zero.

Note that the command that will be executed next in this case is the one AFTER target_label, as the command we jump to is skipped by the advancing IP after the rewind.

Parameters

label	command label
target_label	label of the new instruction pointer's destination after the jump; must be before the current instruction (and the command at the target_label itself will not be run, but the one afterwards)
counter	counts how many times the rewinding is to happen.

Definition at line 1005 of file testing_api_loop.c.

{
  struct RewindIpState *ris;
 
  ris = GNUNET_new (struct RewindIpState);
  ris->target_label = target_label;
  ris->counter = counter;
  return GNUNET_TESTING_command_new (ris,
                                     label,
                                     &rewind_ip_run,
                                     &rewind_ip_free,
                                     NULL);
}

References RewindIpState::counter, GNUNET_new, GNUNET_TESTING_command_new, rewind_ip_free(), rewind_ip_run(), and RewindIpState::target_label.

Here is the call graph for this function:

Data Structures

Functions

Detailed Description

Function Documentation

◆ GNUNET_TESTING_interpreter_lookup_command()

◆ GNUNET_TESTING_interpreter_get_command()

◆ send_finished()

◆ GNUNET_TESTING_loop_notify_children_()

◆ GNUNET_TESTING_loop_notify_parent_()

◆ finish_test()

◆ interpreter_run()

◆ GNUNET_TESTING_interpreter_next_()

◆ GNUNET_TESTING_interpreter_run_cmd_()

◆ GNUNET_TESTING_interpreter_fail()

◆ GNUNET_TESTING_interpreter_skip()

◆ GNUNET_TESTING_async_fail()

◆ GNUNET_TESTING_async_finish()

◆ do_timeout()

◆ setup_is()

◆ GNUNET_TESTING_run()

◆ start_testcase()

◆ GNUNET_TESTING_make_plugin()

◆ GNUNET_TESTING_add_netjail_helper_()

◆ GNUNET_TESTING_get_barrier2_()

◆ GNUNET_TESTING_get_barrier_()

◆ GNUNET_TESTING_add_barrier_()

◆ GNUNET_TESTING_barrier_count_()

◆ GNUNET_TESTING_barrier_iterate_()

◆ GNUNET_TESTING_interpreter_commands_iterate()

◆ GNUNET_TESTING_interpreter_current_cmd_touch()

◆ GNUNET_TESTING_interpreter_current_cmd_inc_tries()

◆ GNUNET_TESTING_interpreter_current_cmd_get_label()

◆ seek_batch()

◆ rewind_ip_run()

◆ rewind_ip_free()

◆ GNUNET_TESTING_cmd_rewind_ip()