projects / oweals / gnunet.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
- verboser log, faster start
[oweals/gnunet.git] / src / testbed / test_testbed_api_controllerlink.c
diff --git a/src/testbed/test_testbed_api_controllerlink.c b/src/testbed/test_testbed_api_controllerlink.c
index 1d0a3652ce9257ad2dac19896ca377f160247be9..f0ce4daa5141721955a30279995940db4dfea20c 100644 (file)
--- a/src/testbed/test_testbed_api_controllerlink.c
+++ b/src/testbed/test_testbed_api_controllerlink.c
@@ -266,6 +266,20 @@ uint64_t event_mask;
  */
 static enum Stage result;
 
+/**
+ * shortcut to exit during failure
+ */
+#define FAIL_TEST(cond) do {                                    \
+    if (!(cond)) {                                              \
+      GNUNET_break(0);                                          \
+      if (GNUNET_SCHEDULER_NO_TASK != abort_task)               \
+        GNUNET_SCHEDULER_cancel (abort_task);                   \
+      abort_task = GNUNET_SCHEDULER_NO_TASK;                    \
+      GNUNET_SCHEDULER_add_now (do_shutdown, NULL);             \
+      return;                                                   \
+    }                                                          \
+  } while (0)
+
 
 /**
  * Shutdown nicely
@@ -315,7 +329,7 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n");
+  LOG (GNUNET_ERROR_TYPE_WARNING, "Aborting\n");
   abort_task = GNUNET_SCHEDULER_NO_TASK;
   do_shutdown (cls, tc);
 }
@@ -350,14 +364,14 @@ delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   {
   case SLAVE2_PEER_CREATE_SUCCESS:
     op = GNUNET_TESTBED_peer_stop (slave1_peer, NULL, NULL);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   case MASTER_SLAVE2_PEERS_CONNECTED:
     op = GNUNET_TESTBED_peer_stop (slave2_peer, NULL, NULL);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   default:
-    GNUNET_assert (0);
+    FAIL_TEST (0);
   }
 }
 
@@ -374,8 +388,8 @@ delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
 {
-  GNUNET_assert (NULL != peer);
-  GNUNET_assert (NULL == emsg);
+  FAIL_TEST (NULL != peer);
+  FAIL_TEST (NULL == emsg);
   switch (result)
   {
   case MASTER_STARTED:
@@ -401,9 +415,9 @@ peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
                                       NULL);
     break;
   default:
-    GNUNET_assert (0);
+    FAIL_TEST (0);
   }
-  GNUNET_assert (NULL != op);
+  FAIL_TEST (NULL != op);
 }
 
 
@@ -416,12 +430,12 @@ peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
 static void
 check_operation_success (const struct GNUNET_TESTBED_EventInformation *event)
 {
-  GNUNET_assert (NULL != event);
-  GNUNET_assert (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
-  GNUNET_assert (event->details.operation_finished.operation == op);
-  GNUNET_assert (NULL == event->details.operation_finished.op_cls);
-  GNUNET_assert (NULL == event->details.operation_finished.emsg);
-  GNUNET_assert (NULL == event->details.operation_finished.generic);
+  FAIL_TEST (NULL != event);
+  FAIL_TEST (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
+  FAIL_TEST (event->details.operation_finished.operation == op);
+  FAIL_TEST (NULL == event->details.operation_finished.op_cls);
+  FAIL_TEST (NULL == event->details.operation_finished.emsg);
+  FAIL_TEST (NULL == event->details.operation_finished.generic);
 }
 
 
@@ -452,60 +466,60 @@ controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
     GNUNET_TESTBED_operation_done (op);
     op = NULL;
     result = SLAVE1_LINK_SUCCESS;
-    GNUNET_assert (NULL != slave2);
-    GNUNET_assert (NULL != slave);
+    FAIL_TEST (NULL != slave2);
+    FAIL_TEST (NULL != slave);
     op = GNUNET_TESTBED_peer_create (mc, slave, cfg, peer_create_cb, NULL);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   case SLAVE1_PEER_START_SUCCESS:
     check_operation_success (event);
     GNUNET_TESTBED_operation_done (op);
     result = SLAVE2_LINK_SUCCESS;
     op = GNUNET_TESTBED_peer_create (mc, slave2, cfg, peer_create_cb, NULL);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   case MASTER_PEER_CREATE_SUCCESS:
-    GNUNET_assert (GNUNET_TESTBED_ET_PEER_START == event->type);
-    GNUNET_assert (event->details.peer_start.host == host);
-    GNUNET_assert (event->details.peer_start.peer == master_peer);
+    FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type);
+    FAIL_TEST (event->details.peer_start.host == host);
+    FAIL_TEST (event->details.peer_start.peer == master_peer);
     GNUNET_TESTBED_operation_done (op);
     result = MASTER_PEER_START_SUCCESS;
     slave = GNUNET_TESTBED_host_create_with_id (1, "127.0.0.1", NULL, 0);
-    GNUNET_assert (NULL != slave);
+    FAIL_TEST (NULL != slave);
     rh = GNUNET_TESTBED_register_host (mc, slave, &registration_cont, NULL);
-    GNUNET_assert (NULL != rh);
+    FAIL_TEST (NULL != rh);
     break;
   case SLAVE1_PEER_CREATE_SUCCESS:
-    GNUNET_assert (GNUNET_TESTBED_ET_PEER_START == event->type);
-    GNUNET_assert (event->details.peer_start.host == slave);
-    GNUNET_assert (event->details.peer_start.peer == slave1_peer);
+    FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type);
+    FAIL_TEST (event->details.peer_start.host == slave);
+    FAIL_TEST (event->details.peer_start.peer == slave1_peer);
     GNUNET_TESTBED_operation_done (op);
     result = SLAVE1_PEER_START_SUCCESS;
     op = GNUNET_TESTBED_controller_link (NULL, mc, slave2, slave, cfg,
                                          GNUNET_YES);
     break;
   case SLAVE2_PEER_CREATE_SUCCESS:
-    GNUNET_assert (GNUNET_TESTBED_ET_PEER_STOP == event->type);
-    GNUNET_assert (event->details.peer_stop.peer == slave1_peer);
+    FAIL_TEST (GNUNET_TESTBED_ET_PEER_STOP == event->type);
+    FAIL_TEST (event->details.peer_stop.peer == slave1_peer);
     GNUNET_TESTBED_operation_done (op);
     result = SLAVE1_PEER_STOP_SUCCESS;
     op = GNUNET_TESTBED_peer_start (NULL, slave2_peer, NULL, NULL);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   case SLAVE1_PEER_STOP_SUCCESS:
-    GNUNET_assert (GNUNET_TESTBED_ET_PEER_START == event->type);
-    GNUNET_assert (event->details.peer_start.host == slave2);
-    GNUNET_assert (event->details.peer_start.peer == slave2_peer);
+    FAIL_TEST (GNUNET_TESTBED_ET_PEER_START == event->type);
+    FAIL_TEST (event->details.peer_start.host == slave2);
+    FAIL_TEST (event->details.peer_start.peer == slave2_peer);
     GNUNET_TESTBED_operation_done (op);
     result = SLAVE2_PEER_START_SUCCESS;
     op = GNUNET_TESTBED_overlay_connect (mc, NULL, NULL, master_peer,
                                          slave2_peer);
     break;
   case SLAVE2_PEER_START_SUCCESS:
-    GNUNET_assert (NULL != event);
-    GNUNET_assert (GNUNET_TESTBED_ET_CONNECT == event->type);
-    GNUNET_assert (event->details.peer_connect.peer1 == master_peer);
-    GNUNET_assert (event->details.peer_connect.peer2 == slave2_peer);
+    FAIL_TEST (NULL != event);
+    FAIL_TEST (GNUNET_TESTBED_ET_CONNECT == event->type);
+    FAIL_TEST (event->details.peer_connect.peer1 == master_peer);
+    FAIL_TEST (event->details.peer_connect.peer2 == slave2_peer);
     result = MASTER_SLAVE2_PEERS_CONNECTED;
     GNUNET_TESTBED_operation_done (op);
     op = NULL;
@@ -515,19 +529,19 @@ controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
                                       NULL);
     break;
   case MASTER_SLAVE2_PEERS_CONNECTED:
-    GNUNET_assert (GNUNET_TESTBED_ET_PEER_STOP == event->type);
-    GNUNET_assert (event->details.peer_stop.peer == slave2_peer);
+    FAIL_TEST (GNUNET_TESTBED_ET_PEER_STOP == event->type);
+    FAIL_TEST (event->details.peer_stop.peer == slave2_peer);
     GNUNET_TESTBED_operation_done (op);
     result = SLAVE2_PEER_STOP_SUCCESS;
     op = GNUNET_TESTBED_peer_destroy (slave1_peer);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   case SLAVE2_PEER_STOP_SUCCESS:
     check_operation_success (event);
     GNUNET_TESTBED_operation_done (op);
     result = SLAVE1_PEER_DESTROY_SUCCESS;
     op = GNUNET_TESTBED_peer_destroy (slave2_peer);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   case SLAVE1_PEER_DESTROY_SUCCESS:
     check_operation_success (event);
@@ -543,14 +557,14 @@ controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
     op = NULL;
     result = SLAVE3_STARTED;
     op = GNUNET_TESTBED_get_slave_config (NULL, mc, slave3);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   case SLAVE3_STARTED:
-    GNUNET_assert (NULL != event);
-    GNUNET_assert (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
-    GNUNET_assert (event->details.operation_finished.operation == op);
-    GNUNET_assert (NULL == event->details.operation_finished.op_cls);
-    GNUNET_assert (NULL == event->details.operation_finished.emsg);
+    FAIL_TEST (NULL != event);
+    FAIL_TEST (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
+    FAIL_TEST (event->details.operation_finished.operation == op);
+    FAIL_TEST (NULL == event->details.operation_finished.op_cls);
+    FAIL_TEST (NULL == event->details.operation_finished.emsg);
     cfg3 = GNUNET_CONFIGURATION_dup (event->details.operation_finished.generic);
     GNUNET_TESTBED_operation_done (op);
     result = SLAVE3_GET_CONFIG_SUCCESS;
@@ -572,7 +586,7 @@ controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
                                   NULL);
     break;
   default:
-    GNUNET_assert (0);
+    FAIL_TEST (0);
   }
 }
 
@@ -590,31 +604,31 @@ registration_cont (void *cls, const char *emsg)
   switch (result)
   {
   case MASTER_PEER_START_SUCCESS:
-    GNUNET_assert (NULL == emsg);
-    GNUNET_assert (NULL != mc);
+    FAIL_TEST (NULL == emsg);
+    FAIL_TEST (NULL != mc);
     result = SLAVE1_REGISTERED;
     slave2 = GNUNET_TESTBED_host_create_with_id (2, "127.0.0.1", NULL, 0);
-    GNUNET_assert (NULL != slave2);
+    FAIL_TEST (NULL != slave2);
     rh = GNUNET_TESTBED_register_host (mc, slave2, &registration_cont, NULL);
-    GNUNET_assert (NULL != rh);
+    FAIL_TEST (NULL != rh);
     break;
   case SLAVE1_REGISTERED:
-    GNUNET_assert (NULL == emsg);
-    GNUNET_assert (NULL != mc);
+    FAIL_TEST (NULL == emsg);
+    FAIL_TEST (NULL != mc);
     result = SLAVE2_REGISTERED;
-    GNUNET_assert (NULL != cfg);
+    FAIL_TEST (NULL != cfg);
     op = GNUNET_TESTBED_controller_link (NULL, mc, slave, NULL, cfg,
                                          GNUNET_YES);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   case SLAVE2_PEER_DESTROY_SUCCESS:
-    GNUNET_assert (NULL == emsg);
-    GNUNET_assert (NULL != mc);
-    GNUNET_assert (NULL == op);
+    FAIL_TEST (NULL == emsg);
+    FAIL_TEST (NULL != mc);
+    FAIL_TEST (NULL == op);
     result = SLAVE3_REGISTERED;
     op = GNUNET_TESTBED_controller_link (NULL, mc, slave3, NULL, cfg,
                                          GNUNET_YES);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   default:
     GNUNET_break (0);
@@ -638,7 +652,7 @@ status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *config,
   switch (result)
   {
   case INIT:
-    GNUNET_assert (GNUNET_OK == status);
+    FAIL_TEST (GNUNET_OK == status);
     event_mask = 0;
     event_mask |= (1L << GNUNET_TESTBED_ET_PEER_START);
     event_mask |= (1L << GNUNET_TESTBED_ET_PEER_STOP);
@@ -646,10 +660,10 @@ status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *config,
     event_mask |= (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED);
     mc = GNUNET_TESTBED_controller_connect (config, host, event_mask,
                                             &controller_cb, NULL);
-    GNUNET_assert (NULL != mc);
+    FAIL_TEST (NULL != mc);
     result = MASTER_STARTED;
     op = GNUNET_TESTBED_peer_create (mc, host, cfg, peer_create_cb, NULL);
-    GNUNET_assert (NULL != op);
+    FAIL_TEST (NULL != op);
     break;
   default:
     GNUNET_break (0);
@@ -704,7 +718,7 @@ run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *config)
 {
   host = GNUNET_TESTBED_host_create (NULL, NULL, 0);
-  GNUNET_assert (NULL != host);
+  FAIL_TEST (NULL != host);
   if (NULL ==
       (hc_handle =
        GNUNET_TESTBED_is_host_habitable (host, config, &host_habitable_cb,
Unnamed repository; edit this file 'description' to name the repository.