/*
      This file is part of GNUnet
      Copyright (C) 2021, 2023, 2024 GNUnet e.V.

      GNUnet is free software: you can redistribute it and/or modify it
      under the terms of the GNU Affero General Public License as published
      by the Free Software Foundation, either version 3 of the License,
      or (at your option) any later version.

      GNUnet is distributed in the hope that it will be useful, but
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.

      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
 */

/**
 * @brief Central interpreter and command loop for writing an interpreter to test asynchronous systems
 * @author Christian Grothoff <christian@grothoff.org>
 * @author Marcello Stanisci
 * @author t3sserakt
 */
#ifndef GNUNET_TESTING_LIB_H
#define GNUNET_TESTING_LIB_H

#include "gnunet_util_lib.h"

/**
 * Maximum length of label in command
 */
#define GNUNET_TESTING_CMD_MAX_LABEL_LENGTH 127

/* ********************* Helper functions ********************* */

/**
 * Print failing line number and trigger shutdown.  Useful
 * quite any time after the command "run" method has been called.
 * Returns from the current function.
 */
#define GNUNET_TESTING_FAIL(is)                 \
        do {                                    \
          GNUNET_break (0);                     \
          GNUNET_TESTING_interpreter_fail (is); \
          return;                               \
        } while (0)


/**
 * Log an error message about a command not having run to completion.
 *
 * @param is interpreter
 * @param label command label of the incomplete command
 */
#define GNUNET_TESTING_command_incomplete(is,label)                       \
        do {                                                              \
          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,                            \
                      "Command %s (%s:%u) did not complete (at %s)\n",    \
                      label,                                              \
                      __FILE__,                                           \
                      __LINE__,                                           \
                      GNUNET_TESTING_interpreter_current_cmd_get_label (is)); \
        } while (0)


/* ******************* Generic interpreter logic ************ */

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

/**
 * State each asynchronous command must have in its closure.
 */
struct GNUNET_TESTING_AsyncContext
{

  /**
   * Interpreter we are part of.  Initialized when
   * the global interpreter starts.
   */
  struct GNUNET_TESTING_Interpreter *is;

  /**
   * Function to call when async operation is done.
   */
  GNUNET_SCHEDULER_TaskCallback notify_finished;

  /**
   * Closure for @e notify_finished.
   */
  void *notify_finished_cls;

  /**
   * Indication if the command finished (#GNUNET_OK).
   * #GNUNET_NO if it did not finish,
   * #GNUNET_SYSERR if it failed.
   */
  enum GNUNET_GenericReturnValue finished;

  /**
   * Set to true if interpreter_next() has already been
   * called for this command.
   */
  bool next_called;
};


/**
 * The asynchronous command of @a ac has failed.
 *
 * @param ac command-specific context
 */
void
GNUNET_TESTING_async_fail (
  struct GNUNET_TESTING_AsyncContext *ac);


/**
 * The asynchronous command of @a ac has finished.
 *
 * @param ac command-specific context
 */
void
GNUNET_TESTING_async_finish (
  struct GNUNET_TESTING_AsyncContext *ac);


/**
 * Signature of a function used to start executing a command of a test.  Runs
 * the command.  Note that upon return, the interpreter will not automatically
 * run the next command if this is an asynchronous command unless the command
 * was wrapped in #GNUNET_TESTING_cmd_make_unblocking(), as the command may
 * then continue asynchronously in other scheduler tasks.  In this case,
 * #GNUNET_TESTING_async_finish() must be called to run the next task.
 *
 * @param cls closure
 * @param is interpreter running the command
 */
typedef void
(*GNUNET_TESTING_CommandRunRoutine)(
  void *cls,
  struct GNUNET_TESTING_Interpreter *is);


/**
 * Signature of a function used to clean up resources allocated
 * by a command.
 *
 * @param cls closure
 */
typedef void
(*GNUNET_TESTING_CommandCleanupRoutine)(void *cls);


/**
 * Signature of a function used to extract traits exposed by a
 * command.
 *
 * @param cls closure
 * @param[out] ret where to return the trait data
 * @param trait name of the trait to return
 * @param index index of the trait (for traits that are indexed)
 * @return #GNUNET_OK on success
 */
