taler/exchange
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Adapting wirewatch tests to new style.

Browse Source
This commit is contained in:
Marcello Stanisci 2020-01-16 00:11:51 +01:00
parent 2c4bdcc4c0
commit 90e1572039
No known key found for this signature in database
GPG Key ID: 8D526861953F4C0F
7 changed files with 64 additions and 744 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/auditordb/plugin_auditordb_postgres.c
View File

@ -1040,13 +1040,13 @@ postgres_preflight (void *cls,
es))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"BUG: Preflight check committed transaction `%s'!\n",
"BUG: Preflight check rolled back transaction `%s'!\n",
session->transaction_name);
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"BUG: Preflight check failed to commit transaction `%s'!\n",
"BUG: Preflight check failed to rollback transaction `%s'!\n",
session->transaction_name);
}
session->transaction_name = NULL;

2
src/bank-lib/fakebank.c
View File

@ -1053,7 +1053,7 @@ handle_credit_history (struct TALER_FAKEBANK_Handle *h,
credit_payto = TALER_payto_xtalerbank_make (h->my_baseurl,
pos->credit_account);
debit_payto = TALER_payto_xtalerbank_make (h->my_baseurl,
account);
pos->debit_account);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Returning transaction %s->%s (%s)\n",
debit_payto,

6
src/exchange/taler-exchange-aggregator.c
View File

@ -1244,6 +1244,10 @@ expired_reserve_cb (void *cls,
erc->async_cont = GNUNET_YES;
task = GNUNET_SCHEDULER_add_now (&run_transfers,
NULL);
GNUNET_free (ctc->method);
GNUNET_free (ctc);
ctc = NULL;
return GNUNET_DB_STATUS_SUCCESS_ONE_RESULT;
}
@ -1326,9 +1330,9 @@ run_reserve_closures (void *cls)
NULL);
return;
case GNUNET_DB_STATUS_SUCCESS_ONE_RESULT:
(void) commit_or_warn (session);
if (GNUNET_YES == erc.async_cont)
break;
(void) commit_or_warn (session);
task = GNUNET_SCHEDULER_add_now (&run_reserve_closures,
NULL);
return;

8
src/exchangedb/plugin_exchangedb_postgres.c
View File

@ -1743,6 +1743,10 @@ postgres_start (void *cls,
GNUNET_PQ_EXECUTE_STATEMENT_END
};
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Starting transaction named: %s\n",
name);
postgres_preflight (cls,
session);
@ -1840,13 +1844,13 @@ postgres_preflight (void *cls,
es))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"BUG: Preflight check committed transaction `%s'!\n",
"BUG: Preflight check rolled back transaction `%s'!\n",
session->transaction_name);
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"BUG: Preflight check failed to commit transaction `%s'!\n",
"BUG: Preflight check failed to rollback transaction `%s'!\n",
session->transaction_name);
}
session->transaction_name = NULL;

2
src/lib/test-taler-exchange-wirewatch-postgres.conf
View File

@ -46,7 +46,7 @@ PORT = 8083
[account-1]
# What is the account URL?
URL = "payto://x-taler-bank/localhost:8082/3"
URL = "payto://x-taler-bank/localhost:8082/2"
METHOD = x-taler-bank
WIRE_RESPONSE = ${TALER_CONFIG_HOME}/account-1.json

4
src/lib/test_taler_exchange_httpd_home/.config/taler/account-1.json
View File

@ -1,4 +1,4 @@
{
"url": "payto://x-taler-bank/localhost:8082/3",
"master_sig": "P0EC2BBQ8HYCMR29651K7Y36MVQMDP2746EHTAGXYKNVXRZR604BGDSGZ99NPM26BJJFAR16MGW2QJD15BXYPJWNPY2WVACHTW0XE2R"
"url": "payto://x-taler-bank/localhost:8082/2",
"master_sig": "2MNAYBN0Q5VEJKFBGH2SRJQSV3QXA81FPXMFF5Y5YQQW1MRTDGJTZX35XHMCZFZ9SN9Q4TQ6MNM8EX7GPPD2MP8Q528A1D8RK7N9J38"
}

778
src/lib/test_taler_exchange_wirewatch.c
View File

