along with this program. If not, see <http://www.gnu.org/licenses/>.
SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
/**
* @file cadet/test_cadet.c
* @author Bart Polot
/**
* Ugly workaround to unify data handlers on incoming and outgoing channels.
*/
-struct CadetTestChannelWrapper
-{
+struct CadetTestChannelWrapper {
/**
* Channel pointer.
*/
/**
* How long until we give up on connecting the peers?
*/
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120)
/**
* Time to wait by default for stuff that should be rather fast.
*/
-#define SHORT_TIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20)
+#define SHORT_TIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20)
/**
* How fast do we send messages?
*/
-#define SEND_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 10)
+#define SEND_INTERVAL GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 10)
/**
* DIFFERENT TESTS TO RUN
/**
* Size of each test packet's payload
*/
-static size_t size_payload = sizeof (uint32_t);
+static size_t size_payload = sizeof(uint32_t);
/**
* Operation to get peer ids.
* or the last peer in the line (for other tests).
*/
static struct GNUNET_CADET_Channel *
-get_target_channel ()
+get_target_channel()
{
if (SPEED == test && GNUNET_YES == test_backwards)
return outgoing_ch;
* Show the results of the test (banwidth acheived) and log them to GAUGER
*/
static void
-show_end_data (void)
+show_end_data(void)
{
static struct GNUNET_TIME_Absolute end_time;
static struct GNUNET_TIME_Relative total_time;
- end_time = GNUNET_TIME_absolute_get ();
- total_time = GNUNET_TIME_absolute_get_difference (start_time, end_time);
- fprintf (stderr,
- "\nResults of test \"%s\"\n",
- test_name);
- fprintf (stderr,
- "Test time %s\n",
- GNUNET_STRINGS_relative_time_to_string (total_time, GNUNET_YES));
- fprintf (stderr,
- "Test bandwidth: %f kb/s\n",
- 4 * total_packets * 1.0 / (total_time.rel_value_us / 1000)); // 4bytes * ms
- fprintf (stderr,
- "Test throughput: %f packets/s\n\n",
- total_packets * 1000.0 / (total_time.rel_value_us / 1000)); // packets * ms
- GAUGER ("CADET",
- test_name,
- total_packets * 1000.0 / (total_time.rel_value_us / 1000),
- "packets/s");
+ end_time = GNUNET_TIME_absolute_get();
+ total_time = GNUNET_TIME_absolute_get_difference(start_time, end_time);
+ fprintf(stderr,
+ "\nResults of test \"%s\"\n",
+ test_name);
+ fprintf(stderr,
+ "Test time %s\n",
+ GNUNET_STRINGS_relative_time_to_string(total_time, GNUNET_YES));
+ fprintf(stderr,
+ "Test bandwidth: %f kb/s\n",
+ 4 * total_packets * 1.0 / (total_time.rel_value_us / 1000)); // 4bytes * ms
+ fprintf(stderr,
+ "Test throughput: %f packets/s\n\n",
+ total_packets * 1000.0 / (total_time.rel_value_us / 1000)); // packets * ms
+ GAUGER("CADET",
+ test_name,
+ total_packets * 1000.0 / (total_time.rel_value_us / 1000),
+ "packets/s");
}
* @param tc Task Context.
*/
static void
-disconnect_cadet_peers (void *cls)
+disconnect_cadet_peers(void *cls)
{
- long line = (long) cls;
+ long line = (long)cls;
disconnect_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "disconnecting cadet service of peers, called from line %ld\n",
- line);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "disconnecting cadet service of peers, called from line %ld\n",
+ line);
for (unsigned int i = 0; i < 2; i++)
- {
- GNUNET_TESTBED_operation_done (t_op[i]);
- }
+ {
+ GNUNET_TESTBED_operation_done(t_op[i]);
+ }
if (NULL != outgoing_ch)
- {
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
+ {
+ GNUNET_CADET_channel_destroy(outgoing_ch);
+ outgoing_ch = NULL;
+ }
if (NULL != incoming_ch)
- {
- GNUNET_CADET_channel_destroy (incoming_ch);
- incoming_ch = NULL;
- }
- GNUNET_CADET_TEST_cleanup (test_ctx);
- GNUNET_SCHEDULER_shutdown ();
+ {
+ GNUNET_CADET_channel_destroy(incoming_ch);
+ incoming_ch = NULL;
+ }
+ GNUNET_CADET_TEST_cleanup(test_ctx);
+ GNUNET_SCHEDULER_shutdown();
}
* @param tc Task Context.
*/
static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Ending test.\n");
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Ending test.\n");
if (NULL != send_next_msg_task)
- {
- GNUNET_SCHEDULER_cancel (send_next_msg_task);
- send_next_msg_task = NULL;
- }
+ {
+ GNUNET_SCHEDULER_cancel(send_next_msg_task);
+ send_next_msg_task = NULL;
+ }
if (NULL != test_task)
- {
- GNUNET_SCHEDULER_cancel (test_task);
- test_task = NULL;
- }
+ {
+ GNUNET_SCHEDULER_cancel(test_task);
+ test_task = NULL;
+ }
if (NULL != disconnect_task)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task =
- GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- (void *) __LINE__);
- }
+ {
+ GNUNET_SCHEDULER_cancel(disconnect_task);
+ disconnect_task =
+ GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers,
+ (void *)__LINE__);
+ }
}
* operation has executed successfully.
*/
static void
-stats_cont (void *cls,
- struct GNUNET_TESTBED_Operation *op,
- const char *emsg)
+stats_cont(void *cls,
+ struct GNUNET_TESTBED_Operation *op,
+ const char *emsg)
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "KA sent: %u, KA received: %u\n",
- ka_sent,
- ka_received);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "KA sent: %u, KA received: %u\n",
+ ka_sent,
+ ka_received);
if ((KEEPALIVE == test || REOPEN == test) &&
((ka_sent < 2) || (ka_sent > ka_received + 1)))
- {
- GNUNET_break (0);
- ok--;
- }
- GNUNET_TESTBED_operation_done (stats_op);
+ {
+ GNUNET_break(0);
+ ok--;
+ }
+ GNUNET_TESTBED_operation_done(stats_op);
if (NULL != disconnect_task)
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- cls);
+ GNUNET_SCHEDULER_cancel(disconnect_task);
+ disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers,
+ cls);
}
* @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
*/
static int
-stats_iterator (void *cls,
- const struct GNUNET_TESTBED_Peer *peer,
- const char *subsystem,
- const char *name,
- uint64_t value,
- int is_persistent)
+stats_iterator(void *cls,
+ const struct GNUNET_TESTBED_Peer *peer,
+ const char *subsystem,
+ const char *name,
+ uint64_t value,
+ int is_persistent)
{
static const char *s_sent = "# keepalives sent";
static const char *s_recv = "# keepalives received";
static const char *cdrops = "# messages dropped due to slow client";
uint32_t i;
- i = GNUNET_TESTBED_get_index (peer);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i,
- subsystem, name, (unsigned long long) value);
- if (0 == strncmp (s_sent, name, strlen (s_sent)) && 0 == i)
+ i = GNUNET_TESTBED_get_index(peer);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "STATS PEER %u - %s [%s]: %llu\n", i,
+ subsystem, name, (unsigned long long)value);
+ if (0 == strncmp(s_sent, name, strlen(s_sent)) && 0 == i)
ka_sent = value;
- if (0 == strncmp (s_recv, name, strlen (s_recv)) && peers_requested - 1 == i)
+ if (0 == strncmp(s_recv, name, strlen(s_recv)) && peers_requested - 1 == i)
ka_received = value;
- if (0 == strncmp (rdrops, name, strlen (rdrops)))
+ if (0 == strncmp(rdrops, name, strlen(rdrops)))
msg_dropped += value;
- if (0 == strncmp (cdrops, name, strlen (cdrops)))
+ if (0 == strncmp(cdrops, name, strlen(cdrops)))
msg_dropped += value;
return GNUNET_OK;
* @param cls Closure (line from which the task was scheduled).
*/
static void
-gather_stats_and_exit (void *cls)
+gather_stats_and_exit(void *cls)
{
- long l = (long) cls;
+ long l = (long)cls;
disconnect_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "gathering statistics from line %ld\n",
- l);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "gathering statistics from line %ld\n",
+ l);
if (NULL != outgoing_ch)
- {
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
- stats_op = GNUNET_TESTBED_get_statistics (peers_running,
- testbed_peers,
- "cadet",
- NULL,
- &stats_iterator,
- stats_cont,
- cls);
+ {
+ GNUNET_CADET_channel_destroy(outgoing_ch);
+ outgoing_ch = NULL;
+ }
+ stats_op = GNUNET_TESTBED_get_statistics(peers_running,
+ testbed_peers,
+ "cadet",
+ NULL,
+ &stats_iterator,
+ stats_cont,
+ cls);
}
* @param channel Channel to send the message on.
*/
static void
-send_test_message (struct GNUNET_CADET_Channel *channel);
+send_test_message(struct GNUNET_CADET_Channel *channel);
/**
* Check if payload is sane (size contains payload).
* #GNUNET_SYSERR to close it (signal serious error).
*/
static int
-check_data (void *cls,
- const struct GNUNET_MessageHeader *message);
+check_data(void *cls,
+ const struct GNUNET_MessageHeader *message);
/**
* Function is called whenever a message is received.
* @param message the actual message
*/
static void
-handle_data (void *cls,
- const struct GNUNET_MessageHeader *message);
+handle_data(void *cls,
+ const struct GNUNET_MessageHeader *message);
/**
* Function called whenever an MQ-channel is destroyed, unless the destruction
* @param channel Connection to the other end (henceforth invalid).
*/
static void
-disconnect_handler (void *cls,
- const struct GNUNET_CADET_Channel *channel);
+disconnect_handler(void *cls,
+ const struct GNUNET_CADET_Channel *channel);
/**
* @param cls Closure (line from which the task was scheduled).
*/
static void
-reconnect_op (void *cls)
+reconnect_op(void *cls)
{
struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (data,
- GNUNET_MESSAGE_TYPE_DUMMY,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
+ GNUNET_MQ_hd_var_size(data,
+ GNUNET_MESSAGE_TYPE_DUMMY,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_handler_end()
};
- long l = (long) cls;
+ long l = (long)cls;
struct CadetTestChannelWrapper *ch;
reconnect_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "reconnecting from line %ld\n",
- l);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "reconnecting from line %ld\n",
+ l);
if (NULL != outgoing_ch)
- {
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
- }
- ch = GNUNET_new (struct CadetTestChannelWrapper);
- outgoing_ch = GNUNET_CADET_channel_create (h1,
- ch,
- p_id[1],
- &port,
- NULL,
- &disconnect_handler,
- handlers);
+ {
+ GNUNET_CADET_channel_destroy(outgoing_ch);
+ outgoing_ch = NULL;
+ }
+ ch = GNUNET_new(struct CadetTestChannelWrapper);
+ outgoing_ch = GNUNET_CADET_channel_create(h1,
+ ch,
+ p_id[1],
+ &port,
+ NULL,
+ &disconnect_handler,
+ handlers);
ch->ch = outgoing_ch;
- send_test_message (outgoing_ch);
+ send_test_message(outgoing_ch);
}
/**
* @param channel Connection to the other end (henceforth invalid).
*/
static void
-disconnect_handler (void *cls,
- const struct GNUNET_CADET_Channel *channel)
+disconnect_handler(void *cls,
+ const struct GNUNET_CADET_Channel *channel)
{
struct CadetTestChannelWrapper *ch_w = cls;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Channel disconnected at %d\n",
- ok);
- GNUNET_assert (ch_w->ch == channel);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "Channel disconnected at %d\n",
+ ok);
+ GNUNET_assert(ch_w->ch == channel);
if (channel == incoming_ch)
- {
- ok++;
- incoming_ch = NULL;
- }
- else if (outgoing_ch == channel)
- {
- if (P2P_SIGNAL == test)
{
ok++;
+ incoming_ch = NULL;
+ }
+ else if (outgoing_ch == channel)
+ {
+ if (P2P_SIGNAL == test)
+ {
+ ok++;
+ }
+ outgoing_ch = NULL;
}
- outgoing_ch = NULL;
- }
else
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Unknown channel! %p\n",
- channel);
+ GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+ "Unknown channel! %p\n",
+ channel);
if (NULL != disconnect_task && REOPEN != test)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task =
- GNUNET_SCHEDULER_add_now (&gather_stats_and_exit,
- (void *) __LINE__);
- }
+ {
+ GNUNET_SCHEDULER_cancel(disconnect_task);
+ disconnect_task =
+ GNUNET_SCHEDULER_add_now(&gather_stats_and_exit,
+ (void *)__LINE__);
+ }
else if (NULL != reconnect_task && REOPEN == test)
- {
- GNUNET_SCHEDULER_cancel (reconnect_task);
- reconnect_task =
- GNUNET_SCHEDULER_add_now (&reconnect_op,
- (void *) __LINE__);
- }
- GNUNET_free (ch_w);
+ {
+ GNUNET_SCHEDULER_cancel(reconnect_task);
+ reconnect_task =
+ GNUNET_SCHEDULER_add_now(&reconnect_op,
+ (void *)__LINE__);
+ }
+ GNUNET_free(ch_w);
}
* @param line Line in the code the abort is requested from (__LINE__).
*/
static void
-abort_test (long line)
+abort_test(long line)
{
if (NULL != disconnect_task)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Aborting test from %ld\n",
- line);
- disconnect_task =
- GNUNET_SCHEDULER_add_now (&disconnect_cadet_peers,
- (void *) line);
- }
+ {
+ GNUNET_SCHEDULER_cancel(disconnect_task);
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Aborting test from %ld\n",
+ line);
+ disconnect_task =
+ GNUNET_SCHEDULER_add_now(&disconnect_cadet_peers,
+ (void *)line);
+ }
}
* @param channel Channel to send the message on.
*/
static void
-send_test_message (struct GNUNET_CADET_Channel *channel)
+send_test_message(struct GNUNET_CADET_Channel *channel)
{
struct GNUNET_MQ_Envelope *env;
struct GNUNET_MessageHeader *msg;
int payload;
int size;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending test message on channel %p\n",
- channel);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Sending test message on channel %p\n",
+ channel);
size = size_payload;
if (GNUNET_NO == initialized)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n");
- size += 1000;
- payload = data_sent;
- if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending INITIALIZER\n");
+ size += 1000;
+ payload = data_sent;
+ if (SPEED_ACK == test) // FIXME unify SPEED_ACK with an initializer
data_sent++;
- }
+ }
else if (SPEED == test || SPEED_ACK == test)
- {
- if (get_target_channel() == channel)
+ {
+ if (get_target_channel() == channel)
+ {
+ payload = ack_sent;
+ size += ack_sent;
+ ack_sent++;
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Sending ACK %u [%d bytes]\n",
+ payload, size);
+ }
+ else
+ {
+ payload = data_sent;
+ size += data_sent;
+ data_sent++;
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Sending DATA %u [%d bytes]\n",
+ data_sent, size);
+ }
+ }
+ else if (FORWARD == test)
{
payload = ack_sent;
- size += ack_sent;
- ack_sent++;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending ACK %u [%d bytes]\n",
- payload, size);
}
- else
+ else if (P2P_SIGNAL == test)
{
payload = data_sent;
- size += data_sent;
- data_sent++;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending DATA %u [%d bytes]\n",
- data_sent, size);
}
- }
- else if (FORWARD == test)
- {
- payload = ack_sent;
- }
- else if (P2P_SIGNAL == test)
- {
- payload = data_sent;
- }
else if (REOPEN == test)
- {
- payload = data_sent;
- data_sent++;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending DATA %u [%d bytes]\n",
- data_sent, size);
- }
+ {
+ payload = data_sent;
+ data_sent++;
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Sending DATA %u [%d bytes]\n",
+ data_sent, size);
+ }
else
- {
- GNUNET_assert (0);
- }
- env = GNUNET_MQ_msg_extra (msg, size, GNUNET_MESSAGE_TYPE_DUMMY);
-
- data = (uint32_t *) &msg[1];
- *data = htonl (payload);
- GNUNET_MQ_send (GNUNET_CADET_get_mq (channel), env);
+ {
+ GNUNET_assert(0);
+ }
+ env = GNUNET_MQ_msg_extra(msg, size, GNUNET_MESSAGE_TYPE_DUMMY);
+
+ data = (uint32_t *)&msg[1];
+ *data = htonl(payload);
+ GNUNET_MQ_send(GNUNET_CADET_get_mq(channel), env);
}
* @param cls Closure (unused).
*/
static void
-send_next_msg (void *cls)
+send_next_msg(void *cls)
{
struct GNUNET_CADET_Channel *channel;
send_next_msg_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending next message: %d\n",
- data_sent);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Sending next message: %d\n",
+ data_sent);
channel = GNUNET_YES == test_backwards ? incoming_ch : outgoing_ch;
- GNUNET_assert (NULL != channel);
- GNUNET_assert (SPEED == test);
- send_test_message (channel);
+ GNUNET_assert(NULL != channel);
+ GNUNET_assert(SPEED == test);
+ send_test_message(channel);
if (data_sent < total_packets)
- {
- /* SPEED test: Send all messages as soon as possible */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Scheduling message %d\n",
- data_sent + 1);
- send_next_msg_task =
- GNUNET_SCHEDULER_add_delayed (SEND_INTERVAL,
- &send_next_msg,
- NULL);
- }
+ {
+ /* SPEED test: Send all messages as soon as possible */
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Scheduling message %d\n",
+ data_sent + 1);
+ send_next_msg_task =
+ GNUNET_SCHEDULER_add_delayed(SEND_INTERVAL,
+ &send_next_msg,
+ NULL);
+ }
}
* @param line Code line number to log if a timeout occurs.
*/
static void
-reschedule_timeout_task (long line)
+reschedule_timeout_task(long line)
{
if ((ok % 10) == 0)
- {
- if (NULL != disconnect_task)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "reschedule timeout every 10 messages\n");
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &gather_stats_and_exit,
- (void *) line);
+ if (NULL != disconnect_task)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "reschedule timeout every 10 messages\n");
+ GNUNET_SCHEDULER_cancel(disconnect_task);
+ disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+ &gather_stats_and_exit,
+ (void *)line);
+ }
}
- }
}
* #GNUNET_SYSERR to close it (signal serious error).
*/
static int
-check_data (void *cls,
- const struct GNUNET_MessageHeader *message)
+check_data(void *cls,
+ const struct GNUNET_MessageHeader *message)
{
return GNUNET_OK; /* all is well-formed */
}
* @param message the actual message
*/
static void
-handle_data (void *cls,
- const struct GNUNET_MessageHeader *message)
+handle_data(void *cls,
+ const struct GNUNET_MessageHeader *message)
{
struct CadetTestChannelWrapper *ch = cls;
struct GNUNET_CADET_Channel *channel = ch->ch;
int *counter;
ok++;
- GNUNET_CADET_receive_done (channel);
- counter = get_target_channel () == channel ? &data_received : &ack_received;
+ GNUNET_CADET_receive_done(channel);
+ counter = get_target_channel() == channel ? &data_received : &ack_received;
- reschedule_timeout_task ((long) __LINE__);
+ reschedule_timeout_task((long)__LINE__);
if (channel == outgoing_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Root client got a message.\n");
- }
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "Root client got a message.\n");
+ }
else if (channel == incoming_ch)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Leaf client got a message.\n");
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Unknown channel %p.\n",
- channel);
- GNUNET_assert (0);
- }
-
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- " ok: (%d/%d)\n",
- ok,
- ok_goal);
- data = (uint32_t *) &message[1];
- payload = ntohl (*data);
- if (payload == *counter)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- " payload as expected: %u\n",
- payload);
- }
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "Leaf client got a message.\n");
+ }
else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- " payload %u, expected: %u\n",
- payload, *counter);
- }
-
- if (GNUNET_NO == initialized)
- {
- initialized = GNUNET_YES;
- start_time = GNUNET_TIME_absolute_get ();
- if (SPEED == test)
{
- GNUNET_assert (incoming_ch == channel);
- send_next_msg_task = GNUNET_SCHEDULER_add_now (&send_next_msg,
- NULL);
- return;
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Unknown channel %p.\n",
+ channel);
+ GNUNET_assert(0);
}
- }
- (*counter)++;
- if (get_target_channel () == channel) /* Got "data" */
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received data %u\n", data_received);
- if (SPEED != test || (ok_goal - 2) == ok)
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ " ok: (%d/%d)\n",
+ ok,
+ ok_goal);
+ data = (uint32_t *)&message[1];
+ payload = ntohl(*data);
+ if (payload == *counter)
{
- /* Send ACK */
- send_test_message (channel);
- return;
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ " payload as expected: %u\n",
+ payload);
}
- else
+ else
{
- if (data_received < total_packets)
- return;
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ " payload %u, expected: %u\n",
+ payload, *counter);
}
- }
- else /* Got "ack" */
- {
- if (SPEED_ACK == test || SPEED == test)
+
+ if (GNUNET_NO == initialized)
{
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received);
- /* Send more data */
- send_test_message (channel);
- if (ack_received < total_packets && SPEED != test)
- return;
- if (ok == 2 && SPEED == test)
- return;
- show_end_data ();
+ initialized = GNUNET_YES;
+ start_time = GNUNET_TIME_absolute_get();
+ if (SPEED == test)
+ {
+ GNUNET_assert(incoming_ch == channel);
+ send_next_msg_task = GNUNET_SCHEDULER_add_now(&send_next_msg,
+ NULL);
+ return;
+ }
}
- if (test == P2P_SIGNAL)
+
+ (*counter)++;
+ if (get_target_channel() == channel) /* Got "data" */
{
- GNUNET_CADET_channel_destroy (incoming_ch);
- incoming_ch = NULL;
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, " received data %u\n", data_received);
+ if (SPEED != test || (ok_goal - 2) == ok)
+ {
+ /* Send ACK */
+ send_test_message(channel);
+ return;
+ }
+ else
+ {
+ if (data_received < total_packets)
+ return;
+ }
}
- else
+ else /* Got "ack" */
{
- GNUNET_CADET_channel_destroy (outgoing_ch);
- outgoing_ch = NULL;
+ if (SPEED_ACK == test || SPEED == test)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, " received ack %u\n", ack_received);
+ /* Send more data */
+ send_test_message(channel);
+ if (ack_received < total_packets && SPEED != test)
+ return;
+ if (ok == 2 && SPEED == test)
+ return;
+ show_end_data();
+ }
+ if (test == P2P_SIGNAL)
+ {
+ GNUNET_CADET_channel_destroy(incoming_ch);
+ incoming_ch = NULL;
+ }
+ else
+ {
+ GNUNET_CADET_channel_destroy(outgoing_ch);
+ outgoing_ch = NULL;
+ }
}
- }
}
* received on the @a channel.
*/
static void *
-connect_handler (void *cls,
- struct GNUNET_CADET_Channel *channel,
- const struct GNUNET_PeerIdentity *source)
+connect_handler(void *cls,
+ struct GNUNET_CADET_Channel *channel,
+ const struct GNUNET_PeerIdentity *source)
{
struct CadetTestChannelWrapper *ch;
- long peer = (long) cls;
+ long peer = (long)cls;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Incoming channel from %s to %ld: %p\n",
- GNUNET_i2s (source),
- peer,
- channel);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "Incoming channel from %s to %ld: %p\n",
+ GNUNET_i2s(source),
+ peer,
+ channel);
ok++;
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- " ok: %d\n",
- ok);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ " ok: %d\n",
+ ok);
if (peer == peers_requested - 1)
- {
- if (NULL != incoming_ch)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Duplicate incoming channel for client %lu\n",
- (long) cls);
- GNUNET_assert (0);
+ if (NULL != incoming_ch)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "Duplicate incoming channel for client %lu\n",
+ (long)cls);
+ GNUNET_assert(0);
+ }
+ incoming_ch = channel;
}
- incoming_ch = channel;
- }
else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Incoming channel for unexpected peer #%lu\n",
- (long) cls);
- GNUNET_assert (0);
- }
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+ "Incoming channel for unexpected peer #%lu\n",
+ (long)cls);
+ GNUNET_assert(0);
+ }
if (NULL != disconnect_task && REOPEN != test)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &gather_stats_and_exit,
- (void *) __LINE__);
- }
+ {
+ GNUNET_SCHEDULER_cancel(disconnect_task);
+ disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+ &gather_stats_and_exit,
+ (void *)__LINE__);
+ }
else if ((NULL != disconnect_task) && (REOPEN == test))
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_delayed (
- GNUNET_TIME_relative_multiply (short_time, 2),
+ {
+ GNUNET_SCHEDULER_cancel(disconnect_task);
+ disconnect_task = GNUNET_SCHEDULER_add_delayed(
+ GNUNET_TIME_relative_multiply(short_time, 2),
&gather_stats_and_exit,
- (void *) __LINE__);
- }
+ (void *)__LINE__);
+ }
if ((NULL != reconnect_task) && (REOPEN == test))
- {
- GNUNET_SCHEDULER_cancel (reconnect_task);
- reconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &reconnect_op,
- (void *) __LINE__);
- }
+ {
+ GNUNET_SCHEDULER_cancel(reconnect_task);
+ reconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+ &reconnect_op,
+ (void *)__LINE__);
+ }
/* TODO: cannot return channel as-is, in order to unify the data handlers */
- ch = GNUNET_new (struct CadetTestChannelWrapper);
+ ch = GNUNET_new(struct CadetTestChannelWrapper);
ch->ch = channel;
return ch;
* @param cls Closure (unused).
*/
static void
-start_test (void *cls)
+start_test(void *cls)
{
struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (data,
- GNUNET_MESSAGE_TYPE_DUMMY,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
+ GNUNET_MQ_hd_var_size(data,
+ GNUNET_MESSAGE_TYPE_DUMMY,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_handler_end()
};
struct CadetTestChannelWrapper *ch;
test_task = NULL;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "start_test: %s\n", test_name);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "start_test: %s\n", test_name);
if (NULL != disconnect_task)
- {
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = NULL;
- }
+ {
+ GNUNET_SCHEDULER_cancel(disconnect_task);
+ disconnect_task = NULL;
+ }
if (SPEED_REL == test)
- {
- test = SPEED;
- }
-
- ch = GNUNET_new (struct CadetTestChannelWrapper);
- outgoing_ch = GNUNET_CADET_channel_create (h1,
- ch,
- p_id[1],
- &port,
- NULL,
- &disconnect_handler,
- handlers);
+ {
+ test = SPEED;
+ }
+
+ ch = GNUNET_new(struct CadetTestChannelWrapper);
+ outgoing_ch = GNUNET_CADET_channel_create(h1,
+ ch,
+ p_id[1],
+ &port,
+ NULL,
+ &disconnect_handler,
+ handlers);
ch->ch = outgoing_ch;
- disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &gather_stats_and_exit,
- (void *) __LINE__);
+ disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+ &gather_stats_and_exit,
+ (void *)__LINE__);
if (KEEPALIVE == test)
return; /* Don't send any data. */
data_sent = 0;
ack_received = 0;
ack_sent = 0;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending data initializer on channel %p...\n",
- outgoing_ch);
- send_test_message (outgoing_ch);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Sending data initializer on channel %p...\n",
+ outgoing_ch);
+ send_test_message(outgoing_ch);
if (REOPEN == test)
- {
- reconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &reconnect_op,
- (void *) __LINE__);
- GNUNET_SCHEDULER_cancel (disconnect_task);
- disconnect_task = GNUNET_SCHEDULER_add_delayed (
- GNUNET_TIME_relative_multiply (short_time, 2),
+ {
+ reconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+ &reconnect_op,
+ (void *)__LINE__);
+ GNUNET_SCHEDULER_cancel(disconnect_task);
+ disconnect_task = GNUNET_SCHEDULER_add_delayed(
+ GNUNET_TIME_relative_multiply(short_time, 2),
&gather_stats_and_exit,
- (void *) __LINE__);
- }
-
+ (void *)__LINE__);
+ }
}
* NULL if the operation is successfull
*/
static void
-pi_cb (void *cls,
- struct GNUNET_TESTBED_Operation *op,
- const struct GNUNET_TESTBED_PeerInformation *pinfo,
- const char *emsg)
+pi_cb(void *cls,
+ struct GNUNET_TESTBED_Operation *op,
+ const struct GNUNET_TESTBED_PeerInformation *pinfo,
+ const char *emsg)
{
- long i = (long) cls;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ID callback for %ld\n",
- i);
- if ( (NULL == pinfo) ||
- (NULL != emsg) )
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "pi_cb: %s\n",
- emsg);
- abort_test (__LINE__);
- return;
- }
+ long i = (long)cls;
+
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "ID callback for %ld\n",
+ i);
+ if ((NULL == pinfo) ||
+ (NULL != emsg))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "pi_cb: %s\n",
+ emsg);
+ abort_test(__LINE__);
+ return;
+ }
p_id[i] = pinfo->result.id;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "id: %s\n",
- GNUNET_i2s (p_id[i]));
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "id: %s\n",
+ GNUNET_i2s(p_id[i]));
p_ids++;
if (p_ids < 2)
return;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Got all IDs, starting test\n");
- test_task = GNUNET_SCHEDULER_add_now (&start_test, NULL);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Got all IDs, starting test\n");
+ test_task = GNUNET_SCHEDULER_add_now(&start_test, NULL);
}
* @param cadets Handle to each of the CADETs of the peers.
*/
static void
-tmain (void *cls,
- struct GNUNET_CADET_TEST_Context *ctx,
- unsigned int num_peers,
- struct GNUNET_TESTBED_Peer **peers,
- struct GNUNET_CADET_Handle **cadets)
+tmain(void *cls,
+ struct GNUNET_CADET_TEST_Context *ctx,
+ unsigned int num_peers,
+ struct GNUNET_TESTBED_Peer **peers,
+ struct GNUNET_CADET_Handle **cadets)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test main\n");
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "test main\n");
ok = 0;
test_ctx = ctx;
peers_running = num_peers;
- GNUNET_assert (peers_running == peers_requested);
+ GNUNET_assert(peers_running == peers_requested);
testbed_peers = peers;
h1 = cadets[0];
h2 = cadets[num_peers - 1];
- disconnect_task = GNUNET_SCHEDULER_add_delayed (short_time,
- &disconnect_cadet_peers,
- (void *) __LINE__);
- GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
- NULL);
- t_op[0] = GNUNET_TESTBED_peer_get_information (peers[0],
- GNUNET_TESTBED_PIT_IDENTITY,
- &pi_cb,
- (void *) 0L);
- t_op[1] = GNUNET_TESTBED_peer_get_information (peers[num_peers - 1],
- GNUNET_TESTBED_PIT_IDENTITY,
- &pi_cb,
- (void *) 1L);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "requested peer ids\n");
+ disconnect_task = GNUNET_SCHEDULER_add_delayed(short_time,
+ &disconnect_cadet_peers,
+ (void *)__LINE__);
+ GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
+ NULL);
+ t_op[0] = GNUNET_TESTBED_peer_get_information(peers[0],
+ GNUNET_TESTBED_PIT_IDENTITY,
+ &pi_cb,
+ (void *)0L);
+ t_op[1] = GNUNET_TESTBED_peer_get_information(peers[num_peers - 1],
+ GNUNET_TESTBED_PIT_IDENTITY,
+ &pi_cb,
+ (void *)1L);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "requested peer ids\n");
}
* Main: start test
*/
int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
{
static const struct GNUNET_HashCode *ports[2];
struct GNUNET_MQ_MessageHandler handlers[] = {
- GNUNET_MQ_hd_var_size (data,
- GNUNET_MESSAGE_TYPE_DUMMY,
- struct GNUNET_MessageHeader,
- NULL),
- GNUNET_MQ_handler_end ()
+ GNUNET_MQ_hd_var_size(data,
+ GNUNET_MESSAGE_TYPE_DUMMY,
+ struct GNUNET_MessageHeader,
+ NULL),
+ GNUNET_MQ_handler_end()
};
const char *config_file;
char port_id[] = "test port";
struct GNUNET_GETOPT_CommandLineOption options[] = {
- GNUNET_GETOPT_option_relative_time ('t',
- "time",
- "short_time",
- gettext_noop ("set short timeout"),
- &short_time),
- GNUNET_GETOPT_option_uint ('m',
- "messages",
- "NUM_MESSAGES",
- gettext_noop ("set number of messages to send"),
- &total_packets),
+ GNUNET_GETOPT_option_relative_time('t',
+ "time",
+ "short_time",
+ gettext_noop("set short timeout"),
+ &short_time),
+ GNUNET_GETOPT_option_uint('m',
+ "messages",
+ "NUM_MESSAGES",
+ gettext_noop("set number of messages to send"),
+ &total_packets),
GNUNET_GETOPT_OPTION_END
};
initialized = GNUNET_NO;
- GNUNET_log_setup ("test", "DEBUG", NULL);
+ GNUNET_log_setup("test", "DEBUG", NULL);
total_packets = TOTAL_PACKETS;
short_time = SHORT_TIME;
- if (-1 == GNUNET_GETOPT_run (argv[0], options, argc, argv))
- {
- fprintf (stderr, "test failed: problem with CLI parameters\n");
- exit (1);
- }
+ if (-1 == GNUNET_GETOPT_run(argv[0], options, argc, argv))
+ {
+ fprintf(stderr, "test failed: problem with CLI parameters\n");
+ exit(1);
+ }
config_file = "test_cadet.conf";
- GNUNET_CRYPTO_hash (port_id, sizeof (port_id), &port);
+ GNUNET_CRYPTO_hash(port_id, sizeof(port_id), &port);
/* Find out requested size */
- if (strstr (argv[0], "_2_") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DIRECT CONNECTIONs\n");
- peers_requested = 2;
- }
- else if (strstr (argv[0], "_5_") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "5 PEER LINE\n");
- peers_requested = 5;
- }
- else if (strstr (argv[0], "_6_") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "6 PEER LINE\n");
- peers_requested = 6;
- }
+ if (strstr(argv[0], "_2_") != NULL)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DIRECT CONNECTIONs\n");
+ peers_requested = 2;
+ }
+ else if (strstr(argv[0], "_5_") != NULL)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "5 PEER LINE\n");
+ peers_requested = 5;
+ }
+ else if (strstr(argv[0], "_6_") != NULL)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "6 PEER LINE\n");
+ peers_requested = 6;
+ }
else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "SIZE UNKNOWN, USING 2\n");
- peers_requested = 2;
- }
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "SIZE UNKNOWN, USING 2\n");
+ peers_requested = 2;
+ }
/* Find out requested test */
- if (strstr (argv[0], "_forward") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "FORWARD\n");
- test = FORWARD;
- test_name = "unicast";
- ok_goal = 4;
- }
- else if (strstr (argv[0], "_signal") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SIGNAL\n");
- test = P2P_SIGNAL;
- test_name = "signal";
- ok_goal = 4;
- }
- else if (strstr (argv[0], "_speed_ack") != NULL)
- {
- /* Test is supposed to generate the following callbacks:
- * 1 incoming channel (@dest)
- * total_packets received data packet (@dest)
- * total_packets received data packet (@orig)
- * 1 received channel destroy (@dest) FIXME #5818
- */
- ok_goal = total_packets * 2 + 2;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED_ACK\n");
- test = SPEED_ACK;
- test_name = "speed ack";
- }
- else if (strstr (argv[0], "_speed") != NULL)
- {
- /* Test is supposed to generate the following callbacks:
- * 1 incoming channel (@dest)
- * 1 initial packet (@dest)
- * total_packets received data packet (@dest)
- * 1 received data packet (@orig)
- * 1 received channel destroy (@dest) FIXME #5818
- */
- ok_goal = total_packets + 4;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED\n");
- if (strstr (argv[0], "_reliable") != NULL)
+ if (strstr(argv[0], "_forward") != NULL)
{
- test = SPEED_REL;
- test_name = "speed reliable";
- config_file = "test_cadet_drop.conf";
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "FORWARD\n");
+ test = FORWARD;
+ test_name = "unicast";
+ ok_goal = 4;
}
- else
+ else if (strstr(argv[0], "_signal") != NULL)
{
- test = SPEED;
- test_name = "speed";
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "SIGNAL\n");
+ test = P2P_SIGNAL;
+ test_name = "signal";
+ ok_goal = 4;
+ }
+ else if (strstr(argv[0], "_speed_ack") != NULL)
+ {
+ /* Test is supposed to generate the following callbacks:
+ * 1 incoming channel (@dest)
+ * total_packets received data packet (@dest)
+ * total_packets received data packet (@orig)
+ * 1 received channel destroy (@dest) FIXME #5818
+ */
+ ok_goal = total_packets * 2 + 2;
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "SPEED_ACK\n");
+ test = SPEED_ACK;
+ test_name = "speed ack";
+ }
+ else if (strstr(argv[0], "_speed") != NULL)
+ {
+ /* Test is supposed to generate the following callbacks:
+ * 1 incoming channel (@dest)
+ * 1 initial packet (@dest)
+ * total_packets received data packet (@dest)
+ * 1 received data packet (@orig)
+ * 1 received channel destroy (@dest) FIXME #5818
+ */
+ ok_goal = total_packets + 4;
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "SPEED\n");
+ if (strstr(argv[0], "_reliable") != NULL)
+ {
+ test = SPEED_REL;
+ test_name = "speed reliable";
+ config_file = "test_cadet_drop.conf";
+ }
+ else
+ {
+ test = SPEED;
+ test_name = "speed";
+ }
+ }
+ else if (strstr(argv[0], "_keepalive") != NULL)
+ {
+ test = KEEPALIVE;
+ test_name = "keepalive";
+ /* Test is supposed to generate the following callbacks:
+ * 1 incoming channel (@dest)
+ * [wait]
+ * 1 received channel destroy (@dest) FIXME #5818
+ */
+ ok_goal = 1;
+ }
+ else if (strstr(argv[0], "_reopen") != NULL)
+ {
+ test = REOPEN;
+ test_name = "reopen";
+ ///* Test is supposed to generate the following callbacks:
+ // * 1 incoming channel (@dest)
+ // * [wait]
+ // * 1 received channel destroy (@dest) FIXME #5818
+ // */
+ ok_goal = 6;
}
- }
- else if (strstr (argv[0], "_keepalive") != NULL)
- {
- test = KEEPALIVE;
- test_name = "keepalive";
- /* Test is supposed to generate the following callbacks:
- * 1 incoming channel (@dest)
- * [wait]
- * 1 received channel destroy (@dest) FIXME #5818
- */
- ok_goal = 1;
- }
- else if (strstr (argv[0], "_reopen") != NULL)
- {
- test = REOPEN;
- test_name = "reopen";
- ///* Test is supposed to generate the following callbacks:
- // * 1 incoming channel (@dest)
- // * [wait]
- // * 1 received channel destroy (@dest) FIXME #5818
- // */
- ok_goal = 6;
- }
else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "UNKNOWN\n");
- test = SETUP;
- ok_goal = 0;
- }
-
- if (strstr (argv[0], "backwards") != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "BACKWARDS (LEAF TO ROOT)\n");
- test_backwards = GNUNET_YES;
- GNUNET_asprintf (&test_name, "backwards %s", test_name);
- }
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "UNKNOWN\n");
+ test = SETUP;
+ ok_goal = 0;
+ }
+
+ if (strstr(argv[0], "backwards") != NULL)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "BACKWARDS (LEAF TO ROOT)\n");
+ test_backwards = GNUNET_YES;
+ GNUNET_asprintf(&test_name, "backwards %s", test_name);
+ }
p_ids = 0;
ports[0] = &port;
ports[1] = NULL;
- GNUNET_CADET_TEST_ruN ("test_cadet_small",
- config_file,
- peers_requested,
- &tmain,
- NULL, /* tmain cls */
- &connect_handler,
- NULL,
- &disconnect_handler,
- handlers,
- ports);
- if (NULL != strstr (argv[0], "_reliable"))
+ GNUNET_CADET_TEST_ruN("test_cadet_small",
+ config_file,
+ peers_requested,
+ &tmain,
+ NULL, /* tmain cls */
+ &connect_handler,
+ NULL,
+ &disconnect_handler,
+ handlers,
+ ports);
+ if (NULL != strstr(argv[0], "_reliable"))
msg_dropped = 0; /* dropped should be retransmitted */
if (ok_goal > ok - msg_dropped)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "FAILED! (%d/%d)\n", ok, ok_goal);
- return 1;
- }
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "success\n");
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "FAILED! (%d/%d)\n", ok, ok_goal);
+ return 1;
+ }
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "success\n");
return 0;
}
projects / oweals / gnunet.git / blobdiff