typedef enum GNUNET_GenericReturnValue
(*GNUNET_TESTING_CommandGetTraits) (void *cls,
                                    const void **ret,
                                    const char *trait,
                                    unsigned int index);

/**
 * Create a new command that may be asynchronous.
 *
 * @param cls the closure
 * @param label the Label. Maximum length is #GNUNET_TESTING_CMD_MAX_LABEL_LENGTH
 * @param run the run routing
 * @param cleanup the cleanup function
 * @param traits the traits function (optional)
 * @param ac the async context, NULL if command is always
 *           synchronous
 * @return the command the function cannot fail
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_command_new_ac (
  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
 *
 * @param cls the closure
 * @param label the Label. Maximum length is #GNUNET_TESTING_CMD_MAX_LABEL_LENGTH
 * @param run the run routing
 * @param cleanup the cleanup function
 * @param traits the traits function (optional)
 * @return the command the function cannot fail
 */
#define GNUNET_TESTING_command_new(cls,label,run,cleanup,traits) \
        GNUNET_TESTING_command_new_ac (cls,label,run,cleanup,traits,NULL)


/**
 * Structure with storage space for a label.
 */
struct GNUNET_TESTING_CommandLabel
{
  char value[GNUNET_TESTING_CMD_MAX_LABEL_LENGTH + 1];
};


/**
 * Set @a label to @a value. Asserts that @a value is
 * not longer than #GNUNET_TESTING_CMD_MAX_LABEL_LENGTH.
 *
 * @param[out] label label to initialize
 * @param value value to store into @a label
 */
void
GNUNET_TESTING_set_label (
  struct GNUNET_TESTING_CommandLabel *label,
  const char *value);


/**
 * A command to be run by the interpreter.
 */
struct GNUNET_TESTING_Command
{

  /**
   * Label for the command.
   */
  struct GNUNET_TESTING_CommandLabel label;

  /**
   * Closure for all commands with command-specific context information.
   */
  void *cls;

  /**
   * Variable name for the command, NULL for none.
   */
  const char *name;

  /**
   * Runs the command.  Note that upon return, the interpreter
   * will not automatically run the next command, as the command
   * may continue asynchronously in other scheduler tasks.  Thus,
   * the command must ensure to eventually call
   * #GNUNET_TESTING_interpreter_next() or
   * #GNUNET_TESTING_interpreter_fail().
   *
   * If this function creates some asynchronous activity, it should
   * initialize @e finish to a function that can be used to wait for
   * the asynchronous activity to terminate.
   *
   * @param cls closure
   * @param is interpreter state
   */
  GNUNET_TESTING_CommandRunRoutine run;

  /**
   * Pointer to the asynchronous context in the command's
   * closure. Used by the
   * #GNUNET_TESTING_async_finish() and
   * #GNUNET_TESTING_async_fail() functions.
   *
   * Must be NULL if a command is synchronous.
   */
  struct GNUNET_TESTING_AsyncContext *ac;

  /**
   * Clean up after the command.  Run during forced termination
   * (CTRL-C) or test failure or test success.
   *
   * @param cls closure
   */
  GNUNET_TESTING_CommandCleanupRoutine cleanup;

  /**
   * Extract information from a command that is useful for other
   * commands. Can be NULL if a command has no traits.
   *
   * @param cls closure
   * @param[out] ret result (could be anything)
   * @param trait name of the trait
   * @param index index number of the object to extract.
   * @return #GNUNET_OK on success,
   *         #GNUNET_NO if no trait was found
   */
  GNUNET_TESTING_CommandGetTraits traits;

  /**
   * When did the execution of this command start?
   */
  struct GNUNET_TIME_Absolute start_time;

  /**
   * When did the execution of this command finish?
   */
  struct GNUNET_TIME_Absolute finish_time;

  /**
   * When did we start the last run of this command?  Delta to @e finish_time
   * gives the latency for the last successful run.  Useful in case @e
   * num_tries was positive and the command was run multiple times.  In that
   * case, the @e start_time gives the time when we first tried to run the
   * command, so the difference between @e start_time and @e finish_time would
   * be the time all of the @e num_tries took, while the delta to @e
   * last_req_time is the time the last (successful) execution took.
   */
  struct GNUNET_TIME_Absolute last_req_time;

  /**
   * How often did we try to execute this command? (In case it is a request
   * that is repated.)  Note that a command must have some built-in retry
   * mechanism for this value to be useful.
   */
  unsigned int num_tries;

