testing.h File Reference

#include "gnunet_util_lib.h"
#include "gnunet_testing_plugin.h"

Include dependency graph for testing.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	CommandBarrierCrossable
	Message send to a child loop to inform the child loop about a barrier being advanced. More...
struct	CommandBarrierAttached
	Message send by a child loop to inform the master loop how much GNUNET_CMDS_BARRIER_REACHED messages the child will send. More...
struct	GNUNET_TESTING_CommandBarrierReached
struct	TestcasePlugin
	Handle for a plugin. More...
struct	CommandListEntry
struct	GNUNET_TESTING_Barrier

Functions
bool	GNUNET_TESTING_cmd_batch_next_ (void *cls)
	Advance internal pointer to next command. More...
bool	GNUNET_TESTING_cmd_is_batch_ (const struct GNUNET_TESTING_Command *cmd)
	Test if this command is a batch command. More...
struct GNUNET_TESTING_Command *	GNUNET_TESTING_cmd_batch_get_current_ (const struct GNUNET_TESTING_Command *cmd)
	Obtain what command the batch is at. More...
void	GNUNET_TESTING_cmd_batch_set_current_ (const struct GNUNET_TESTING_Command *cmd, unsigned int new_ip)
	Set what command the batch should be at. More...
unsigned int	GNUNET_TESTING_barrier_crossable (struct GNUNET_TESTING_Barrier *barrier)
	This function checks, if a barrier can be crossed, which actually means that the cmd representing the barrier is finished. 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...
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	GNUNET_TESTING_send_barrier_attach (struct GNUNET_TESTING_Interpreter *is, char *barrier_name, unsigned int global_node_number, unsigned int expected_reaches, GNUNET_TESTING_cmd_helper_write_cb write_message)
	Send Message to master loop that cmds being attached to a barrier. More...
struct GNUNET_TESTING_NetjailNode *	GNUNET_TESTING_barrier_get_node (struct GNUNET_TESTING_Barrier *barrier, unsigned int node_number)
	Getting a node from a map by global node number. 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_add_barrier (struct GNUNET_TESTING_Interpreter *is, struct GNUNET_TESTING_Barrier *barrier)
	Add a barrier to the loop. More...

Function Documentation

GNUNET_TESTING_cmd_batch_next_()

bool GNUNET_TESTING_cmd_batch_next_

(

void *

cls

)

Advance internal pointer to next command.

Parameters

cls	batch internal state

Returns

true if we could advance, false if the batch has completed and cannot advance anymore

Definition at line 181 of file testing_api_cmd_batch.c.

{
  struct BatchState *bs = cls;
 
  if (NULL == bs->batch[bs->batch_ip].run)
    return false;
  bs->batch[bs->batch_ip].finish_time
    = GNUNET_TIME_absolute_get ();
  bs->batch_ip++;
  return true;
}

References BatchState::batch, BatchState::batch_ip, GNUNET_TESTING_Command::finish_time, GNUNET_TIME_absolute_get(), and GNUNET_TESTING_Command::run.

Referenced by interpreter_next().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_cmd_is_batch_()

bool GNUNET_TESTING_cmd_is_batch_

(

const struct GNUNET_TESTING_Command *

cmd

)

Test if this command is a batch command.

Returns

false if not, true if it is a batch command

Definition at line 195 of file testing_api_cmd_batch.c.

{
  return cmd->run == &batch_run;
}

References batch_run(), and GNUNET_TESTING_Command::run.

Referenced by get_command(), GNUNET_TESTING_cmd_batch_get_current_(), GNUNET_TESTING_cmd_batch_set_current_(), GNUNET_TESTING_interpreter_fail(), and interpreter_next().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_cmd_batch_get_current_()

struct GNUNET_TESTING_Command* GNUNET_TESTING_cmd_batch_get_current_

(

const struct GNUNET_TESTING_Command *

cmd

)

Obtain what command the batch is at.

Returns

cmd current batch command

Definition at line 202 of file testing_api_cmd_batch.c.

{
  struct BatchState *bs = cmd->cls;
 
  GNUNET_assert (GNUNET_TESTING_cmd_is_batch_ (cmd));
  return &bs->batch[bs->batch_ip];
}

References BatchState::batch, BatchState::batch_ip, GNUNET_TESTING_Command::cls, GNUNET_assert, and GNUNET_TESTING_cmd_is_batch_().

Referenced by get_command(), and GNUNET_TESTING_interpreter_fail().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_cmd_batch_set_current_()

void GNUNET_TESTING_cmd_batch_set_current_	(	const struct GNUNET_TESTING_Command *	cmd,
		unsigned int	new_ip
	)

Set what command the batch should be at.

Needed for loops. We may want to change this to take a label and/or expose it in the public API in the future. Not used for now.

Parameters