@ -41,563 +41,22 @@ static struct TALER_TESTING_BankConfiguration bc;
/**
* Helper structure to keep exchange configuration values.
*/
struct TALER_TESTING_ExchangeConfiguration ec;
// just to compile
int result;
/**
* Commands for the interpreter.
*/
enum OpCode
{
/**
* Terminate testcase with 'skipped' result.
*/
OPCODE_TERMINATE_SKIP,
/**
* Run taler-exchange-aggregator.
*/
OPCODE_RUN_AGGREGATOR,
/**
* Expect that we have exhaustively gone over all transactions.
*/
OPCODE_RUN_WIREWATCH,
/**
* Send money from bank to exchange.
*/
OPCODE_RUN_TRANSFER,
/**
* Wait a certain amount of time.
*/
OPCODE_WAIT,
/**
* Expect that we have received the specified transfer.
*/
OPCODE_EXPECT_TRANSFER,
/**
* Expect that we have 'expected' all wire transfers.
*/
OPCODE_EXPECT_TRANSFERS_EMPTY,
/**
* Finish testcase with success.
*/
OPCODE_TERMINATE_SUCCESS
};
/**
* Command state for the interpreter.
*/
struct Command
{
/**
* What instruction should we run?
*/
enum OpCode opcode;
/**
* Human-readable label for the command.
*/
const char *label;
union
{
/**
* If @e opcode is #OPCODE_EXPECT_TRANSFER, this
* specifies which transaction we expected. Note that
* the WTID will be set, not checked!
*/
struct
{
/**
* Amount to be transferred.
*/
const char *amount;
/**
* Account to debit.
*/
uint64_t debit_account;
/**
* Account to credit.
*/
uint64_t credit_account;
/**
* Expected base URL for the exchange.
*/
const char *exchange_base_url;
/**
* Subject of the transfer, set by the command.
*/
struct TALER_WireTransferIdentifierRawP wtid;
} expect_transfer;
/**
* If @e opcode is #OPCODE_RUN_TRANSFER, this
* specifies which transaction the bank should do.
*/
struct
{
/**
* Amount to be transferred.
*/
const char *amount;
/**
* Account to debit.
*/
uint64_t debit_account;
/**
* Account to credit.
*/
uint64_t credit_account;
/**
* Subject of the transfer, set by the command.
*/
const char *subject;
/**
* Serial ID of the wire transfer as assigned by the bank.
*/
uint64_t serial_id;
} run_transfer;
struct
{
/**
* The handle for the aggregator process that we are testing.
*/
struct GNUNET_OS_Process *aggregator_proc;
/**
* ID of task called whenever we get a SIGCHILD.
*/
struct GNUNET_SCHEDULER_Task *child_death_task;
} aggregator;
struct
{
/**
* The handle for the wirewatch process that we are testing.
*/
struct GNUNET_OS_Process *wirewatch_proc;
/**
* ID of task called whenever we get a SIGCHILD.
*/
struct GNUNET_SCHEDULER_Task *child_death_task;
} wirewatch;
/**
* How long should we wait if the opcode is #OPCODE_WAIT.
*/
struct GNUNET_TIME_Relative wait_delay;
} details;
};
/**
* State of the interpreter.
*/
struct State
{
/**
* Array of commands to run.
*/
struct Command*commands;
/**
* Offset of the next command to be run.
*/
unsigned int ioff;
};
/**
* Pipe used to communicate child death via signal.
*/
static struct GNUNET_DISK_PipeHandle *sigpipe;
/**
* ID of task called whenever we time out.
*/
static struct GNUNET_SCHEDULER_Task *timeout_task;
static struct TALER_TESTING_ExchangeConfiguration ec;
/**
* Name of the configuration file to use.
*/
static char *config_filename;
/**
* Task running the interpreter().
*/
static struct GNUNET_SCHEDULER_Task *int_task;
/**
* Handle for our fake bank.
*/
static struct TALER_FAKEBANK_Handle *fb;
/**
* Interprets the commands from the test program.
*
* @param cls the `struct State` of the interpreter
*/
static void
interpreter (void *cls);
/**
* Advance the IP and run the next command.
*
* @param state interpreter to advance.
*/
static void
next_command (struct State *state)
static struct TALER_TESTING_Command
transfer_to_exchange (const char *label,
const char *amount)
{
GNUNET_assert (NULL == int_task);
state->ioff++;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Advancing to command %s\n",
state->commands[state->ioff].label);
int_task = GNUNET_SCHEDULER_add_now (&interpreter,
state);
}
/**
* Fail the testcase at the current command.
*/
static void
fail (struct Command *cmd)
{
GNUNET_assert (NULL == int_task);
fprintf (stderr,
"Testcase failed at command `%s'\n",
cmd->label);
result = 2;
GNUNET_SCHEDULER_shutdown ();
}
/**
* Task triggered whenever we are to shutdown.
*
* @param cls closure, NULL if we need to self-restart
*/
static void
timeout_action (void *cls)
{
timeout_task = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Test failed: timeout\n");
result = 2;
GNUNET_SCHEDULER_shutdown ();
}
/**
* Task triggered whenever we are to shutdown.
*
* @param cls our `struct State`
*/
static void
shutdown_action (void *cls)
{
struct State *state = cls;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Running shutdown\n");
if (NULL != timeout_task)
{
GNUNET_SCHEDULER_cancel (timeout_task);
timeout_task = NULL;
}
if (NULL != int_task)
{
GNUNET_SCHEDULER_cancel (int_task);
int_task = NULL;
}
if (NULL != fb)
{
TALER_FAKEBANK_stop (fb);
fb = NULL;
}
for (unsigned int i = 0; i<=state->ioff; i++)
{
struct Command *cmd = &state->commands[i];
switch (cmd->opcode)
{
case OPCODE_TERMINATE_SKIP:
break;
case OPCODE_RUN_AGGREGATOR:
if (NULL != cmd->details.aggregator.child_death_task)
{
GNUNET_SCHEDULER_cancel (cmd->details.aggregator.child_death_task);
cmd->details.aggregator.child_death_task = NULL;
}
if (NULL != cmd->details.aggregator.aggregator_proc)
{
GNUNET_break (0 == GNUNET_OS_process_kill (
cmd->details.aggregator.aggregator_proc,
SIGKILL));
GNUNET_OS_process_wait (cmd->details.aggregator.aggregator_proc);
GNUNET_OS_process_destroy (cmd->details.aggregator.aggregator_proc);
cmd->details.aggregator.aggregator_proc = NULL;
}
break;
case OPCODE_RUN_WIREWATCH:
if (NULL != cmd->details.wirewatch.child_death_task)
{
GNUNET_SCHEDULER_cancel (cmd->details.wirewatch.child_death_task);
cmd->details.wirewatch.child_death_task = NULL;
}
if (NULL != cmd->details.wirewatch.wirewatch_proc)
{
GNUNET_break (0 == GNUNET_OS_process_kill (
cmd->details.wirewatch.wirewatch_proc,
SIGKILL));
GNUNET_OS_process_wait (cmd->details.wirewatch.wirewatch_proc);
GNUNET_OS_process_destroy (cmd->details.wirewatch.wirewatch_proc);
cmd->details.wirewatch.wirewatch_proc = NULL;
}
break;
case OPCODE_RUN_TRANSFER:
break;
case OPCODE_WAIT:
break;
case OPCODE_EXPECT_TRANSFER:
break;
case OPCODE_EXPECT_TRANSFERS_EMPTY:
break;
case OPCODE_TERMINATE_SUCCESS:
break;
}
}
}
/**
* Task triggered whenever we receive a SIGCHLD (child
* process died).
*
* @param cls our `struct State`
*/
static void
maint_child_death (void *cls)
{
struct State *state = cls;
const struct GNUNET_DISK_FileHandle *pr;
struct Command *cmd = &state->commands[state->ioff];
char c[16];
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Child process died for command %s\n",
cmd->label);
pr = GNUNET_DISK_pipe_handle (sigpipe,
GNUNET_DISK_PIPE_END_READ);
GNUNET_break (0 < GNUNET_DISK_file_read (pr,
&c,
sizeof (c)));
switch (cmd->opcode)
{
case OPCODE_RUN_AGGREGATOR:
GNUNET_assert (NULL != cmd->details.aggregator.child_death_task);
cmd->details.aggregator.child_death_task = NULL;
GNUNET_OS_process_wait (cmd->details.aggregator.aggregator_proc);
GNUNET_OS_process_destroy (cmd->details.aggregator.aggregator_proc);
cmd->details.aggregator.aggregator_proc = NULL;
break;
case OPCODE_RUN_WIREWATCH:
GNUNET_assert (NULL != cmd->details.wirewatch.child_death_task);
cmd->details.wirewatch.child_death_task = NULL;
GNUNET_OS_process_wait (cmd->details.wirewatch.wirewatch_proc);
GNUNET_OS_process_destroy (cmd->details.wirewatch.wirewatch_proc);
cmd->details.wirewatch.wirewatch_proc = NULL;
break;
default:
fail (cmd);
return;
}
next_command (state);
}
/**
* Interprets the commands from the test program.
*
* @param cls the `struct State` of the interpreter
*/
static void
interpreter (void *cls)
{
struct State *state = cls;
struct Command *cmd = &state->commands[state->ioff];
GNUNET_assert (NULL != int_task);
int_task = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Running command %u (%s)\n",
state->ioff,
cmd->label);
#if 0
switch (cmd->opcode)
{
case OPCODE_TERMINATE_SKIP:
/* return skip: test not finished, but did not fail either */
result = 77;
GNUNET_SCHEDULER_shutdown ();
return;
case OPCODE_RUN_AGGREGATOR:
cmd->details.aggregator.child_death_task =
GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
GNUNET_DISK_pipe_handle (sigpipe,
GNUNET_DISK_PIPE_END_READ),
&maint_child_death,
state);
cmd->details.aggregator.aggregator_proc
= GNUNET_OS_start_process (GNUNET_NO,
GNUNET_OS_INHERIT_STD_ALL,
NULL, NULL, NULL,
"taler-exchange-aggregator",
"taler-exchange-aggregator",
"-c", config_filename,
"-t", /* enable temporary tables */
NULL);
if (NULL == cmd->details.aggregator.aggregator_proc)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to start taler-exchange-aggregator. Check $PATH.\n");
GNUNET_break (0);
fail (cmd);
return;
}
return;
case OPCODE_RUN_WIREWATCH:
cmd->details.wirewatch.child_death_task =
GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
GNUNET_DISK_pipe_handle (sigpipe,
GNUNET_DISK_PIPE_END_READ),
&maint_child_death,
state);
cmd->details.wirewatch.wirewatch_proc
= GNUNET_OS_start_process (GNUNET_NO,
GNUNET_OS_INHERIT_STD_ALL,
NULL, NULL, NULL,
"taler-exchange-wirewatch",
"taler-exchange-wirewatch",
"-c", config_filename,
"-T", /* run in test mode, exit instead of looping */
NULL);
if (NULL == cmd->details.wirewatch.wirewatch_proc)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to start taler-exchange-wirewatch. Check $PATH.\n");
GNUNET_break (0);
fail (cmd);
return;
}
return;
case OPCODE_RUN_TRANSFER:
{
struct TALER_Amount amount;
if (GNUNET_OK !=
TALER_string_to_amount (cmd->details.run_transfer.amount,
&amount))
{
GNUNET_break (0);
fail (cmd);
return;
}
GNUNET_assert (NULL != cmd->details.run_transfer.subject);
cmd->details.run_transfer.serial_id
= TALER_FAKEBANK_make_transfer (fb,
cmd->details.run_transfer.debit_account,
cmd->details.run_transfer.credit_account,
&amount,
cmd->details.run_transfer.subject,
"https://exchange.taler.net/");
next_command (state);
return;
}
case OPCODE_WAIT:
state->ioff++;
GNUNET_assert (NULL == int_task);
int_task = GNUNET_SCHEDULER_add_delayed (cmd->details.wait_delay,
&interpreter,
state);
return;
case OPCODE_EXPECT_TRANSFER:
{
struct TALER_Amount want_amount;
if (GNUNET_OK !=
TALER_string_to_amount (cmd->details.expect_transfer.amount,
&want_amount))
{
GNUNET_break (0);
fail (cmd);
return;
}
if (GNUNET_OK !=
TALER_FAKEBANK_check_debit (fb,
&want_amount,
cmd->details.expect_transfer.debit_account,
cmd->details.expect_transfer.
credit_account,
cmd->details.expect_transfer.
exchange_base_url,
&cmd->details.expect_transfer.wtid))
{
fail (cmd);
return;
}
next_command (state);
return;
}
case OPCODE_EXPECT_TRANSFERS_EMPTY:
if (GNUNET_OK != TALER_FAKEBANK_check_empty (fb))
{
fail (cmd);
return;
}
next_command (state);
return;
case OPCODE_TERMINATE_SUCCESS:
result = 0;
GNUNET_SCHEDULER_shutdown ();
return;
}
#endif
return TALER_TESTING_cmd_admin_add_incoming (label,
amount,
bc.exchange_account_url,
&bc.exchange_auth,
bc.user42_payto);
}
/**
@ -611,194 +70,46 @@ run (void *cls,
struct TALER_TESTING_Interpreter *is)
{
struct TALER_TESTING_Command all[] = {
// TALER_TESTING_cmd_exec_aggregator ("expect-empty-transactions-on-start",
// config_filename),
TALER_TESTING_cmd_check_bank_empty ("expect-empty-transactions-on-start"),
TALER_TESTING_cmd_exec_aggregator ("run-aggregator-on-empty",
config_filename),
TALER_TESTING_cmd_exec_wirewatch ("run-wirewatch-on-empty",
config_filename),
TALER_TESTING_cmd_check_bank_empty ("expect-transfers-empty-after-dry-run"),
transfer_to_exchange ("run-transfer-good-to-exchange",
"EUR:5"),
TALER_TESTING_cmd_exec_wirewatch ("run-wirewatch-on-good-transfer",
config_filename),
TALER_TESTING_cmd_check_bank_admin_transfer ("clear-good-transfer-to-the-exchange",
"EUR:5",
bc.user42_payto, // debit
bc.exchange_payto, // credit
"run-transfer-good-to-exchange"),
TALER_TESTING_cmd_exec_aggregator ("run-aggregator-non-expired-reserve",
config_filename),
TALER_TESTING_cmd_check_bank_empty ("expect-empty-transactions-1"),
TALER_TESTING_cmd_sleep ("wait (5s)",
5),
TALER_TESTING_cmd_exec_aggregator ("run-aggregator-on-expired-reserve",
config_filename),
TALER_TESTING_cmd_check_bank_transfer ("check-reserve-expiration-transfer",
ec.exchange_url,
"EUR:4.99",
bc.exchange_payto,
bc.user42_payto),
TALER_TESTING_cmd_check_bank_empty ("expect-empty-transactions-2"),
TALER_TESTING_cmd_end ()
};
TALER_TESTING_run_with_fakebank (is,
all,
bc.bank_url);
}
/**
* Main function that will be run by the scheduler.
*
* @param cls closure with configuration
*/
static void
OLDrun (void *cls)
{
static struct Command commands[] = {
#if 0
/* test running with empty DB */
{
.opcode = OPCODE_EXPECT_TRANSFERS_EMPTY,
.label = "expect-empty-transactions-on-start"
},
{
.opcode = OPCODE_RUN_AGGREGATOR,
.label = "run-aggregator-on-empty"
},
{
.opcode = OPCODE_RUN_WIREWATCH,
.label = "run-wirewatch-on-empty"
},
{
.opcode = OPCODE_EXPECT_TRANSFERS_EMPTY,
.label = "expect-empty-transactions-after-dry-run"
},
/* fill exchange's reserve at bank */
{
.opcode = OPCODE_RUN_TRANSFER,
.label = "run-transfer-good-to-exchange",
.details.run_transfer.debit_account = 4,
.details.run_transfer.credit_account = 3,
.details.run_transfer.subject =
"SRB8VQHNTNJWSSG7BXT24Z063ZSXN7T0MHCQCBAFC1V17BZH10D0",
.details.run_transfer.amount = "EUR:5.00"
},
/* creates reserve */
{
.opcode = OPCODE_RUN_WIREWATCH,
.label = "run-wirewatch-on-good-transfer"
},
/* clear first transfer from DLL */
{
.opcode = OPCODE_EXPECT_TRANSFER,
.label = "clear-good-transfer-to-exchange",
.details.expect_transfer.debit_account = 4,
.details.expect_transfer.credit_account = 3,
.details.expect_transfer.exchange_base_url =
"https://exchange.taler.net/",
.details.expect_transfer.amount = "EUR:5.00"
},
/* should do NOTHING, it is too early... */
{
.opcode = OPCODE_RUN_AGGREGATOR,
.label = "run-aggregator-non-expired-reserve"
},
/* check nothing happened */
{
.opcode = OPCODE_EXPECT_TRANSFERS_EMPTY,
.label = "expect-empty-transactions-1"
},
/* Configuration says reserves expire after 5s! */
{
.opcode = OPCODE_WAIT,
.label = "wait (5s)",
.details.wait_delay = { 1000LL * 1000 * 6 } /* 6s */
},
/* This time the reserve expired, so the money should go back... */
{
.opcode = OPCODE_RUN_AGGREGATOR,
.label = "run-aggregator-non-expired-reserve"
},
/* Check exchange sent money back, minus closing fee of EUR:0.01 */
{
.opcode = OPCODE_EXPECT_TRANSFER,
.label = "check-reserve-expiration-transfer",
.details.expect_transfer.debit_account = 3,
.details.expect_transfer.credit_account = 4,
.details.expect_transfer.exchange_base_url =
"https://exchange.taler.net/",
.details.expect_transfer.amount = "EUR:4.99"
},
/* check nothing else happened */
{
.opcode = OPCODE_EXPECT_TRANSFERS_EMPTY,
.label = "expect-empty-transactions-1"
},
/* This cannot work unless #5077 is implemented. */
#if TEST_5077
{
.opcode = OPCODE_RUN_TRANSFER,
.label = "run-transfer-bad-to-exchange",
.details.run_transfer.debit_account = 4,
.details.run_transfer.credit_account = 3,
.details.run_transfer.subject = "random junk",
.details.run_transfer.amount = "EUR:5.00"
},
{
.opcode = OPCODE_RUN_WIREWATCH,
.label = "run-wirewatch-on-bad-transfer"
},
{
.opcode = OPCODE_EXPECT_TRANSFER,
.label = "expect-bad-transfer-to-exchange",
.details.expect_transfer.debit_account = 4,
.details.expect_transfer.credit_account = 3,
.details.expect_transfer.exchange_base_url =
"https://exchange.taler.net/",
.details.expect_transfer.amount = "EUR:5.00"
},
{
.opcode = OPCODE_EXPECT_TRANSFER,
.label = "expect-rewire-transfer-from-exchange",
.details.expect_transfer.debit_account = 3,
.details.expect_transfer.credit_account = 4,
.details.expect_transfer.exchange_base_url =
"https://exchange.taler.net/",
.details.expect_transfer.amount = "EUR:5.00"
},
{
.opcode = OPCODE_EXPECT_TRANSFERS_EMPTY,
.label = "expect-empty-transactions-1"
},
#endif
{
.opcode = OPCODE_TERMINATE_SUCCESS,
.label = "testcase-complete-terminating-with-success"
}
#endif
};
static struct State state = {
.commands = commands
};
GNUNET_SCHEDULER_add_shutdown (&shutdown_action,
&state);
timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
&timeout_action,
&state);
result = 1; /* test failed for undefined reason */
fb = TALER_FAKEBANK_start (8082);
if (NULL == fb)
{
GNUNET_SCHEDULER_shutdown ();
result = 77;
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Launching interpreter\n");
int_task = GNUNET_SCHEDULER_add_now (&interpreter,
&state);
}
/**
* Signal handler called for SIGCHLD. Triggers the
* respective handler by writing to the trigger pipe.
*/
static void
sighandler_child_death ()
{
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 */
}
int
main (int argc,
char *const argv[])
@ -813,7 +124,7 @@ main (int argc,
unsetenv ("XDG_DATA_HOME");
unsetenv ("XDG_CONFIG_HOME");
GNUNET_log_setup ("test_taler_exchange_wirewatch",
"WARNING",
"DEBUG",
NULL);
if (NULL == (plugin_name = strrchr (argv[0], (int) '-')))
@ -858,9 +169,10 @@ main (int argc,
&bc))
return 77;
return TALER_TESTING_setup_with_exchange (&run,
return
(GNUNET_OK == TALER_TESTING_setup_with_exchange (&run,
NULL,
config_filename);
config_filename)) ? 0 : 1;
}
/* end of test_taler_exchange_wirewatch.c */