  /**
   * If "true", the interpreter should not immediately run the next command,
   * even if this command did not complete via #GNUNET_TESTING_async_finish().
   * Otherwise, #GNUNET_TESTING_cmd_finish() must be used to ensure that a
   * command actually completed.
   */
  bool asynchronous_finish;

};


/**
 * Lookup command by label.
 *
 * @param is interpreter to lookup command in
 * @param label label of the command to lookup.
 * @return the command, if it is found, or NULL.
 */
const struct GNUNET_TESTING_Command *
GNUNET_TESTING_interpreter_lookup_command (
  struct GNUNET_TESTING_Interpreter *is,
  const char *label);


/**
 * Get command from hash map by variable name.
 *
 * @param is interpreter state.
 * @param name name of the variable to get command by
 * @return the command, if it is found, or NULL.
 */
const struct GNUNET_TESTING_Command *
GNUNET_TESTING_interpreter_get_command (
  struct GNUNET_TESTING_Interpreter *is,
  const char *name);


/**
 * Update the last request time of the current command
 * to the current time.
 *
 * @param[in,out] is interpreter state where to show
 *       that we are doing something
 */
void
GNUNET_TESTING_interpreter_current_cmd_touch (
  struct GNUNET_TESTING_Interpreter *is);


/**
 * Increment the 'num_tries' counter for the current command.
 *
 * @param[in,out] is interpreter state where to
 *   increment the counter
 */
void
GNUNET_TESTING_interpreter_current_cmd_inc_tries (
  struct GNUNET_TESTING_Interpreter *is);


/**
 * Obtain label of the command being now run.
 *
 * @param is interpreter state.
 * @return the label.
 */
const char *
GNUNET_TESTING_interpreter_current_cmd_get_label (
  struct GNUNET_TESTING_Interpreter *is);


/**
 * Current command failed, clean up and fail the test case.
 *
 * @param is interpreter state.
 */
void
GNUNET_TESTING_interpreter_fail (
  struct GNUNET_TESTING_Interpreter *is);


/**
 * Skips the current test, the environment is
 * not prepared correctly.
 *
 * @param is interpreter state.
 */
void
GNUNET_TESTING_interpreter_skip (
  struct GNUNET_TESTING_Interpreter *is);


/**
 * Callback over commands of an interpreter.
 *
 * @param cls closure
 * @param cmd a command to process
 */
typedef void
(*GNUNET_TESTING_CommandIterator)(
  void *cls,
  const struct GNUNET_TESTING_Command *cmd);


/**
 * Iterates over all of the top-level commands of an
 * interpreter.
 *
 * @param[in] is interpreter to iterate over
 * @param asc true in execution order, false for reverse execution order
 * @param cb function to call on each command
 * @param cb_cls closure for cb
 */
void
GNUNET_TESTING_interpreter_commands_iterate (
  struct GNUNET_TESTING_Interpreter *is,
  bool asc,
  GNUNET_TESTING_CommandIterator cb,
  void *cb_cls);


/* ************** Fundamental interpreter commands ************ */


/**
 * Create command array terminator.
 *
 * @return a end-command.
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_end (void);


/**
 * Create a "batch" command.  Such command takes a end_CMD-terminated array of
 * CMDs and executed them.  Once it hits the end CMD, it passes the control to
 * the next top-level CMD, regardless of it being another batch or ordinary
 * CMD.
 *
 * @param label the command label.
 * @param batch array of CMDs to execute.
 * @return the command.
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_batch (
  const char *label,
  struct GNUNET_TESTING_Command *batch);


/**
 * Performance counter.
 */
struct GNUNET_TESTING_Timer
{
  /**
   * For which type of commands.
   */
  const char *prefix;

  /**
   * Total time spend in all commands of this type.
   */
  struct GNUNET_TIME_Relative total_duration;

  /**
   * Total time spend waiting for the *successful* execution
   * in all commands of this type.
   */
  struct GNUNET_TIME_Relative success_latency;

  /**
   * Number of commands summed up.
   */
  unsigned int num_commands;

  /**
   * Number of retries summed up.
   */
  unsigned int num_retries;
};

