X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fpsyc%2Ftest_psyc.c;h=03a1890b1fa160256b24967f4545170ce2288351;hb=2105059516320800eaa8fff1196b58f29a50ba7c;hp=4aae5e122b4f145b86f047e6bf5800d5ee880f4e;hpb=23f117ce9756b2fb898bba5cb3a1f638333c23d9;p=oweals%2Fgnunet.git

diff --git a/src/psyc/test_psyc.c b/src/psyc/test_psyc.c
index 4aae5e122..03a1890b1 100644
--- a/src/psyc/test_psyc.c
+++ b/src/psyc/test_psyc.c
@@ -34,35 +34,33 @@
 #include "gnunet_testing_lib.h"
 #include "gnunet_psyc_util_lib.h"
 #include "gnunet_psyc_service.h"
-#include "gnunet_core_service.h"
 
 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
 
 /**
  * Return value from 'main'.
  */
-int res;
+static int res;
 
-const struct GNUNET_CONFIGURATION_Handle *cfg;
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
-struct GNUNET_CORE_Handle *core;
-struct GNUNET_PeerIdentity this_peer;
+static struct GNUNET_PeerIdentity this_peer;
 
 /**
  * Handle for task for timeout termination.
  */
-struct GNUNET_SCHEDULER_Task * end_badly_task;
+static struct GNUNET_SCHEDULER_Task * end_badly_task;
 
-struct GNUNET_PSYC_Master *mst;
-struct GNUNET_PSYC_Slave *slv;
+static struct GNUNET_PSYC_Master *mst;
+static struct GNUNET_PSYC_Slave *slv;
 
-struct GNUNET_PSYC_Channel *mst_chn, *slv_chn;
+static struct GNUNET_PSYC_Channel *mst_chn, *slv_chn;
 
-struct GNUNET_CRYPTO_EddsaPrivateKey *channel_key;
-struct GNUNET_CRYPTO_EcdsaPrivateKey *slave_key;
+static struct GNUNET_CRYPTO_EddsaPrivateKey *channel_key;
+static struct GNUNET_CRYPTO_EcdsaPrivateKey *slave_key;
 
-struct GNUNET_CRYPTO_EddsaPublicKey channel_pub_key;
-struct GNUNET_CRYPTO_EcdsaPublicKey slave_pub_key;
+static struct GNUNET_CRYPTO_EddsaPublicKey channel_pub_key;
+static struct GNUNET_CRYPTO_EcdsaPublicKey slave_pub_key;
 
 struct TransmitClosure
 {
@@ -79,9 +77,9 @@ struct TransmitClosure
   uint8_t n;
 };
 
-struct TransmitClosure *tmit;
+static struct TransmitClosure *tmit;
 
-uint8_t join_req_count, end_count;
+static uint8_t join_req_count, end_count;
 
 enum
 {
@@ -104,14 +102,15 @@ enum
 } test;
 
 
-void
+static void
 master_transmit ();
 
-void
+static void
 master_history_replay_latest ();
 
 