cmd	current batch command
new_ip	where to move the IP

Definition at line 212 of file testing_api_cmd_batch.c.

{
  struct BatchState *bs = cmd->cls;
 
  /* sanity checks */
  GNUNET_assert (GNUNET_TESTING_cmd_is_batch_ (cmd));
  for (unsigned int i = 0; i < new_ip; i++)
    GNUNET_assert (NULL != bs->batch[i].label);
  /* actual logic */
  bs->batch_ip = new_ip;
}

References BatchState::batch, BatchState::batch_ip, GNUNET_TESTING_Command::cls, GNUNET_assert, GNUNET_TESTING_cmd_is_batch_(), and GNUNET_TESTING_Command::label.

Here is the call graph for this function:

GNUNET_TESTING_barrier_crossable()

unsigned int GNUNET_TESTING_barrier_crossable

(

struct GNUNET_TESTING_Barrier *

barrier

)

This function checks, if a barrier can be crossed, which actually means that the cmd representing the barrier is finished.

Parameters

barrier

The barrier in question.

Returns

GNUNET_YES if we can cross the barrier, GNUNET_NO if not.

Definition at line 78 of file testing_api_cmd_barrier.c.

{
  unsigned int expected_reaches = barrier->expected_reaches;
  unsigned int reached = barrier->reached;
  double percentage_to_be_reached = barrier->percentage_to_be_reached;
  unsigned int number_to_be_reached = barrier->number_to_be_reached;
  double percentage_reached = (double) reached / expected_reaches * 100;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "%u %f %f %u %u\n",
       expected_reaches,
       percentage_to_be_reached,
       percentage_reached,
       number_to_be_reached,
       reached);
 
  if (((0 < percentage_to_be_reached) &&
       (percentage_reached >= percentage_to_be_reached)) ||
      ((0 < number_to_be_reached) && (reached >= number_to_be_reached)))
  {
    return GNUNET_YES;
  }
  else
  {
    return GNUNET_NO;
  }
}

Referenced by barrier_reached(), and barrier_reached_run().

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

GNUNET_TESTING_send_barrier_attach()

void GNUNET_TESTING_send_barrier_attach	(	struct GNUNET_TESTING_Interpreter *	is,
		char *	barrier_name,
		unsigned int	global_node_number,
		unsigned int	expected_reaches,
		GNUNET_TESTING_cmd_helper_write_cb	write_message
	)

Send Message to master loop that cmds being attached to a barrier.

FIXME: Unused function

Parameters

is	The interpreter loop.
barrier_name	The name of the barrier to attach to.
subnet_number	The number of the subnet.
node_number	The node to inform.
write_message	Callback to write messages to the master loop.

Definition at line 53 of file testing_api_cmd_barrier.c.

{
  struct CommandBarrierAttached *atm = GNUNET_new (struct
                                                   CommandBarrierAttached);
  size_t msg_length = sizeof(struct CommandBarrierAttached);
  size_t name_len;
 
  name_len = strlen (barrier_name) + 1;
  atm->header.type = htons (GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_ATTACHED);
  atm->header.size = htons ((uint16_t) msg_length);
  atm->expected_reaches = expected_reaches;
  atm->node_number = global_node_number;
  memcpy (&atm[1], barrier_name, name_len);
  write_message ((struct GNUNET_MessageHeader *) atm, msg_length);
 
  GNUNET_free (atm);
}

References CommandBarrierAttached::expected_reaches, GNUNET_free, GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_ATTACHED, GNUNET_new, CommandBarrierAttached::header, CommandBarrierAttached::node_number, GNUNET_MessageHeader::size, GNUNET_MessageHeader::type, and write_message().

Here is the call graph for this function:

GNUNET_TESTING_barrier_get_node()

struct GNUNET_TESTING_NetjailNode* GNUNET_TESTING_barrier_get_node	(	struct GNUNET_TESTING_Barrier *	barrier,
		unsigned int	node_number
	)

Getting a node from a map by global node number.

FIXME: This is a barrier helper function not related to a command but it is implemented in the *_cmd_barrier.c file. Maybe move into a separate file like testing_barrier.c; see also can barrier advance above

Parameters

nodes	The map.
node_number	The global node number.

Returns

The node.

Definition at line 166 of file testing_api_cmd_barrier.c.

{
  struct GNUNET_HashCode hc;
  struct GNUNET_ShortHashCode key;
 
  GNUNET_CRYPTO_hash (&(node_number), sizeof(node_number), &hc);
  memcpy (&key,
          &hc,
          sizeof (key));
  return GNUNET_CONTAINER_multishortmap_get (barrier->nodes, &key);
}

References GNUNET_CONTAINER_multishortmap_get(), GNUNET_CRYPTO_hash(), key, and GNUNET_TESTING_Barrier::nodes.

Referenced by barrier_attached().

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