/**
 * Obtain performance data from the interpreter.
 *
 * @param label command label.
 * @param[in,out] timers NULL-prefix terminated array that specifies what commands (by label) to obtain runtimes for
 * @return the command
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_stat (
  const char *label,
  struct GNUNET_TESTING_Timer *timers);


/**
 * Set variable to command as side-effect of
 * running a command.
 *
 * @param name name of the variable to set
 * @param cmd command to set to variable when run
 * @return modified command
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_set_var (
  const char *name,
  struct GNUNET_TESTING_Command cmd);


/**
 * Command to create a barrier.
 *
 * @param label The label of this command.
 * @param number_to_be_reached If this number of processes reached
 *                             this barrier, all processes waiting at
 *                             this barrier can pass it.
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_barrier_create (
  const char *label,
  unsigned int number_to_be_reached);


/**
 * If this command is executed the the process is signaling the master process
 * that it reached a barrier. If this command is synchronous it will block.
 *
 * @param label name for command.
 * @param barrier_label The name of the barrier we waited for and which was reached.
 * @return command.
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_barrier_reached (
  const char *label,
  const char *barrier_label);


#define GNUNET_TESTING_NETJAIL_START_SCRIPT "netjail_start_new.sh"

#define GNUNET_TESTING_NETJAIL_STOP_SCRIPT "netjail_stop.sh"

/**
 * Create command.
 *
 * @param label Name for the command.
 * @param topology_data topology data
 * @param timeout Before this timeout is reached this cmd MUST finish.
 * @return command.
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_netjail_start_helpers (
  const char *label,
  const char *topology_cmd_label,
  struct GNUNET_TIME_Relative timeout);


/**
 * This command executes a shell script to setup the netjail environment.
 *
 * @param label name for command.
 * @param script which script to run, e.g. #GNUNET_TESTING_NETJAIL_START_SCRIPT
 * @param topology_config Configuration file for the test topology.
 * @param read_file Flag indicating if the the name of the topology file is send to the helper, or a string with the topology data.
 * @return command.
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_netjail_setup (
  const char *label,
  const char *script,
  const char *topology_cmd_label);


struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_load_topology_from_file (
  const char *label,
  const char *filename);


struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_load_topology_from_string (
  const char *label,
  const char *topology_data);


/**
 * Turn asynchronous command into non-blocking command by setting
 * asynchronous_finish to true.  Modifies (and then returns) @a cmd simply
 * setting the bit. By default, most commands are blocking, and by wrapping
 * the command construction in this function a blocking command can be turned
 * into an asynchronous command where the interpreter continues after
 * initiating the asynchronous action. Does nothing if the command is
 * fundamentally synchronous.
 *
 * @param[in,out] cmd command to make non-blocking
 * @return a finish-command.
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_make_unblocking (
  struct GNUNET_TESTING_Command cmd);


/**
 * Create (synchronous) command that waits for another command to finish.
 * If @a cmd_ref did not finish after @a timeout, this command will fail
 * the test case.
 *
 * @param finish_label label for this command
 * @param cmd_ref reference to a previous command which we should
 *        wait for (call `finish()` on)
 * @param timeout how long to wait at most for @a cmd_ref to finish
 * @return a finish-command.
 */
const struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_finish (
  const char *finish_label,
  const char *cmd_ref,
  struct GNUNET_TIME_Relative timeout);


/**
 * Create a "signal" CMD.
 *
 * @param label command label.
 * @param process_label label of a command that has a process trait
 * @param signal signal to send to @a process.
 * @return the command.
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_signal (
  const char *label,
  const char *process_label,
  int signal);


/**
 * Sleep for @a duration.
 *
 * @param label command label.
 * @param duration time to sleep
 * @return the command.
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_sleep (
  const char *label,
  struct GNUNET_TIME_Relative duration);


/**
 * Command to execute a command.
 *
 * @param label Label of the command.
*/
const struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_exec (
  const char *label,
  enum GNUNET_OS_ProcessStatusType expected_type,
  unsigned long int expected_exit_code,
  char *const script_argv[]);


/**
 * Command to execute a command.
 *
 * @param label Label of the command.
*/
const struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_exec_va (
  const char *label,
  enum GNUNET_OS_ProcessStatusType expected_type,
  unsigned long int expected_exit_code,
  ...);