-void master_stopped (void *cls)
+static void
+master_stopped (void *cls)
 {
   if (NULL != tmit)
   {
@@ -122,7 +121,9 @@ void master_stopped (void *cls)
   GNUNET_SCHEDULER_shutdown ();
 }
 
-void slave_parted (void *cls)
+
+static void
+slave_parted (void *cls)
 {
   if (NULL != mst)
   {
@@ -133,17 +134,13 @@ void slave_parted (void *cls)
     master_stopped (NULL);
 }
 
+
 /**
  * Clean up all resources used.
  */
-void
+static void
 cleanup ()
 {
-  if (NULL != core)
-  {
-    GNUNET_CORE_disconnect (core);
-    core = NULL;
-  }
   if (NULL != slv)
   {
     GNUNET_PSYC_slave_part (slv, GNUNET_NO, &slave_parted, NULL);
@@ -158,10 +155,9 @@ cleanup ()
  * Terminate the test case (failure).
  *
  * @param cls NULL
- * @param tc scheduler context
  */
-void
-end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+end_badly (void *cls)
 {
   res = 1;
   cleanup ();
@@ -173,10 +169,9 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * Terminate the test case (success).
  *
  * @param cls NULL
- * @param tc scheduler context
  */
-void
-end_normally (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+end_normally (void *cls)
 {
   res = 0;
   cleanup ();
@@ -187,10 +182,10 @@ end_normally (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 /**
  * Finish the test case (successfully).
  */
-void
+static void
 end ()
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending tests.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Ending tests.\n");
 
   if (end_badly_task != NULL)
   {
@@ -202,11 +197,11 @@ end ()
 }
 
 
-void
+static void
 master_message_cb (void *cls, const struct GNUNET_PSYC_MessageHeader *msg)
 {
   GNUNET_assert (NULL != msg);
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Test #%d: Master got PSYC message fragment of size %u "
               "belonging to message ID %" PRIu64 " with flags %x\n",
               test, ntohs (msg->header.size),
@@ -215,7 +210,7 @@ master_message_cb (void *cls, const struct GNUNET_PSYC_MessageHeader *msg)
 }
 
 
-void
+static void
 master_message_part_cb (void *cls, const struct GNUNET_PSYC_MessageHeader *msg,
                         const struct GNUNET_MessageHeader *pmsg)
 {
@@ -227,7 +222,7 @@ master_message_part_cb (void *cls, const struct GNUNET_PSYC_MessageHeader *msg,
   uint16_t type = ntohs (pmsg->type);
   uint16_t size = ntohs (pmsg->size);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Test #%d: Master got message part of type %u and size %u "
               "belonging to message ID %" PRIu64 " with flags %x\n",
               test, type, size, message_id, flags);
@@ -272,11 +267,11 @@ master_message_part_cb (void *cls, const struct GNUNET_PSYC_MessageHeader *msg,
 }
 
 
-void
+static void
 slave_message_cb (void *cls, const struct GNUNET_PSYC_MessageHeader *msg)
 {
   GNUNET_assert (NULL != msg);
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Test #%d: Slave got PSYC message fragment of size %u "
               "belonging to message ID %" PRIu64 " with flags %x\n",
               test, ntohs (msg->header.size),
@@ -285,7 +280,7 @@ slave_message_cb (void *cls, const struct GNUNET_PSYC_MessageHeader *msg)
 }
 
 
-void
+static void
 slave_message_part_cb (void *cls,
                        const struct GNUNET_PSYC_MessageHeader *msg,
                        const struct GNUNET_MessageHeader *pmsg)
@@ -298,7 +293,7 @@ slave_message_part_cb (void *cls,
   uint16_t type = ntohs (pmsg->type);
   uint16_t size = ntohs (pmsg->size);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Test #%d: Slave got message part of type %u and size %u "
               "belonging to message ID %" PRIu64 " with flags %x\n",
               test, type, size, message_id, flags);
@@ -328,31 +323,36 @@ slave_message_part_cb (void *cls,
 }
 
 
-void
+static void
 state_get_var (void *cls, const struct GNUNET_MessageHeader *mod,
                const char *name, const void *value,
                uint32_t value_size, uint32_t full_value_size)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Got state var: %s\n%.*s\n", name, value_size, value);
+              "Got state var: %s\n%.*s\n",
+              name,
+              (int) value_size,
+              (const char *) value);
 }
 
 
 /*** Slave state_get_prefix() ***/
 
-void
+static void
 slave_state_get_prefix_result (void *cls, int64_t result,
                                const void *err_msg, uint16_t err_msg_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "slave_state_get_prefix:\t%" PRId64 " (%.s)\n",
-              result, err_msg_size, err_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: slave_state_get_prefix:\t%" PRId64 " (%.*s)\n",
+              test, result,
+              (int) err_msg_size,
+              (const char *) err_msg);
   // FIXME: GNUNET_assert (2 == result);
   end ();
 }
 
 
-void
+static void
 slave_state_get_prefix ()
 {
   test = TEST_SLAVE_STATE_GET_PREFIX;
@@ -364,18 +364,19 @@ slave_state_get_prefix ()
 /*** Master state_get_prefix() ***/
 
 
-void
+static void
 master_state_get_prefix_result (void *cls, int64_t result,
                                 const void *err_msg, uint16_t err_msg_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "master_state_get_prefix:\t%" PRId64 " (%s)\n", result, err_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: master_state_get_prefix:\t%" PRId64 " (%s)\n",
+              test, result, (char *) err_msg);
   // FIXME: GNUNET_assert (2 == result);
   slave_state_get_prefix ();
 }
 
 
-void
+static void
 master_state_get_prefix ()
 {
   test = TEST_MASTER_STATE_GET_PREFIX;
@@ -387,19 +388,19 @@ master_state_get_prefix ()
 /*** Slave state_get() ***/
 
 
-void
+static void
 slave_state_get_result (void *cls, int64_t result,
                         const void *err_msg, uint16_t err_msg_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "slave_state_get:\t%" PRId64 " (%.*s)\n",
-              result, err_msg_size, err_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: slave_state_get:\t%" PRId64 " (%.*s)\n",
+              test, result, err_msg_size, (char *) err_msg);
   // FIXME: GNUNET_assert (2 == result);
   master_state_get_prefix ();
 }
 
 
-void
+static void
 slave_state_get ()
 {
   test = TEST_SLAVE_STATE_GET;
@@ -411,19 +412,19 @@ slave_state_get ()
 /*** Master state_get() ***/
 
 
-void
+static void
 master_state_get_result (void *cls, int64_t result,
                          const void *err_msg, uint16_t err_msg_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "master_state_get:\t%" PRId64 " (%.*s)\n",
-              result, err_msg_size, err_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: master_state_get:\t%" PRId64 " (%.*s)\n",
+              test, result, err_msg_size, (char *) err_msg);
   // FIXME: GNUNET_assert (1 == result);
   slave_state_get ();
 }
 
 
-void
+static void
 master_state_get ()
 {
   test = TEST_MASTER_STATE_GET;
@@ -434,20 +435,22 @@ master_state_get ()
 
 /*** Slave history_replay() ***/
 
-void
+static void
 slave_history_replay_result (void *cls, int64_t result,
                              const void *err_msg, uint16_t err_msg_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "slave_history_replay:\t%" PRId64 " (%.*s)\n",
-              result, err_msg_size, err_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: slave_history_replay:\t%" PRId64 " (%.*s)\n",
+              test, result,
+              (int) err_msg_size,
+              (const char *) err_msg);
   GNUNET_assert (9 == result);
 
   master_state_get ();
 }
 
 
-void
+static void
 slave_history_replay ()
 {
   test = TEST_SLAVE_HISTORY_REPLAY;
@@ -462,20 +465,22 @@ slave_history_replay ()
 /*** Master history_replay() ***/
 
 
-void
+static void
 master_history_replay_result (void *cls, int64_t result,
                               const void *err_msg, uint16_t err_msg_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "master_history_replay:\t%" PRId64 " (%.*s)\n",
-              result, err_msg_size, err_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: master_history_replay:\t%" PRId64 " (%.*s)\n",
+              test, result,
+              (int) err_msg_size,
+              (const char *) err_msg);
   GNUNET_assert (9 == result);
 
   slave_history_replay ();
 }
 
 
-void
+static void
 master_history_replay ()
 {
   test = TEST_MASTER_HISTORY_REPLAY;
@@ -490,20 +495,22 @@ master_history_replay ()
 /*** Slave history_replay_latest() ***/
 
 
-void
+static void
 slave_history_replay_latest_result (void *cls, int64_t result,
                                     const void *err_msg, uint16_t err_msg_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "slave_history_replay_latest:\t%" PRId64 " (%.*s)\n",
-              result, err_msg_size, err_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: slave_history_replay_latest:\t%" PRId64 " (%.*s)\n",
+              test, result,
+              (int) err_msg_size,
+              (const char *) err_msg);
   GNUNET_assert (9 == result);
 
   master_history_replay ();
 }
 
 
-void
+static void
 slave_history_replay_latest ()
 {
   test = TEST_SLAVE_HISTORY_REPLAY_LATEST;
@@ -519,20 +526,20 @@ slave_history_replay_latest ()
 /*** Master history_replay_latest() ***/
 
 
-void
+static void
 master_history_replay_latest_result (void *cls, int64_t result,
                                      const void *err_msg, uint16_t err_msg_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "master_history_replay_latest:\t%" PRId64 " (%.*s)\n",
-              result, err_msg_size, err_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: master_history_replay_latest:\t%" PRId64 " (%.*s)\n",
+              test, result, err_msg_size, (char *) err_msg);
   GNUNET_assert (9 == result);
 
   slave_history_replay_latest ();
 }
 
 
-void
+static void
 master_history_replay_latest ()
 {
   test = TEST_MASTER_HISTORY_REPLAY_LATEST;
@@ -545,10 +552,11 @@ master_history_replay_latest ()
 }
 
 
-void
-transmit_resume (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+transmit_resume (void *cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmission resumed.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Test #%d: Transmission resumed.\n", test);
   struct TransmitClosure *tmit = cls;
   if (NULL != tmit->mst_tmit)
     GNUNET_PSYC_master_transmit_resume (tmit->mst_tmit);
@@ -557,7 +565,7 @@ transmit_resume (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 }
 
 
-int
+static int
 tmit_notify_data (void *cls, uint16_t *data_size, void *data)
 {
   struct TransmitClosure *tmit = cls;
@@ -594,21 +602,21 @@ tmit_notify_data (void *cls, uint16_t *data_size, void *data)
   tmit->paused = GNUNET_NO;
 
   *data_size = size;
-  memcpy (data, tmit->data[tmit->n], size);
+  GNUNET_memcpy (data, tmit->data[tmit->n], size);
 
   return ++tmit->n < tmit->data_count ? GNUNET_NO : GNUNET_YES;
 }
 
 
-int
+static int
 tmit_notify_mod (void *cls, uint16_t *data_size, void *data, uint8_t *oper,
                  uint32_t *full_value_size)
 {
   struct TransmitClosure *tmit = cls;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Test #%d: Transmit notify modifier: %lu bytes available, "
+              "Test #%d: Transmit notify modifier: %u bytes available, "
               "%u modifiers left to process.\n",
-              test, *data_size, GNUNET_PSYC_env_get_count (tmit->env));
+              test, *data_size, (unsigned int) GNUNET_PSYC_env_get_count (tmit->env));
 
   uint16_t name_size = 0;
   size_t value_size = 0;
@@ -640,9 +648,9 @@ tmit_notify_mod (void *cls, uint16_t *data_size, void *data, uint8_t *oper,
       tmit->mod_value = tmit->mod->value + value_size;
     }
 
-    memcpy (data, tmit->mod->name, name_size);
+    GNUNET_memcpy (data, tmit->mod->name, name_size);
     ((char *)data)[name_size] = '\0';
-    memcpy ((char *)data + name_size + 1, tmit->mod->value, value_size);
+    GNUNET_memcpy ((char *)data + name_size + 1, tmit->mod->value, value_size);
   }
   else if (NULL != tmit->mod_value && 0 < tmit->mod_value_size)
   { /* Modifier continuation */
@@ -669,7 +677,7 @@ tmit_notify_mod (void *cls, uint16_t *data_size, void *data, uint8_t *oper,
     }
 
     *data_size = value_size;
-    memcpy (data, value, value_size);
+    GNUNET_memcpy (data, value, value_size);
   }
 
   return GNUNET_NO;
@@ -680,11 +688,11 @@ static void
 slave_join ();
 
 
-void
+static void
 slave_transmit ()
 {
   test = TEST_SLAVE_TRANSMIT;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Test #%d: Slave sending request to master.\n", test);
 
   tmit = GNUNET_new (struct TransmitClosure);
@@ -704,19 +712,19 @@ slave_transmit ()
 }
 
 
-void
+static void
 slave_remove_cb (void *cls, int64_t result,
                  const void *err_msg, uint16_t err_msg_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "slave_remove:\t%" PRId64 " (%.*s)\n",
-              result, err_msg_size, err_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: slave_remove:\t%" PRId64 " (%.*s)\n",
+              test, result, err_msg_size, (char *) err_msg);
 
   slave_transmit ();
 }
 
 
-void
+static void
 slave_remove ()
 {
   test = TEST_SLAVE_REMOVE;
@@ -726,18 +734,18 @@ slave_remove ()
 }
 
 
-void
+static void
 slave_add_cb (void *cls, int64_t result,
               const void *err_msg, uint16_t err_msg_size)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "slave_add:\t%" PRId64 " (%.*s)\n",
-              result, err_msg_size, err_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: slave_add:\t%" PRId64 " (%.*s)\n",
+              test, result, err_msg_size, (char *) err_msg);
   slave_remove ();
 }
 
 
-void
+static void
 slave_add ()
 {
   test = TEST_SLAVE_ADD;
@@ -746,17 +754,18 @@ slave_add ()
 }
 
 
-void first_slave_parted (void *cls)
+static void
+first_slave_parted (void *cls)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "First slave parted.\n");
   slave_join (TEST_SLAVE_JOIN_ACCEPT);
 }
 
 
-void
-schedule_slave_part (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+schedule_slave_part (void *cls)
 {
-  GNUNET_PSYC_slave_part (slv, GNUNET_NO, first_slave_parted, NULL);
+  GNUNET_PSYC_slave_part (slv, GNUNET_NO, &first_slave_parted, NULL);
 }
 
 
@@ -766,7 +775,7 @@ join_decision_cb (void *cls,
                   int is_admitted,
                   const struct GNUNET_PSYC_Message *join_msg)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Test #%d: Slave got join decision: %d\n", test, is_admitted);
 
   switch (test)
@@ -774,7 +783,7 @@ join_decision_cb (void *cls,
   case TEST_SLAVE_JOIN_REJECT:
     GNUNET_assert (0 == is_admitted);
     GNUNET_assert (1 == join_req_count);
-    GNUNET_SCHEDULER_add_now (schedule_slave_part, NULL);
+    GNUNET_SCHEDULER_add_now (&schedule_slave_part, NULL);
     break;
 
   case TEST_SLAVE_JOIN_ACCEPT:
@@ -798,7 +807,7 @@ join_request_cb (void *cls,
 {
   struct GNUNET_HashCode slave_key_hash;
   GNUNET_CRYPTO_hash (slave_key, sizeof (*slave_key), &slave_key_hash);
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Test #%d: Got join request #%u from %s.\n",
               test, join_req_count, GNUNET_h2s (&slave_key_hash));
 
@@ -811,7 +820,7 @@ join_request_cb (void *cls,
 static void
 slave_connect_cb (void *cls, int result, uint64_t max_message_id)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Test #%d: Slave connected: %d, max_message_id: %" PRIu64 "\n",
               test, result, max_message_id);
   GNUNET_assert (TEST_SLAVE_JOIN_REJECT == test || TEST_SLAVE_JOIN_ACCEPT == test);
@@ -823,7 +832,8 @@ static void
 slave_join (int t)
 {
   test = t;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Test #%d: Joining slave.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: Joining slave.\n", t);
 
   struct GNUNET_PeerIdentity origin = this_peer;
   struct GNUNET_PSYC_Environment *env = GNUNET_PSYC_env_create ();
@@ -846,11 +856,11 @@ slave_join (int t)
 }
 
 
-void
+static void
 master_transmit ()
 {
   test = TEST_MASTER_TRANSMIT;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Test #%d: Master sending message to all.\n", test);
   end_count = 0;
 
@@ -901,7 +911,7 @@ master_transmit ()
 }
 
 
-void
+static void
 master_start_cb (void *cls, int result, uint64_t max_message_id)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -913,11 +923,12 @@ master_start_cb (void *cls, int result, uint64_t max_message_id)
 }
 
 
-void
+static void
 master_start ()
 {
   test = TEST_MASTER_START;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Test #%d: Starting master.\n", test);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Test #%d: Starting master.\n", test);
   mst = GNUNET_PSYC_master_start (cfg, channel_key, GNUNET_PSYC_CHANNEL_PRIVATE,
                                   &master_start_cb, &join_request_cb,
                                   &master_message_cb, &master_message_part_cb,
@@ -925,28 +936,14 @@ master_start ()
   mst_chn = GNUNET_PSYC_master_get_channel (mst);
 }
 
-void
-schedule_master_start (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  master_start ();
-}
-
 
-void
-core_connected (void *cls, const struct GNUNET_PeerIdentity *my_identity)
+static void
+schedule_master_start (void *cls)
 {
-  this_peer = *my_identity;
-
-#if DEBUG_TEST_PSYC
   master_start ();
-#else
-  /* Allow some time for the services to initialize. */
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                &schedule_master_start, NULL);
-#endif
-
 }
 
+
 /**
  * Main function of the test, run from scheduler.
  *
@@ -954,7 +951,7 @@ core_connected (void *cls, const struct GNUNET_PeerIdentity *my_identity)
  * @param cfg configuration we use (also to connect to PSYC service)
  * @param peer handle to access more of the peer (not used)
  */
-void
+static void
 #if DEBUG_TEST_PSYC
 run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *c)
@@ -967,14 +964,21 @@ run (void *cls,
   cfg = c;
   end_badly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
 
+  GNUNET_CRYPTO_get_peer_identity (cfg, &this_peer);
+
   channel_key = GNUNET_CRYPTO_eddsa_key_create ();
   slave_key = GNUNET_CRYPTO_ecdsa_key_create ();
 
   GNUNET_CRYPTO_eddsa_key_get_public (channel_key, &channel_pub_key);
   GNUNET_CRYPTO_ecdsa_key_get_public (slave_key, &slave_pub_key);
 
-  core = GNUNET_CORE_connect (cfg, NULL, &core_connected, NULL, NULL,
-                              NULL, GNUNET_NO, NULL, GNUNET_NO, NULL);
+#if DEBUG_TEST_PSYC
+  master_start ();
+#else
+  /* Allow some time for the services to initialize. */
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                &schedule_master_start, NULL);
+#endif
 }