From e5d31aa52e4983bffce3eca6ca601bbb8f4a302a Mon Sep 17 00:00:00 2001 From: t3sserakt Date: Thu, 4 Mar 2021 10:41:01 +0100 Subject: - first try to integrate GNU Taler command style testing --- src/include/Makefile.am | 1 + src/include/gnunet_testing_ng_lib.h | 1147 +++++++++++++++++++++++ src/testing/Makefile.am | 25 +- src/testing/test_testing_hello_world.c | 61 ++ src/testing/testing_api_cmd_batch.c | 257 +++++ src/testing/testing_api_cmd_hello_world.c | 113 +++ src/testing/testing_api_cmd_hello_world_birth.c | 160 ++++ src/testing/testing_api_loop.c | 652 +++++++++++++ src/testing/testing_api_trait_cmd.c | 79 ++ src/testing/testing_api_trait_process.c | 81 ++ src/testing/testing_api_traits.c | 81 ++ 11 files changed, 2656 insertions(+), 1 deletion(-) create mode 100644 src/include/gnunet_testing_ng_lib.h create mode 100644 src/testing/test_testing_hello_world.c create mode 100644 src/testing/testing_api_cmd_batch.c create mode 100644 src/testing/testing_api_cmd_hello_world.c create mode 100644 src/testing/testing_api_cmd_hello_world_birth.c create mode 100644 src/testing/testing_api_loop.c create mode 100644 src/testing/testing_api_trait_cmd.c create mode 100644 src/testing/testing_api_trait_process.c create mode 100644 src/testing/testing_api_traits.c diff --git a/src/include/Makefile.am b/src/include/Makefile.am index 5569c87ed..39a67acc4 100644 --- a/src/include/Makefile.am +++ b/src/include/Makefile.am @@ -113,6 +113,7 @@ gnunetinclude_HEADERS = \ gnunet_testbed_service.h \ gnunet_testbed_logger_service.h \ gnunet_testing_lib.h \ + gnunet_testing_ng_lib.h \ gnunet_time_lib.h \ gnunet_transport_service.h \ gnunet_transport_application_service.h \ diff --git a/src/include/gnunet_testing_ng_lib.h b/src/include/gnunet_testing_ng_lib.h new file mode 100644 index 000000000..aa997a77c --- /dev/null +++ b/src/include/gnunet_testing_ng_lib.h @@ -0,0 +1,1147 @@ +/* + This file is part of GNUnet + Copyright (C) 2008, 2009, 2012 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 . + + SPDX-License-Identifier: AGPL3.0-or-later + */ + +/** + * @brief API for writing an interpreter to test GNUnet components + * @author Christian Grothoff + * @author Marcello Stanisci + * @author t3sserakt + */ +#ifndef GNUNET_TESTING_NG_LIB_H +#define GNUNET_TESTING_NG_LIB_H + +#include +#include + + +/* ********************* Helper functions ********************* */ + +/** + * Print failing line number and trigger shutdown. Useful + * quite any time after the command "run" method has been called. + */ +#define GNUNET_TESTING_FAIL(is) \ + do \ + { \ + GNUNET_break (0); \ + GNUNET_TESTING_interpreter_fail (is); \ + return; \ + } while (0) + +/** + * Remove files from previous runs + * + * @param config_name configuration file to use+ + */ +void +GNUNET_TESTING_cleanup_files (const char *config_name); + + +/** + * Remove files from previous runs + * + * @param cls NULL + * @param cfg configuration + * @return #GNUNET_OK on success + */ +int +GNUNET_TESTING_cleanup_files_cfg (void *cls, + const struct + GNUNET_CONFIGURATION_Handle *cfg); + + +/* ******************* Generic interpreter logic ************ */ + +/** + * Global state of the interpreter, used by a command + * to access information about other commands. + */ +struct GNUNET_TESTING_Interpreter +{ + + /** + * Commands the interpreter will run. + */ + struct GNUNET_TESTING_Command *commands; + + /** + * Interpreter task (if one is scheduled). + */ + struct GNUNET_SCHEDULER_Task *task; + + /** + * ID of task called whenever we get a SIGCHILD. + * Used for #GNUNET_TESTING_wait_for_sigchld(). + */ + struct GNUNET_SCHEDULER_Task *child_death_task; + + /** + * Our configuration. + */ + const struct GNUNET_CONFIGURATION_Handle *cfg; + + /** + * Task run on timeout. + */ + struct GNUNET_SCHEDULER_Task *timeout_task; + + /** + * Function to call for cleanup at the end. Can be NULL. + */ + GNUNET_SCHEDULER_TaskCallback final_cleanup_cb; + + /** + * Closure for #final_cleanup_cb(). + */ + void *final_cleanup_cb_cls; + + /** + * Instruction pointer. Tells #interpreter_run() which instruction to run + * next. Need (signed) int because it gets -1 when rewinding the + * interpreter to the first CMD. + */ + int ip; + + /** + * Result of the testcases, #GNUNET_OK on success + */ + int result; + + /** + * Handle to the auditor. NULL unless specifically initialized + * as part of #GNUNET_TESTING_auditor_setup(). + */ + struct AUDITOR_Handle *auditor; + + /** + * Handle to exchange process; some commands need it + * to send signals. E.g. to trigger the key state reload. + */ + struct GNUNET_OS_Process *exchanged; + + /** + * URL of the auditor (as per configuration). + */ + char *auditor_url; + + /** + * URL of the exchange (as per configuration). + */ + char *exchange_url; + + /** + * Is the interpreter running (#GNUNET_YES) or waiting + * for /keys (#GNUNET_NO)? + */ + int working; + + /** + * Is the auditor running (#GNUNET_YES) or waiting + * for /version (#GNUNET_NO)? + */ + int auditor_working; + + /** + * How often have we gotten a /keys response so far? + */ + unsigned int key_generation; + + /** + * Exchange keys from last download. + */ + const struct EXCHANGE_Keys *keys; + +}; + + +/** + * A command to be run by the interpreter. + */ +struct GNUNET_TESTING_Command +{ + + /** + * Closure for all commands with command-specific context + * information. + */ + void *cls; + + /** + * Label for the command. + */ + const char *label; + + /** + * 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(). + * + * @param cls closure + * @param cmd command being run + * @param i interpreter state + */ + void + (*run)(void *cls, + const struct GNUNET_TESTING_Command *cmd, + struct GNUNET_TESTING_Interpreter *i); + + + /** + * Clean up after the command. Run during forced termination + * (CTRL-C) or test failure or test success. + * + * @param cls closure + * @param cmd command being cleaned up + */ + void + (*cleanup)(void *cls, + const struct GNUNET_TESTING_Command *cmd); + + /** + * Extract information from a command that is useful for other + * commands. + * + * @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 + */ + int + (*traits)(void *cls, + const void **ret, + const char *trait, + unsigned int index); + + /** + * 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 request of this command? + * Delta to @e finish_time gives the latency for the last + * successful request. + */ + 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.) + */ + unsigned int num_tries; + +}; + + +/** + * Lookup command by label. + * + * @param is interpreter state. + * @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); + + +/** + * Obtain label of the command being now run. + * + * @param is interpreter state. + * @return the label. + */ +const char * +GNUNET_TESTING_interpreter_get_current_label ( + struct GNUNET_TESTING_Interpreter *is); + +/** + * Current command is done, run the next one. + * + * @param is interpreter state. + */ +void +GNUNET_TESTING_interpreter_next (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); + +/** + * Create command array terminator. + * + * @return a end-command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_end (void); + + +/** + * Make the instruction pointer point to @a target_label + * only if @a counter is greater than zero. + * + * @param label command label + * @param target_label label of the new instruction pointer's destination after the jump; + * must be before the current instruction + * @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); + + +/** + * Wait until we receive SIGCHLD signal. + * Then obtain the process trait of the current + * command, wait on the the zombie and continue + * with the next command. + * + * @param is interpreter state. + */ +void +GNUNET_TESTING_wait_for_sigchld (struct GNUNET_TESTING_Interpreter *is); + + +/** + * Schedule the first CMD in the CMDs array. + * + * @param is interpreter state. + * @param commands array of all the commands to execute. + */ +void +GNUNET_TESTING_run (struct GNUNET_TESTING_Interpreter *is, + struct GNUNET_TESTING_Command *commands); + + +/** + * 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 is the interpreter state + * @param commands the list of command to execute + * @param timeout how long to wait + */ +void +GNUNET_TESTING_run2 (struct GNUNET_TESTING_Interpreter *is, + struct GNUNET_TESTING_Command *commands, + struct GNUNET_TIME_Relative timeout); + +/** + * The function that contains the array of all the CMDs to run, + * which is then on charge to call some fashion of + * GNUNET_TESTING_run*. In all the test cases, this function is + * always the GNUnet-ish "run" method. + * + * @param cls closure. + * @param is interpreter state. + */ +typedef void +(*GNUNET_TESTING_Main)(void *cls, + struct GNUNET_TESTING_Interpreter *is); + + +/** + * Install signal handlers plus schedules the main wrapper + * around the "run" method. + * + * @param main_cb the "run" method which coontains all the + * commands. + * @param main_cb_cls a closure for "run", typically NULL. + * @param cfg configuration to use + * @param exchanged exchange process handle: will be put in the + * state as some commands - e.g. revoke - need to send + * signal to it, for example to let it know to reload the + * key state.. if NULL, the interpreter will run without + * trying to connect to the exchange first. + * @param exchange_connect GNUNET_YES if the test should connect + * to the exchange, GNUNET_NO otherwise + * @return #GNUNET_OK if all is okay, != #GNUNET_OK otherwise. + * non-GNUNET_OK codes are #GNUNET_SYSERR most of the + * times. + */ +int +GNUNET_TESTING_setup (GNUNET_TESTING_Main main_cb, + void *main_cb_cls, + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct GNUNET_OS_Process *exchanged, + int exchange_connect); + + +/** + * Install signal handlers plus schedules the main wrapper + * around the "run" method. + * + * @param main_cb the "run" method which contains all the + * commands. + * @param main_cb_cls a closure for "run", typically NULL. + * @param config_filename configuration filename. + * @return #GNUNET_OK if all is okay, != #GNUNET_OK otherwise. + * non-GNUNET_OK codes are #GNUNET_SYSERR most of the + * times. + */ +int +GNUNET_TESTING_auditor_setup (GNUNET_TESTING_Main main_cb, + void *main_cb_cls, + const char *config_filename); + + +/** + * Closure for #GNUNET_TESTING_setup_with_exchange_cfg(). + */ +struct GNUNET_TESTING_SetupContext +{ + /** + * Main function of the test to run. + */ + GNUNET_TESTING_Main main_cb; + + /** + * Closure for @e main_cb. + */ + void *main_cb_cls; + + /** + * Name of the configuration file. + */ + const char *config_filename; +}; + + +/** + * Initialize scheduler loop and curl context for the test case + * including starting and stopping the exchange using the given + * configuration file. + * + * @param cls must be a `struct GNUNET_TESTING_SetupContext *` + * @param cfg configuration to use. + * @return #GNUNET_OK if no errors occurred. + */ +int +GNUNET_TESTING_setup_with_exchange_cfg ( + void *cls, + const struct GNUNET_CONFIGURATION_Handle *cfg); + + +/** + * Initialize scheduler loop and curl context for the test case + * including starting and stopping the exchange using the given + * configuration file. + * + * @param main_cb main method. + * @param main_cb_cls main method closure. + * @param config_file configuration file name. Is is used + * by both this function and the exchange itself. In the + * first case it gives out the exchange port number and + * the exchange base URL so as to check whether the port + * is available and the exchange responds when requested + * at its base URL. + * @return #GNUNET_OK if no errors occurred. + */ +int +GNUNET_TESTING_setup_with_exchange (GNUNET_TESTING_Main main_cb, + void *main_cb_cls, + const char *config_file); + + +/** + * Initialize scheduler loop and curl context for the test case + * including starting and stopping the auditor and exchange using + * the given configuration file. + * + * @param cls must be a `struct GNUNET_TESTING_SetupContext *` + * @param cfg configuration to use. + * @return #GNUNET_OK if no errors occurred. + */ +int +GNUNET_TESTING_setup_with_auditor_and_exchange_cfg ( + void *cls, + const struct GNUNET_CONFIGURATION_Handle *cfg); + + +/** + * Initialize scheduler loop and curl context for the test case + * including starting and stopping the auditor and exchange using + * the given configuration file. + * + * @param main_cb main method. + * @param main_cb_cls main method closure. + * @param config_file configuration file name. Is is used + * by both this function and the exchange itself. In the + * first case it gives out the exchange port number and + * the exchange base URL so as to check whether the port + * is available and the exchange responds when requested + * at its base URL. + * @return #GNUNET_OK if no errors occurred. + */ +int +GNUNET_TESTING_setup_with_auditor_and_exchange (GNUNET_TESTING_Main main_cb, + void *main_cb_cls, + const char *config_file); + +/** + * Look for substring in a programs' name. + * + * @param prog program's name to look into + * @param marker chunk to find in @a prog + */ +int +GNUNET_TESTING_has_in_name (const char *prog, + const char *marker); + + +/* ************** Specific interpreter commands ************ */ + +/** + * Make the "exec-auditor" CMD. + * + * @param label command label. + * @param config_filename configuration filename. + * @return the command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_exec_auditor (const char *label, + const char *config_filename); + + +/** + * Make a "wirewatch" CMD. + * + * @param label command label. + * @param config_filename configuration filename. + * + * @return the command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_exec_wirewatch (const char *label, + const char *config_filename); + +/** + * Make a "aggregator" CMD. + * + * @param label command label. + * @param config_filename configuration file for the + * aggregator to use. + * @return the command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_exec_aggregator (const char *label, + const char *config_filename); + + +/** + * Make a "closer" CMD. Note that it is right now not supported to run the + * closer to close multiple reserves in combination with a subsequent reserve + * status call, as we cannot generate the traits necessary for multiple closed + * reserves. You can work around this by using multiple closer commands, one + * per reserve that is being closed. + * + * @param label command label. + * @param config_filename configuration file for the + * closer to use. + * @param expected_amount amount we expect to see wired from a @a expected_reserve_ref + * @param expected_fee closing fee we expect to see + * @param expected_reserve_ref reference to a reserve we expect the closer to drain; + * NULL if we do not expect the closer to do anything + * @return the command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_exec_closer (const char *label, + const char *config_filename, + const char *expected_amount, + const char *expected_fee, + const char *expected_reserve_ref); + + +/** + * Make a "transfer" CMD. + * + * @param label command label. + * @param config_filename configuration file for the + * transfer to use. + * @return the command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_exec_transfer (const char *label, + const char *config_filename); + + +/** + * Create a withdraw command, letting the caller specify + * the desired amount as string. + * + * @param label command label. + * @param reserve_reference command providing us with a reserve to withdraw from + * @param amount how much we withdraw. + * @param expected_response_code which HTTP response code + * we expect from the exchange. + * @return the withdraw command to be executed by the interpreter. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_withdraw_amount (const char *label, + const char *reserve_reference, + const char *amount, + unsigned int expected_response_code); + +/** + * Create a "wire" command. + * + * @param label the command label. + * @param expected_method which wire-transfer method is expected + * to be offered by the exchange. + * @param expected_fee the fee the exchange should charge. + * @param expected_response_code the HTTP response the exchange + * should return. + * @return the command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_wire (const char *label, + const char *expected_method, + const char *expected_fee, + unsigned int expected_response_code); + + +/** + * Create a GET "reserves" command. + * + * @param label the command label. + * @param reserve_reference reference to the reserve to check. + * @param expected_balance expected balance for the reserve. + * @param expected_response_code expected HTTP response code. + * @return the command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_status (const char *label, + const char *reserve_reference, + const char *expected_balance, + unsigned int expected_response_code); + +/** + * Index of the deposit value trait of a deposit command. + */ +#define GNUNET_TESTING_CMD_DEPOSIT_TRAIT_IDX_DEPOSIT_VALUE 0 + +/** + * Index of the deposit fee trait of a deposit command. + */ +#define GNUNET_TESTING_CMD_DEPOSIT_TRAIT_IDX_DEPOSIT_FEE 1 + +/** + * Create a "signal" CMD. + * + * @param label command label. + * @param process handle to the process to signal. + * @param signal signal to send. + * + * @return the command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_signal (const char *label, + struct GNUNET_OS_Process *process, + int signal); + + +/** + * Sleep for @a duration_s seconds. + * + * @param label command label. + * @param duration_s number of seconds to sleep + * @return the command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_sleep (const char *label, + unsigned int duration_s); + +/** + * 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); + + +/** + * Test if this command is a batch command. + * + * @return false if not, true if it is a batch command + */ +int +GNUNET_TESTING_cmd_is_batch (const struct GNUNET_TESTING_Command *cmd); + +/** + * Advance internal pointer to next command. + * + * @param is interpreter state. + */ +void +GNUNET_TESTING_cmd_batch_next (struct GNUNET_TESTING_Interpreter *is); + +/** + * Obtain what command the batch is at. + * + * @return cmd current batch command + */ +struct GNUNET_TESTING_Command * +GNUNET_TESTING_cmd_batch_get_current (const struct GNUNET_TESTING_Command *cmd); + + +/** + * Set what command the batch should be at. + * + * @param cmd current batch command + * @param new_ip where to move the IP + */ +void +GNUNET_TESTING_cmd_batch_set_current (const struct GNUNET_TESTING_Command *cmd, + unsigned int new_ip); + + +/** + * 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* exeuction + * 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 timers what commands (by label) to obtain runtimes for + * @return the command + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_stat (struct GNUNET_TESTING_Timer *timers); + + +/* *** Generic trait logic for implementing traits ********* */ + +/** + * A trait. + */ +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" trait. 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); + + +/** + * Extract a trait. + * + * @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. + */ +int +GNUNET_TESTING_get_trait (const struct GNUNET_TESTING_Trait *traits, + const void **ret, + const char *trait, + unsigned int index); + + +/* ****** Specific traits supported by this component ******* */ + +/** + * Obtain location where a command stores a pointer to a process. + * + * @param cmd command to extract trait from. + * @param index which process to pick if @a cmd + * has multiple on offer. + * @param[out] processp set to the address of the pointer to the + * process. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_process (const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + struct GNUNET_OS_Process ***processp); + + +/** + * Offer location where a command stores a pointer to a process. + * + * @param index offered location index number, in case there are + * multiple on offer. + * @param processp process location to offer. + * @return the trait. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_process (unsigned int index, + struct GNUNET_OS_Process **processp); + +/** + * Offer number trait, 32-bit version. + * + * @param index the number's index number. + * @param n number to offer. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_uint32 (unsigned int index, + const uint32_t *n); + + +/** + * Obtain a "number" value from @a cmd, 32-bit version. + * + * @param cmd command to extract the number from. + * @param index the number's index number. + * @param[out] n set to the number coming from @a cmd. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_uint32 (const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + const uint32_t **n); + + +/** + * Offer number trait, 64-bit version. + * + * @param index the number's index number. + * @param n number to offer. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_uint64 (unsigned int index, + const uint64_t *n); + + +/** + * Obtain a "number" value from @a cmd, 64-bit version. + * + * @param cmd command to extract the number from. + * @param index the number's index number. + * @param[out] n set to the number coming from @a cmd. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_uint64 (const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + const uint64_t **n); + + +/** + * Offer number trait, 64-bit signed version. + * + * @param index the number's index number. + * @param n number to offer. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_int64 (unsigned int index, + const int64_t *n); + + +/** + * Obtain a "number" value from @a cmd, 64-bit signed version. + * + * @param cmd command to extract the number from. + * @param index the number's index number. + * @param[out] n set to the number coming from @a cmd. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_int64 (const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + const int64_t **n); + + +/** + * Offer a number. + * + * @param index the number's index number. + * @param n the number to offer. + * @return #GNUNET_OK on success. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_uint (unsigned int index, + const unsigned int *i); + + +/** + * Obtain a number from @a cmd. + * + * @param cmd command to extract the number from. + * @param index the number's index number. + * @param[out] n set to the number coming from @a cmd. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_uint (const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + const unsigned int **n); + +/** + * Obtain a string from @a cmd. + * + * @param cmd command to extract the subject from. + * @param index index number associated with the transfer + * subject to offer. + * @param[out] s where to write the offered + * string. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_string ( + const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + const char **s); + + +/** + * Offer string subject. + * + * @param index index number associated with the transfer + * subject being offered. + * @param s string to offer. + * @return the trait. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_string (unsigned int index, + const char *s); + +/** + * Offer a command in a trait. + * + * @param index always zero. Commands offering this + * kind of traits do not need this index. For + * example, a "meta" CMD returns always the + * CMD currently being executed. + * @param cmd wire details to offer. + * + * @return the trait. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_cmd (unsigned int index, + const struct GNUNET_TESTING_Command *cmd); + + +/** + * Obtain a command from @a cmd. + * + * @param cmd command to extract the command from. + * @param index always zero. Commands offering this + * kind of traits do not need this index. For + * example, a "meta" CMD returns always the + * CMD currently being executed. + * @param[out] _cmd where to write the wire details. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_cmd (const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + struct GNUNET_TESTING_Command **_cmd); + + +/** + * Obtain a uuid from @a cmd. + * + * @param cmd command to extract the uuid from. + * @param index which amount to pick if @a cmd has multiple + * on offer + * @param[out] uuid where to write the uuid. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_uuid (const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + struct GNUNET_Uuid **uuid); + + +/** + * Offer a uuid in a trait. + * + * @param index which uuid to offer, in case there are + * multiple available. + * @param uuid the uuid to offer. + * + * @return the trait. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_uuid (unsigned int index, + const struct GNUNET_Uuid *uuid); + +/** + * Obtain a absolute time from @a cmd. + * + * @param cmd command to extract trait from + * @param index which time stamp to pick if + * @a cmd has multiple on offer. + * @param[out] time set to the wanted WTID. + * @return #GNUNET_OK on success + */ +int +GNUNET_TESTING_get_trait_absolute_time ( + const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + const struct GNUNET_TIME_Absolute **time); + + +/** + * Offer a absolute time. + * + * @param index associate the object with this index + * @param time which object should be returned + * @return the trait. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_absolute_time ( + unsigned int index, + const struct GNUNET_TIME_Absolute *time); + + +/** + * Obtain a relative time from @a cmd. + * + * @param cmd command to extract trait from + * @param index which time to pick if + * @a cmd has multiple on offer. + * @param[out] time set to the wanted WTID. + * @return #GNUNET_OK on success + */ +int +GNUNET_TESTING_get_trait_relative_time ( + const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + const struct GNUNET_TIME_Relative **time); + + +/** + * Offer a relative time. + * + * @param index associate the object with this index + * @param time which object should be returned + * @return the trait. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_relative_time ( + unsigned int index, + const struct GNUNET_TIME_Relative *time); + +/** + * Offer data from trait + * + * @param cmd command to extract the url from. + * @param pt which url is to be picked, in case + * multiple are offered. + * @param[out] url where to write the url. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_what_am_i (const struct + GNUNET_TESTING_Command *cmd, + char *what_am_i); +/** + * Create command. + * + * @param label name for command. + * @param now when the command was started. + * @return command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_hello_world_birth (const char *label, + struct GNUNET_TIME_Absolute *now); + +/** + * Create command. + * + * @param label name for command. + * @param message initial message. + * @return command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_hello_world (const char *label, + char *message); + +#endif diff --git a/src/testing/Makefile.am b/src/testing/Makefile.am index 2b599f55b..f7aa1f896 100644 --- a/src/testing/Makefile.am +++ b/src/testing/Makefile.am @@ -15,7 +15,14 @@ lib_LTLIBRARIES = \ libgnunettesting.la libgnunettesting_la_SOURCES = \ - testing.c + testing.c \ + testing_api_cmd_batch.c \ + testing_api_cmd_hello_world.c \ + testing_api_cmd_hello_world_birth.c \ + testing_api_loop.c \ + testing_api_trait_cmd.c \ + testing_api_trait_process.c \ + testing_api_traits.c libgnunettesting_la_LIBADD = \ $(top_builddir)/src/arm/libgnunetarm.la \ $(top_builddir)/src/util/libgnunetutil.la \ @@ -48,8 +55,10 @@ list_keys_LDADD = \ check_PROGRAMS = \ + test_testing_hello_world \ test_testing_portreservation \ test_testing_servicestartup \ + test_testing_ng_peerstartup \ test_testing_peerstartup \ test_testing_peerstartup2 \ test_testing_sharedservices @@ -57,18 +66,32 @@ check_PROGRAMS = \ if ENABLE_TEST_RUN AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;unset XDG_DATA_HOME;unset XDG_CONFIG_HOME; TESTS = \ + test_testing_hello_world \ test_testing_portreservation \ + test_testing_ng_peerstartup \ test_testing_peerstartup \ test_testing_peerstartup2 \ test_testing_servicestartup endif +test_testing_helloworld_SOURCES = \ + test_testing_hello_world +test_testing_portreservation_LDADD = \ + libgnunettesting.la \ + $(top_builddir)/src/util/libgnunetutil.la + test_testing_portreservation_SOURCES = \ test_testing_portreservation.c test_testing_portreservation_LDADD = \ libgnunettesting.la \ $(top_builddir)/src/util/libgnunetutil.la +test_testing_ng_peerstartup_SOURCES = \ + test_testing_ng_peerstartup.c +test_testing_ng_peerstartup_LDADD = \ + libgnunettesting.la \ + $(top_builddir)/src/util/libgnunetutil.la + test_testing_peerstartup_SOURCES = \ test_testing_peerstartup.c test_testing_peerstartup_LDADD = \ diff --git a/src/testing/test_testing_hello_world.c b/src/testing/test_testing_hello_world.c new file mode 100644 index 000000000..689d04ed3 --- /dev/null +++ b/src/testing/test_testing_hello_world.c @@ -0,0 +1,61 @@ +/* + This file is part of GNUnet + Copyright (C) 2008, 2009, 2012 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 . + + SPDX-License-Identifier: AGPL3.0-or-later + */ + +/** + * @file testing/test_testing_hello_world.c + * @brief hello world test case + * @author t3sserakt + */ +#include "platform.h" +#include "gnunet_testing_ng_lib.h" + +/** + * Main function that will tell the interpreter what commands to + * run. + * + * @param cls closure + */ +static void +run (void *cls, + struct GNUNET_TESTING_Interpreter *is) +{ + struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get (); + + struct GNUNET_TESTING_Command commands[] = { + GNUNET_TESTING_cmd_hello_world_birth ("hello-world-birth-0", + &now), + GNUNET_TESTING_cmd_hello_world ("hello-world-0",""), + GNUNET_TESTING_cmd_end () + }; + + GNUNET_TESTING_run (is, + commands); +} + +int +main (int argc, + char *const *argv) +{ + return GNUNET_TESTING_setup (&run, + NULL, + NULL, + NULL, + GNUNET_NO); +} diff --git a/src/testing/testing_api_cmd_batch.c b/src/testing/testing_api_cmd_batch.c new file mode 100644 index 000000000..74a763718 --- /dev/null +++ b/src/testing/testing_api_cmd_batch.c @@ -0,0 +1,257 @@ +/* + This file is part of GNUnet + Copyright (C) 2008, 2009, 2012 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 . + + SPDX-License-Identifier: AGPL3.0-or-later + */ + +/** + * @file testing/testing_api_cmd_batch.c + * @brief Implement batch-execution of CMDs. + * @author Marcello Stanisci (GNU Taler testing) + * @author t3sserakt + */ +#include "platform.h" +#include "gnunet_testing_ng_lib.h" + + +/** + * State for a "batch" CMD. + */ +struct BatchState +{ + /** + * CMDs batch. + */ + struct GNUNET_TESTING_Command *batch; + + /** + * Internal command pointer. + */ + unsigned int batch_ip; +}; + + +/** + * Run the command. + * + * @param cls closure. + * @param cmd the command being executed. + * @param is the interpreter state. + */ +static void +batch_run (void *cls, + const struct GNUNET_TESTING_Command *cmd, + struct GNUNET_TESTING_Interpreter *is) +{ + struct BatchState *bs = cls; + + if (NULL != bs->batch[bs->batch_ip].label) + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Running batched command: %s\n", + bs->batch[bs->batch_ip].label); + + /* hit end command, leap to next top-level command. */ + if (NULL == bs->batch[bs->batch_ip].label) + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Exiting from batch: %s\n", + cmd->label); + GNUNET_TESTING_interpreter_next (is); + return; + } + bs->batch[bs->batch_ip].start_time + = bs->batch[bs->batch_ip].last_req_time + = GNUNET_TIME_absolute_get (); + bs->batch[bs->batch_ip].num_tries = 1; + bs->batch[bs->batch_ip].run (bs->batch[bs->batch_ip].cls, + &bs->batch[bs->batch_ip], + is); +} + + +/** + * Cleanup the state from a "reserve status" CMD, and possibly + * cancel a pending operation thereof. + * + * @param cls closure. + * @param cmd the command which is being cleaned up. + */ +static void +batch_cleanup (void *cls, + const struct GNUNET_TESTING_Command *cmd) +{ + struct BatchState *bs = cls; + + (void) cmd; + for (unsigned int i = 0; + NULL != bs->batch[i].label; + i++) + bs->batch[i].cleanup (bs->batch[i].cls, + &bs->batch[i]); + GNUNET_free (bs->batch); + GNUNET_free (bs); +} + + +/** + * Offer internal data from a "batch" CMD, to other commands. + * + * @param cls closure. + * @param[out] ret result. + * @param trait name of the trait. + * @param index index number of the object to offer. + * @return #GNUNET_OK on success. + */ +static int +batch_traits (void *cls, + const void **ret, + const char *trait, + unsigned int index) +{ +#define CURRENT_CMD_INDEX 0 +#define BATCH_INDEX 1 + + struct BatchState *bs = cls; + + struct GNUNET_TESTING_Trait traits[] = { + GNUNET_TESTING_make_trait_cmd + (CURRENT_CMD_INDEX, &bs->batch[bs->batch_ip]), + GNUNET_TESTING_make_trait_cmd + (BATCH_INDEX, bs->batch), + GNUNET_TESTING_trait_end () + }; + + /* Always return current command. */ + return GNUNET_TESTING_get_trait (traits, + ret, + trait, + index); +} + + +/** + * 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) +{ + struct BatchState *bs; + unsigned int i; + + bs = GNUNET_new (struct BatchState); + + /* Get number of commands. */ + for (i = 0; NULL != batch[i].label; i++) + /* noop */ + ; + + bs->batch = GNUNET_new_array (i + 1, + struct GNUNET_TESTING_Command); + memcpy (bs->batch, + batch, + sizeof (struct GNUNET_TESTING_Command) * i); + { + struct GNUNET_TESTING_Command cmd = { + .cls = bs, + .label = label, + .run = &batch_run, + .cleanup = &batch_cleanup, + .traits = &batch_traits + }; + + return cmd; + } +} + + +/** + * Advance internal pointer to next command. + * + * @param is interpreter state. + */ +void +GNUNET_TESTING_cmd_batch_next (struct GNUNET_TESTING_Interpreter *is) +{ + struct BatchState *bs = is->commands[is->ip].cls; + + if (NULL == bs->batch[bs->batch_ip].label) + { + is->commands[is->ip].finish_time = GNUNET_TIME_absolute_get (); + is->ip++; + return; + } + bs->batch[bs->batch_ip].finish_time = GNUNET_TIME_absolute_get (); + bs->batch_ip++; +} + + +/** + * Test if this command is a batch command. + * + * @return false if not, true if it is a batch command + */ +int +GNUNET_TESTING_cmd_is_batch (const struct GNUNET_TESTING_Command *cmd) +{ + return cmd->run == &batch_run; +} + + +/** + * Obtain what command the batch is at. + * + * @return cmd current batch command + */ +struct GNUNET_TESTING_Command * +GNUNET_TESTING_cmd_batch_get_current (const struct GNUNET_TESTING_Command *cmd) +{ + struct BatchState *bs = cmd->cls; + + GNUNET_assert (cmd->run == &batch_run); + return &bs->batch[bs->batch_ip]; +} + + +/** + * Set what command the batch should be at. + * + * @param cmd current batch command + * @param new_ip where to move the IP + */ +void +GNUNET_TESTING_cmd_batch_set_current (const struct GNUNET_TESTING_Command *cmd, + unsigned int new_ip) +{ + struct BatchState *bs = cmd->cls; + + /* sanity checks */ + GNUNET_assert (cmd->run == &batch_run); + for (unsigned int i = 0; i < new_ip; i++) + GNUNET_assert (NULL != bs->batch[i].label); + /* actual logic */ + bs->batch_ip = new_ip; +} diff --git a/src/testing/testing_api_cmd_hello_world.c b/src/testing/testing_api_cmd_hello_world.c new file mode 100644 index 000000000..1915f7da7 --- /dev/null +++ b/src/testing/testing_api_cmd_hello_world.c @@ -0,0 +1,113 @@ +/* + This file is part of GNUnet + Copyright (C) 2008, 2009, 2012 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 . + + SPDX-License-Identifier: AGPL3.0-or-later + */ + +/** + * @file testing/testing_api_cmd_hello_world.c + * @brief implementation of a hello world command. + * @author t3sserakt + */ +#include "platform.h" +#include "gnunet_testing_ng_lib.h" + +struct HelloWorldState +{ + char *message; +}; + +/** +* +* +* @param cls closure +* @param cmd current CMD being cleaned up. +*/ +static void +hello_world_cleanup (void *cls, + const struct GNUNET_TESTING_Command *cmd) +{ + struct HelloWorldState *hs = cls; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Cleaning up message %s", + hs->message); +} + +/** +* +* +* @param cls closure. +* @param[out] ret result +* @param trait name of the trait. +* @param index index number of the object to offer. +* @return #GNUNET_OK on success. +*/ +static int +hello_world_traits (void *cls, + const void **ret, + const char *trait, + unsigned int index) +{ + return GNUNET_OK; +} + +/** +* Run the "hello world" CMD. +* +* @param cls closure. +* @param cmd CMD being run. +* @param is interpreter state. +*/ +static void +hello_world_run (void *cls, + const struct GNUNET_TESTING_Command *cmd, + struct GNUNET_TESTING_Interpreter *is) +{ + struct HelloWorldState *hs = cls; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "%s", + hs->message); + GNUNET_TESTING_get_trait_what_am_i (cmd, + hs->message); +} + +/** + * Create command. + * + * @param label name for command. + * @param message initial message. + * @return command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_hello_world (const char *label, + char *message) +{ + struct HelloWorldState *hs; + + hs = GNUNET_new (struct HelloWorldState); + hs->message = "Hello World, I am nobody!"; + + struct GNUNET_TESTING_Command cmd = { + .cls = hs, + .label = label, + .run = &hello_world_run, + .cleanup = &hello_world_cleanup, + .traits = &hello_world_traits + }; + + return cmd; +} diff --git a/src/testing/testing_api_cmd_hello_world_birth.c b/src/testing/testing_api_cmd_hello_world_birth.c new file mode 100644 index 000000000..a3157b6de --- /dev/null +++ b/src/testing/testing_api_cmd_hello_world_birth.c @@ -0,0 +1,160 @@ +/* + This file is part of GNUnet + Copyright (C) 2008, 2009, 2012 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 . + + SPDX-License-Identifier: AGPL3.0-or-later + */ + +/** + * @file testing/testing_api_cmd_hello_world.c + * @brief implementation of a hello world command. + * @author t3sserakt + */ +#include "platform.h" +#include "gnunet_util_lib.h" +#include "gnunet_testing_ng_lib.h" + +struct HelloWorldBirthState +{ + struct GNUNET_TIME_Absolute *date; + char *what_am_i; +}; + +/** +* +* +* @param cls closure +* @param cmd current CMD being cleaned up. +*/ +static void +hello_world_birth_cleanup (void *cls, + const struct GNUNET_TESTING_Command *cmd) +{ + struct HelloWorldBirthState *hbs = cls; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Finished birth of %s", + hbs->what_am_i); +} + +/** +* +* +* @param cls closure. +* @param[out] ret result +* @param trait name of the trait. +* @param index index number of the object to offer. +* @return #GNUNET_OK on success. +*/ +static int +hello_world_birth_traits (void *cls, + const void **ret, + const char *trait, + unsigned int index) +{ + struct HelloWorldBirthState *hbs = cls; + struct GNUNET_TESTING_Trait traits[] = { + { + .index = 0, + .trait_name = "what_am_i", + .ptr = (const void *) hbs->what_am_i, + }, + GNUNET_TESTING_trait_end () + }; + + return GNUNET_TESTING_get_trait (traits, + ret, + trait, + index); +} + +/** +* Run the "hello world" CMD. +* +* @param cls closure. +* @param cmd CMD being run. +* @param is interpreter state. +*/ +static void +hello_world_birth_run (void *cls, + const struct GNUNET_TESTING_Command *cmd, + struct GNUNET_TESTING_Interpreter *is) +{ + struct HelloWorldBirthState *hbs = cls; + struct GNUNET_TIME_Relative relativ; + + relativ = GNUNET_TIME_absolute_get_difference (*hbs->date, + GNUNET_TIME_absolute_get ()); + + if (0 == relativ.rel_value_us % 10) + { + hbs->what_am_i = "Hello World, I am a creature!"; + } + else if (0 == relativ.rel_value_us % 2) + { + hbs->what_am_i = "Hello World, I am a girl!"; + } + else + { + hbs->what_am_i = "Hello World, I am a boy!"; + } +} + +/** + * Offer data from trait + * + * @param cmd command to extract the url from. + * @param pt which url is to be picked, in case + * multiple are offered. + * @param[out] url where to write the url. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_what_am_i (const struct + GNUNET_TESTING_Command *cmd, + char *what_am_i) +{ + return cmd->traits (cmd->cls, + (const void **) what_am_i, + "what_am_i", + (unsigned int) 0); +} + +/** + * Create command. + * + * @param label name for command. + * @param now when the command was started. + * @return command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_hello_world_birth (const char *label, + struct GNUNET_TIME_Absolute *now) +{ + struct HelloWorldBirthState *hbs; + + hbs = GNUNET_new (struct HelloWorldBirthState); + hbs->date = now; + + struct GNUNET_TESTING_Command cmd = { + .cls = hbs, + .label = label, + .run = &hello_world_birth_run, + .cleanup = &hello_world_birth_cleanup, + .traits = &hello_world_birth_traits + }; + + return cmd; +} diff --git a/src/testing/testing_api_loop.c b/src/testing/testing_api_loop.c new file mode 100644 index 000000000..f32f4061e --- /dev/null +++ b/src/testing/testing_api_loop.c @@ -0,0 +1,652 @@ +/* + This file is part of GNUnet + Copyright (C) 2008, 2009, 2012 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 . + + SPDX-License-Identifier: AGPL3.0-or-later + */ + +/** + * @file testing/testing_api_loop.c + * @brief main interpreter loop for testcases + * @author Christian Grothoff (GNU Taler testing) + * @author Marcello Stanisci (GNU Taler testing) + * @author t3sserakt +*/ +#include "platform.h" +#include "gnunet_testing_ng_lib.h" + +/** + * Pipe used to communicate child death via signal. + * Must be global, as used in signal handler! + */ +static struct GNUNET_DISK_PipeHandle *sigpipe; + +/** + * Lookup command by label. + * + * @param is interpreter state to search + * @param label label to look for + * @return NULL if command was not found + */ +const struct GNUNET_TESTING_Command * +GNUNET_TESTING_interpreter_lookup_command (struct + GNUNET_TESTING_Interpreter *is, + const char *label) +{ + if (NULL == label) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Attempt to lookup command for empty label\n"); + return NULL; + } + /* Search backwards as we most likely reference recent commands */ + 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->label) && + (0 == strcmp (cmd->label, + label)) ) + return cmd; + + if (GNUNET_TESTING_cmd_is_batch (cmd)) + { +#define BATCH_INDEX 1 + struct GNUNET_TESTING_Command *batch; + struct GNUNET_TESTING_Command *current; + 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_cmd (cmd, + BATCH_INDEX, + &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])->label; + j++) + { + if (current == icmd) + break; /* do not go past current command */ + if ( (NULL != icmd->label) && + (0 == strcmp (icmd->label, + label)) ) + match = icmd; + } + if (NULL != match) + return match; + } + } + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Command not found: %s\n", + label); + return NULL; + +} + + +/** + * Run the main interpreter loop that performs exchange operations. + * + * @param cls contains the `struct InterpreterState` + */ +static void +interpreter_run (void *cls); + + +/** + * Current command is done, run the next one. + */ +void +GNUNET_TESTING_interpreter_next (struct GNUNET_TESTING_Interpreter *is) +{ + 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! */ + if (GNUNET_TESTING_cmd_is_batch (cmd)) + { + GNUNET_TESTING_cmd_batch_next (is); + } + 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), + GNUNET_YES)); + last_report = GNUNET_TIME_absolute_get (); + } + ipc++; + is->task = GNUNET_SCHEDULER_add_now (&interpreter_run, + is); +} + + +/** + * Current command failed, clean up and fail the test case. + * + * @param is interpreter of the test + */ +void +GNUNET_TESTING_interpreter_fail (struct GNUNET_TESTING_Interpreter *is) +{ + struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip]; + + 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, + "Batch is at command `%s'\n", + cmd->label); + } + is->result = GNUNET_SYSERR; + GNUNET_SCHEDULER_shutdown (); +} + + +/** + * Create command array terminator. + * + * @return a end-command. + */ +struct GNUNET_TESTING_Command +GNUNET_TESTING_cmd_end (void) +{ + static struct GNUNET_TESTING_Command cmd; + cmd.label = NULL; + + return cmd; +} + + +/** + * Obtain current label. + */ +const char * +GNUNET_TESTING_interpreter_get_current_label (struct + GNUNET_TESTING_Interpreter *is) +{ + struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip]; + + return cmd->label; +} + + +/** + * Run the main interpreter loop that performs exchange operations. + * + * @param cls contains the `struct GNUNET_TESTING_Interpreter` + */ +static void +interpreter_run (void *cls) +{ + struct GNUNET_TESTING_Interpreter *is = cls; + struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip]; + + is->task = NULL; + + if (NULL == cmd->label) + { + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Running command END\n"); + is->result = GNUNET_OK; + GNUNET_SCHEDULER_shutdown (); + return; + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Running command `%s'\n", + cmd->label); + cmd->start_time + = cmd->last_req_time + = GNUNET_TIME_absolute_get (); + cmd->num_tries = 1; + cmd->run (cmd->cls, + cmd, + is); +} + + +/** + * Function run when the test terminates (good or bad). + * Cleans up our state. + * + * @param cls the interpreter state. + */ +static void +do_shutdown (void *cls) +{ + struct GNUNET_TESTING_Interpreter *is = cls; + struct GNUNET_TESTING_Command *cmd; + const char *label; + + label = is->commands[is->ip].label; + if (NULL == label) + label = "END"; + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Executing shutdown at `%s'\n", + label); + + for (unsigned int j = 0; + NULL != (cmd = &is->commands[j])->label; + j++) + cmd->cleanup (cmd->cls, + cmd); + + if (NULL != is->task) + { + GNUNET_SCHEDULER_cancel (is->task); + is->task = NULL; + } + if (NULL != is->timeout_task) + { + GNUNET_SCHEDULER_cancel (is->timeout_task); + is->timeout_task = NULL; + } + if (NULL != is->child_death_task) + { + GNUNET_SCHEDULER_cancel (is->child_death_task); + is->child_death_task = NULL; + } + GNUNET_free (is->commands); +} + + +/** + * Function run when the test terminates (good or bad) with timeout. + * + * @param cls NULL + */ +static void +do_timeout (void *cls) +{ + struct GNUNET_TESTING_Interpreter *is = cls; + + is->timeout_task = NULL; + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Terminating test due to timeout\n"); + GNUNET_SCHEDULER_shutdown (); +} + + +/** + * Task triggered whenever we receive a SIGCHLD (child + * process died). + * + * @param cls closure + */ +static void +maint_child_death (void *cls) +{ + struct GNUNET_TESTING_Interpreter *is = cls; + struct GNUNET_TESTING_Command *cmd = &is->commands[is->ip]; + const struct GNUNET_DISK_FileHandle *pr; + struct GNUNET_OS_Process **processp; + char c[16]; + enum GNUNET_OS_ProcessStatusType type; + unsigned long code; + + if (GNUNET_TESTING_cmd_is_batch (cmd)) + { + struct GNUNET_TESTING_Command *batch_cmd; + + GNUNET_assert (GNUNET_OK == + GNUNET_TESTING_get_trait_cmd (cmd, + 0, + &batch_cmd)); + cmd = batch_cmd; + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Got SIGCHLD for `%s'.\n", + cmd->label); + is->child_death_task = NULL; + pr = GNUNET_DISK_pipe_handle (sigpipe, + GNUNET_DISK_PIPE_END_READ); + GNUNET_break (0 < + GNUNET_DISK_file_read (pr, + &c, + sizeof (c))); + if (GNUNET_OK != + GNUNET_TESTING_get_trait_process (cmd, + 0, + &processp)) + { + GNUNET_break (0); + GNUNET_TESTING_interpreter_fail (is); + return; + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Got the dead child process handle, waiting for termination ...\n"); + GNUNET_OS_process_wait_status (*processp, + &type, + &code); + GNUNET_OS_process_destroy (*processp); + *processp = NULL; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "... definitively terminated\n"); + switch (type) + { + case GNUNET_OS_PROCESS_UNKNOWN: + GNUNET_break (0); + GNUNET_TESTING_interpreter_fail (is); + return; + case GNUNET_OS_PROCESS_RUNNING: + GNUNET_break (0); + GNUNET_TESTING_interpreter_fail (is); + return; + case GNUNET_OS_PROCESS_STOPPED: + GNUNET_break (0); + GNUNET_TESTING_interpreter_fail (is); + return; + case GNUNET_OS_PROCESS_EXITED: + if (0 != code) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Process exited with unexpected status %u\n", + (unsigned int) code); + GNUNET_TESTING_interpreter_fail (is); + return; + } + break; + case GNUNET_OS_PROCESS_SIGNALED: + GNUNET_break (0); + GNUNET_TESTING_interpreter_fail (is); + return; + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Dead child, go on with next command.\n"); + GNUNET_TESTING_interpreter_next (is); +} + + +/** + * Wait until we receive SIGCHLD signal. + * Then obtain the process trait of the current + * command, wait on the the zombie and continue + * with the next command. + */ +void +GNUNET_TESTING_wait_for_sigchld (struct GNUNET_TESTING_Interpreter *is) +{ + const struct GNUNET_DISK_FileHandle *pr; + + GNUNET_assert (NULL == is->child_death_task); + pr = GNUNET_DISK_pipe_handle (sigpipe, + GNUNET_DISK_PIPE_END_READ); + is->child_death_task + = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, + pr, + &maint_child_death, + is); +} + + +/** + * 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 is the interpreter state + * @param commands the list of command to execute + * @param timeout how long to wait + */ +void +GNUNET_TESTING_run2 (struct GNUNET_TESTING_Interpreter *is, + struct GNUNET_TESTING_Command *commands, + struct GNUNET_TIME_Relative timeout) +{ + unsigned int i; + + if (NULL != is->timeout_task) + { + GNUNET_SCHEDULER_cancel (is->timeout_task); + is->timeout_task = NULL; + } + /* get the number of commands */ + for (i = 0; NULL != commands[i].label; i++) + ; + is->commands = GNUNET_new_array (i + 1, + struct GNUNET_TESTING_Command); + memcpy (is->commands, + commands, + sizeof (struct GNUNET_TESTING_Command) * i); + is->timeout_task = GNUNET_SCHEDULER_add_delayed + (timeout, + &do_timeout, + is); + GNUNET_SCHEDULER_add_shutdown (&do_shutdown, is); + is->task = GNUNET_SCHEDULER_add_now (&interpreter_run, is); +} + + +/** + * 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 is the interpreter state + * @param commands the list of command to execute + */ +void +GNUNET_TESTING_run (struct GNUNET_TESTING_Interpreter *is, + struct GNUNET_TESTING_Command *commands) +{ + GNUNET_TESTING_run2 (is, + commands, + GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, + 5)); +} + + +/** + * Information used by the wrapper around the main + * "run" method. + */ +struct MainContext +{ + /** + * Main "run" method. + */ + GNUNET_TESTING_Main main_cb; + + /** + * Closure for @e main_cb. + */ + void *main_cb_cls; + + /** + * Interpreter state. + */ + struct GNUNET_TESTING_Interpreter *is; +}; + + +/** + * Signal handler called for SIGCHLD. Triggers the + * respective handler by writing to the trigger pipe. + */ +static void +sighandler_child_death (void) +{ + static char c; + int old_errno = errno; /* back-up errno */ + + GNUNET_break (1 == GNUNET_DISK_file_write + (GNUNET_DISK_pipe_handle (sigpipe, + GNUNET_DISK_PIPE_END_WRITE), + &c, sizeof (c))); + errno = old_errno; /* restore errno */ +} + + +/** + * Initialize scheduler loop and curl context for the testcase, + * and responsible to run the "run" method. + * + * @param cls closure, typically the "run" method, the + * interpreter state and a closure for "run". + */ +static void +main_wrapper_exchange_agnostic (void *cls) +{ + struct MainContext *main_ctx = cls; + + main_ctx->main_cb (main_ctx->main_cb_cls, + main_ctx->is); +} + + +/** + * Function run when the test is aborted before we launch the actual + * interpreter. Cleans up our state. + * + * @param cls the main context + */ +static void +do_abort (void *cls) +{ + struct MainContext *main_ctx = cls; + struct GNUNET_TESTING_Interpreter *is = main_ctx->is; + + is->timeout_task = NULL; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Executing abort prior to interpreter launch\n"); +} + + +/** + * Initialize scheduler loop and curl context for the testcase, + * and responsible to run the "run" method. + * + * @param cls a `struct MainContext *` + */ +static void +main_wrapper_exchange_connect (void *cls) +{ + struct MainContext *main_ctx = cls; + struct GNUNET_TESTING_Interpreter *is = main_ctx->is; + char *exchange_url; + + if (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_string (is->cfg, + "exchange", + "BASE_URL", + &exchange_url)) + { + GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, + "exchange", + "BASE_URL"); + return; + } + is->timeout_task = GNUNET_SCHEDULER_add_shutdown (&do_abort, + main_ctx); + is->working = GNUNET_YES; + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Starting main test loop\n"); + main_ctx->main_cb (main_ctx->main_cb_cls, + is); +} + + +/** + * Install signal handlers plus schedules the main wrapper + * around the "run" method. + * + * @param main_cb the "run" method which contains all the + * commands. + * @param main_cb_cls a closure for "run", typically NULL. + * @param cfg configuration to use + * @param exchanged exchange process handle: will be put in the + * state as some commands - e.g. revoke - need to send + * signal to it, for example to let it know to reload the + * key state.. if NULL, the interpreter will run without + * trying to connect to the exchange first. + * @param exchange_connect #GNUNET_YES if the test should connect + * to the exchange, #GNUNET_NO otherwise + * @return #GNUNET_OK if all is okay, != #GNUNET_OK otherwise. + * non-GNUNET_OK codes are #GNUNET_SYSERR most of the + * times. + */ +int +GNUNET_TESTING_setup (GNUNET_TESTING_Main main_cb, + void *main_cb_cls, + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct GNUNET_OS_Process *exchanged, + int exchange_connect) +{ + struct GNUNET_TESTING_Interpreter is; + struct MainContext main_ctx = { + .main_cb = main_cb, + .main_cb_cls = main_cb_cls, + /* needed to init the curl ctx */ + .is = &is, + }; + struct GNUNET_SIGNAL_Context *shc_chld; + + memset (&is, + 0, + sizeof (is)); + is.exchanged = exchanged; + is.cfg = cfg; + sigpipe = GNUNET_DISK_pipe (GNUNET_DISK_PF_NONE); + GNUNET_assert (NULL != sigpipe); + shc_chld = GNUNET_SIGNAL_handler_install + (GNUNET_SIGCHLD, + &sighandler_child_death); + + + /* Blocking */ + if (GNUNET_YES == exchange_connect) + GNUNET_SCHEDULER_run (&main_wrapper_exchange_connect, + &main_ctx); + else + GNUNET_SCHEDULER_run (&main_wrapper_exchange_agnostic, + &main_ctx); + if (NULL != is.final_cleanup_cb) + is.final_cleanup_cb (is.final_cleanup_cb_cls); + GNUNET_SIGNAL_handler_uninstall (shc_chld); + GNUNET_DISK_pipe_close (sigpipe); + sigpipe = NULL; + GNUNET_free (is.auditor_url); + GNUNET_free (is.exchange_url); + return is.result; +} + + +/* end of testing_api_loop.c */ diff --git a/src/testing/testing_api_trait_cmd.c b/src/testing/testing_api_trait_cmd.c new file mode 100644 index 000000000..67b26cb3e --- /dev/null +++ b/src/testing/testing_api_trait_cmd.c @@ -0,0 +1,79 @@ +/* + This file is part of GNUnet + Copyright (C) 2008, 2009, 2012 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 . + + SPDX-License-Identifier: AGPL3.0-or-later + */ + +/** + * @file testing/testing_api_trait_cmd.c + * @brief offers CMDs as traits. + * @author Marcello Stanisci (GNU Taler testing) + * @author t3sserakt + */ +#include "platform.h" +#include "gnunet_testing_ng_lib.h" + +#define GNUNET_TESTING_TRAIT_CMD "cmd" + + +/** + * Obtain a command from @a cmd. + * + * @param cmd command to extract the command from. + * @param index always zero. Commands offering this + * kind of traits do not need this index. For + * example, a "batch" CMD returns always the + * CMD currently being executed. + * @param[out] _cmd where to write the wire details. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_cmd (const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + struct GNUNET_TESTING_Command **_cmd) +{ + return cmd->traits (cmd->cls, + (const void **) _cmd, + GNUNET_TESTING_TRAIT_CMD, + index); +} + + +/** + * Offer a command in a trait. + * + * @param index always zero. Commands offering this + * kind of traits do not need this index. For + * example, a "meta" CMD returns always the + * CMD currently being executed. + * @param cmd wire details to offer. + * @return the trait. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_cmd (unsigned int index, + const struct GNUNET_TESTING_Command *cmd) +{ + struct GNUNET_TESTING_Trait ret = { + .index = index, + .trait_name = GNUNET_TESTING_TRAIT_CMD, + .ptr = (const struct GNUNET_TESTING_Command *) cmd + }; + return ret; +} + + +/* end of testing_api_trait_cmd.c */ diff --git a/src/testing/testing_api_trait_process.c b/src/testing/testing_api_trait_process.c new file mode 100644 index 000000000..7d694e35d --- /dev/null +++ b/src/testing/testing_api_trait_process.c @@ -0,0 +1,81 @@ +/* + This file is part of GNUnet + Copyright (C) 2008, 2009, 2012 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 . + + SPDX-License-Identifier: AGPL3.0-or-later + */ + +/** + * @file testing/testing_api_trait_process.c + * @brief trait offering process handles. + * @author Christian Grothoff (GNU Taler testing) + * @author Marcello Stanisci (GNU Taler testing) + * @author t3sserakt + */ +#include "platform.h" +#include "gnunet_testing_ng_lib.h" + +#define GNUNET_TESTING_TRAIT_PROCESS "process" + + +/** + * Obtain location where a command stores a pointer to a process. + * + * @param cmd command to extract trait from. + * @param index which process to pick if @a cmd + * has multiple on offer. + * @param[out] processp set to the address of the pointer to the + * process. + * @return #GNUNET_OK on success. + */ +int +GNUNET_TESTING_get_trait_process + (const struct GNUNET_TESTING_Command *cmd, + unsigned int index, + struct GNUNET_OS_Process ***processp) +{ + return cmd->traits (cmd->cls, + (const void **) processp, + GNUNET_TESTING_TRAIT_PROCESS, + index); +} + + +/** + * Offer location where a command stores a pointer to a process. + * + * @param index offered location index number, in case there are + * multiple on offer. + * @param processp process location to offer. + * + * @return the trait. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_make_trait_process + (unsigned int index, + struct GNUNET_OS_Process **processp) +{ + struct GNUNET_TESTING_Trait ret = { + .index = index, + .trait_name = GNUNET_TESTING_TRAIT_PROCESS, + .ptr = (const void *) processp + }; + + return ret; +} + + +/* end of testing_api_trait_process.c */ diff --git a/src/testing/testing_api_traits.c b/src/testing/testing_api_traits.c new file mode 100644 index 000000000..3af839b78 --- /dev/null +++ b/src/testing/testing_api_traits.c @@ -0,0 +1,81 @@ +/* + This file is part of GNUnet + Copyright (C) 2008, 2009, 2012 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 . + + SPDX-License-Identifier: AGPL3.0-or-later + */ + +/** + * @file testing/testing_api_traits.c + * @brief loop for trait resolution + * @author Christian Grothoff (GNU Taler testing) + * @author Marcello Stanisci (GNU Taler testing) + * @author t3sserakt + */ +#include "platform.h" +#include "gnunet_testing_ng_lib.h" + + +/** + * End a trait array. Usually, commands offer several traits, + * and put them in arrays. + */ +struct GNUNET_TESTING_Trait +GNUNET_TESTING_trait_end () +{ + struct GNUNET_TESTING_Trait end = { + .index = 0, + .trait_name = NULL, + .ptr = NULL + }; + + return end; +} + + +/** + * Pick the chosen trait from the traits array. + * + * @param traits the traits array. + * @param ret where to store the result. + * @param trait type of the trait to extract. + * @param index index number of the object to extract. + * @return #GNUNET_OK if no error occurred, #GNUNET_SYSERR otherwise. + */ +int +GNUNET_TESTING_get_trait (const struct GNUNET_TESTING_Trait *traits, + const void **ret, + const char *trait, + unsigned int index) +{ + for (unsigned int i = 0; NULL != traits[i].trait_name; i++) + { + if ( (0 == strcmp (trait, traits[i].trait_name)) && + (index == traits[i].index) ) + { + *ret = (void *) traits[i].ptr; + return GNUNET_OK; + } + } + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "Trait %s/%u not found.\n", + trait, index); + + return GNUNET_SYSERR; +} + + +/* end of testing_api_traits.c */ -- cgit v1.2.3