/**
 * Make the instruction pointer point to @a target_label
 * only if @a counter is greater than zero.  Note that
 * the command that will be executed next in this case
 * is the one AFTER @a target_label, as the command we
 * jump to is skipped by the advancing IP after the
 * rewind.
 *
 * @param label command label
 * @param target_label label of the new instruction pointer's destination after the jump;
 *                     must be before the current instruction (and the command at the @a target_label itself will not be run, but the one afterwards)
 * @param counter counts how many times the rewinding is to happen.
 */
struct GNUNET_TESTING_Command
GNUNET_TESTING_cmd_rewind_ip (
  const char *label,
  const char *target_label,
  unsigned int counter);


/* ***************** main loop logic ************* */

/**
 * Function called with the final result of the test.
 *
 * @param cls closure
 * @param rv #GNUNET_OK if the test passed
 */
typedef void
(*GNUNET_TESTING_ResultCallback)(
  void *cls,
  enum GNUNET_GenericReturnValue rv);


/**
 * 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.
 *
 * @param commands the array of command to execute
 * @param timeout how long to wait for each command to execute
 * @param rc function to call with the final result
 * @param rc_cls closure for @a rc
 * @return The interpreter.
 */
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);


/**
 * Start a GNUnet scheduler event loop and run the testsuite.  Return 0 upon
 * success.  Expected to be called directly from main().
 *
 * @param commands the list of command to execute
 * @param timeout how long to wait for each command to execute
 * @return EXIT_SUCCESS on success, EXIT_FAILURE on failure
 */
int
GNUNET_TESTING_main (
  const struct GNUNET_TESTING_Command *commands,
  struct GNUNET_TIME_Relative timeout);


/* ***************** plugin logic ************* */


/**
 * The plugin API every test case plugin has to implement.
 */
struct GNUNET_TESTING_PluginFunctions;


struct GNUNET_TESTING_PluginFunctions *
GNUNET_TESTING_make_plugin (
  const struct GNUNET_TESTING_Command *commands);

#define GNUNET_TESTING_MAKE_PLUGIN(prefix,name,...)            \
        void *                                                 \
          libgnunet_plugin_testing_ ## prefix ## _ ## name ## _init (void *cls) { \
          const char *my_node_id = cls; (void) my_node_id;     \
          struct GNUNET_TESTING_Command commands[] = {         \
            __VA_ARGS__,                                       \
            GNUNET_TESTING_cmd_end ()                          \
          };                                                   \
          return GNUNET_TESTING_make_plugin (commands);        \
        }                                                      \
        void *                                                 \
        libgnunet_plugin_testing_ ## prefix ## _ ## name ## _done (void *cls) { \
          struct GNUNET_TESTING_PluginFunctions *api = cls;    \
          GNUNET_free (api);                                   \
          return NULL;                                         \
        }


/* *** Generic trait logic for implementing traits ********* */

/**
 * A `struct GNUNET_TESTING_Trait` can be used to exchange data between cmds.
 *
 * Therefore the cmd which like to provide data to other cmds has to implement
 * the trait function, where an array of traits is defined with the help of
 * the #GNUNET_TESTING_make_trait_ macro. The data can be retrieved with the
 * help of the #GNUNET_TESTING_get_trait_ macro. Traits name and type must be
 * defined to make use of the macros.
 */
struct GNUNET_TESTING_Trait
{
  /**
   * Index number associated with the trait.  This gives the
   * possibility to have _multiple_ traits on offer under the
   * same name.
   */
  unsigned int index;

  /**
   * Trait type, for example "reserve-pub" or "coin-priv".
   */
  const char *trait_name;

  /**
   * Pointer to the piece of data to offer.
   */
  const void *ptr;
};


/**
 * "end" of traits array.  Because traits are offered into arrays, this type
 * of trait is used to mark the end of such arrays; useful when iterating over
 * those.
 */
struct GNUNET_TESTING_Trait
GNUNET_TESTING_trait_end (void);


/**
 * Obtain value of a trait from a command.
 *
 * @param traits the array of all the traits.
 * @param[out] ret where to store the result.
 * @param trait type of the trait to extract.
 * @param index index number of the trait to extract.
 * @return #GNUNET_OK when the trait is found.
 */
enum GNUNET_GenericReturnValue
GNUNET_TESTING_get_trait (
  const struct GNUNET_TESTING_Trait *traits,
  const void **ret,
  const char *trait,
  unsigned int index);


/**
 * Create headers for a trait with name @a name for
 * statically allocated data of type @a type.
 *
 * @param prefix symbol prefix to use
 * @param name name of the trait
 * @param type data type for the trait
 */
#define GNUNET_TESTING_MAKE_DECL_SIMPLE_TRAIT(prefix,name,type)  \
        enum GNUNET_GenericReturnValue                           \
        prefix ## _get_trait_ ## name (                          \
          const struct GNUNET_TESTING_Command *cmd,              \
          type * *ret);                                          \
        struct GNUNET_TESTING_Trait                              \
        prefix ## _make_trait_ ## name (                         \
          type * value);


/**
 * Create C implementation for a trait with name @a name for statically
 * allocated data of type @a type.
 *
 * @param prefix symbol prefix to use
 * @param name name of the trait
 * @param type data type for the trait
 */
#define GNUNET_TESTING_MAKE_IMPL_SIMPLE_TRAIT(prefix,name,type) \
        enum GNUNET_GenericReturnValue                          \
        prefix ## _get_trait_ ## name (                         \
          const struct GNUNET_TESTING_Command *cmd,             \
          type * *ret)                                          \
        {                                                       \
          if (NULL == cmd->traits) return GNUNET_SYSERR;        \
          return cmd->traits (cmd->cls,                         \
                              (const void **) ret,              \
                              GNUNET_S (name),                  \
                              0);                               \
        }                                                       \
        struct GNUNET_TESTING_Trait                             \
        prefix ## _make_trait_ ## name (                        \
          type * value)                                         \
        {                                                       \
          struct GNUNET_TESTING_Trait ret = {                   \
            .trait_name = GNUNET_S (name),                      \
            .ptr = (const void *) value                         \
          };                                                    \
          return ret;                                           \
        }


/**
 * Create headers for a trait with name @a name for
 * statically allocated data of type @a type.
 *
 * @param prefix symbol prefix to use
 * @param name name of the trait
 * @param type data type for the trait
 */
#define GNUNET_TESTING_MAKE_DECL_INDEXED_TRAIT(prefix,name,type) \
        enum GNUNET_GenericReturnValue                           \
        prefix ## _get_trait_ ## name (                          \
          const struct GNUNET_TESTING_Command *cmd,              \
          unsigned int index,                                    \
          type * *ret);                                          \
        struct GNUNET_TESTING_Trait                              \
        prefix ## _make_trait_ ## name (                         \
          unsigned int index,                                    \
          type * value);


/**
 * Create C implementation for a trait with name @a name for statically
 * allocated data of type @a type.
 */
#define GNUNET_TESTING_MAKE_IMPL_INDEXED_TRAIT(prefix,name,type)    \
        enum GNUNET_GenericReturnValue                          \
        prefix ## _get_trait_ ## name (                         \
          const struct GNUNET_TESTING_Command *cmd,             \
          unsigned int index,                                   \
          type * *ret)                                          \
        {                                                       \
          if (NULL == cmd->traits) return GNUNET_SYSERR;        \
          return cmd->traits (cmd->cls,                         \
                              (const void **) ret,              \
                              GNUNET_S (name),                  \
                              index);                           \
        }                                                       \
        struct GNUNET_TESTING_Trait                             \
        prefix ## _make_trait_ ## name (                        \
          unsigned int index,                                   \
          type * value)                                         \
        {                                                       \
          struct GNUNET_TESTING_Trait ret = {                   \
            .index = index,                                     \
            .trait_name = GNUNET_S (name),                      \
            .ptr = (const void *) value                         \
          };                                                    \
          return ret;                                           \
        }


/**
 * Call #op on all simple traits needed by testing core logic.
 *
 * @param op operation to perform
 * @param prefix prefix to pass to @e op
 */
#define GNUNET_TESTING_SIMPLE_TRAITS(op,prefix)                  \
        op (prefix, process, struct GNUNET_OS_Process *)         \
        op (prefix, cmd, const struct GNUNET_TESTING_Command)    \
        op (prefix, batch_cmds, struct GNUNET_TESTING_Command *)


GNUNET_TESTING_SIMPLE_TRAITS (GNUNET_TESTING_MAKE_DECL_SIMPLE_TRAIT,
                              GNUNET_TESTING)


#endif
