From: Nathan S. Evans <evans@in.tum.de>
Date: Fri, 26 Feb 2010 10:44:15 +0000 (+0000)
Subject: towards better topology testing, still a kink or two
X-Git-Tag: initial-import-from-subversion-38251~22608
X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=eb98ca5b7a3d2377f2422d453b5b0fe445cf6329;p=oweals%2Fgnunet.git

towards better topology testing, still a kink or two
---

diff --git a/src/testing/test_testing_topology.c b/src/testing/test_testing_topology.c
new file mode 100644
index 000000000..a8d1a4a8c
--- /dev/null
+++ b/src/testing/test_testing_topology.c
@@ -0,0 +1,664 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+/**
+ * @file testing/test_testing_topology.c
+ * @brief base testcase for testing all the topologies provided
+ */
+#include "platform.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_core_service.h"
+
+#define VERBOSE GNUNET_YES
+
+/**
+ * How long until we give up on connecting the peers?
+ */
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
+
+#define DEFAULT_NUM_PEERS 4;
+
+static int ok;
+
+static unsigned long long num_peers;
+
+static unsigned int total_connections;
+
+static unsigned int total_server_connections;
+
+static unsigned int total_messages_received;
+
+static unsigned int expected_messages;
+
+static unsigned int expected_connections;
+
+static int peers_left;
+
+static struct GNUNET_TESTING_PeerGroup *pg;
+
+static struct GNUNET_SCHEDULER_Handle *sched;
+
+const struct GNUNET_CONFIGURATION_Handle *main_cfg;
+
+GNUNET_SCHEDULER_TaskIdentifier die_task;
+
+static char *dotOutFileName = "topology.dot";
+
+static FILE *dotOutFile;
+
+static char *topology_string;
+
+static int transmit_ready_scheduled;
+
+static int transmit_ready_called;
+
+struct TestMessageContext *global_pos;
+
+#define MTYPE 12345
+
+struct TestMessageContext
+{
+  /* This is a linked list */
+  struct TestMessageContext *next;
+
+  /* Handle to the sending peer core */
+  struct GNUNET_CORE_Handle *peer1handle;
+
+  /* Handle to the receiving peer core */
+  struct GNUNET_CORE_Handle *peer2handle;
+
+  /* Handle to the sending peer daemon */
+  struct GNUNET_TESTING_Daemon *peer1;
+
+  /* Handle to the receiving peer daemon */
+  struct GNUNET_TESTING_Daemon *peer2;
+
+  /* Maintain some state */
+  int first_step_done;
+
+};
+
+struct Connection
+{
+  struct Connection *next;
+  struct GNUNET_TESTING_Daemon *peer;
+  struct GNUNET_CORE_Handle *server;
+};
+
+static struct Connection *global_connections;
+
+static struct TestMessageContext *test_messages;
+
+static void
+finish_testing ()
+{
+  GNUNET_assert (pg != NULL);
+  struct Connection *pos;
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Called finish testing, stopping daemons.\n");
+#endif
+  int count;
+  count = 0;
+  pos = global_connections;
+  while (pos != NULL)
+    {
+      if (pos->server != NULL)
+        {
+          GNUNET_CORE_disconnect(pos->server);
+          pos->server = NULL;
+        }
+      pos = pos->next;
+    }
+#if VERBOSE
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "transmit_ready's scheduled %d, transmit_ready's called %d\n", transmit_ready_scheduled, transmit_ready_called);
+#endif
+  sleep(1);
+#if VERBOSE
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Calling daemons_stop\n");
+#endif
+  GNUNET_TESTING_daemons_stop (pg);
+#if VERBOSE
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "daemons_stop finished\n");
+#endif
+  if (dotOutFile != NULL)
+    {
+      fprintf(dotOutFile, "}");
+      fclose(dotOutFile);
+    }
+
+  ok = 0;
+}
+
+static int
+process_mtype (void *cls,
+               const struct GNUNET_PeerIdentity *peer,
+               const struct GNUNET_MessageHeader *message,
+               struct GNUNET_TIME_Relative latency,
+               uint32_t distance)
+{
+  total_messages_received++;
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received message from `%4s', type %d.\n", GNUNET_i2s (peer), ntohs(message->type));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Total messages received %d, expected %d.\n", total_messages_received, expected_messages);
+#endif
+
+  if (total_messages_received == expected_messages)
+    {
+      GNUNET_SCHEDULER_cancel (sched, die_task);
+      GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+    }
+  return GNUNET_OK;
+}
+
+static void
+end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+{
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "End badly was called... stopping daemons.\n");
+#endif
+  struct Connection *pos;
+
+  pos = global_connections;
+  while (pos != NULL)
+    {
+      if (pos->server != NULL)
+        {
+          GNUNET_CORE_disconnect(pos->server);
+          pos->server = NULL;
+        }
+      pos = pos->next;
+    }
+
+  if (pg != NULL)
+    {
+      GNUNET_TESTING_daemons_stop (pg);
+      ok = 7331;                /* Opposite of leet */
+    }
+  else
+    ok = 401;                   /* Never got peers started */
+
+  if (dotOutFile != NULL)
+    {
+      fprintf(dotOutFile, "}");
+      fclose(dotOutFile);
+    }
+}
+
+
+/**
+ * Forward declaration.
+ */
+static size_t
+transmit_ready (void *cls, size_t size, void *buf);
+
+static void
+schedule_transmission (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+{
+
+  if (global_pos != NULL)
+  {
+    if (NULL == GNUNET_CORE_notify_transmit_ready (global_pos->peer1handle,
+                                                 0,
+                                                 TIMEOUT,
+                                                 &global_pos->peer2->id,
+                                                 sizeof (struct GNUNET_MessageHeader),
+                                                 &transmit_ready, &global_pos->peer1->id))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n",
+                    GNUNET_i2s (&global_pos->peer2->id));
+      }
+    else
+      {
+        transmit_ready_scheduled++;
+      }
+    global_pos = global_pos->next;
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmit ready scheduled on %d messages\n",
+                transmit_ready_scheduled);
+  }
+
+}
+
+static size_t
+transmit_ready (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_MessageHeader *m;
+  struct GNUNET_PeerIdentity *peer = cls;
+  GNUNET_assert (buf != NULL);
+  m = (struct GNUNET_MessageHeader *) buf;
+  m->type = htons (MTYPE);
+  m->size = htons (sizeof (struct GNUNET_MessageHeader));
+
+  transmit_ready_called++;
+#if VERBOSE
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "transmit ready for peer %s\ntransmit_ready's scheduled %d, transmit_ready's called %d\n", GNUNET_i2s(peer), transmit_ready_scheduled, transmit_ready_called);
+#endif
+  GNUNET_SCHEDULER_add_now(sched, &schedule_transmission, NULL);
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+
+static struct GNUNET_CORE_MessageHandler handlers[] = {
+  {&process_mtype, MTYPE, sizeof (struct GNUNET_MessageHeader)},
+  {NULL, 0, 0}
+};
+
+
+
+static void
+send_test_messages ()
+{
+  struct TestMessageContext *pos;
+  struct Connection *conn_pos;
+  die_task = GNUNET_SCHEDULER_add_delayed (sched,
+                                           TIMEOUT,
+                                           &end_badly, "from send test messages");
+
+  int count = 0;
+  int conn_count = 0;
+  pos = test_messages;
+  while (pos != NULL)
+    {
+      conn_pos = global_connections;
+      conn_count = 0;
+      while (conn_pos != NULL)
+        {
+          if (conn_pos->peer == pos->peer1)
+            {
+              pos->peer1handle = conn_pos->server;
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                                "Peer matched conn_count %d\n",
+                                conn_count);
+              break;
+            }
+          conn_count++;
+          conn_pos = conn_pos->next;
+        }
+      GNUNET_assert(pos->peer1handle != NULL);
+
+      /*
+      if (NULL == GNUNET_CORE_notify_transmit_ready (pos->peer1handle,
+                                                   0,
+                                                   TIMEOUT,
+                                                   &pos->peer2->id,
+                                                   sizeof (struct GNUNET_MessageHeader),
+                                                   &transmit_ready, &pos->peer1->id))
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n",
+                      GNUNET_i2s (&pos->peer2->id));
+        }
+      else
+        {
+          transmit_ready_scheduled++;
+        }
+      */
+      pos = pos->next;
+      count++;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Prepared %d messages\n",
+                  count);
+    }
+
+  global_pos = test_messages;
+
+  GNUNET_SCHEDULER_add_now(sched, &schedule_transmission, NULL);
+}
+
+
+
+static void
+init_notify (void *cls,
+             struct GNUNET_CORE_Handle *server,
+             const struct GNUNET_PeerIdentity *my_identity,
+             const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
+{
+  struct Connection *connection = cls;
+
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Core connection to `%4s' established, setting up handles\n",
+              GNUNET_i2s (my_identity));
+#endif
+  connection->server = server;
+  total_server_connections++;
+
+  if (total_server_connections == num_peers)
+    {
+      GNUNET_SCHEDULER_cancel(sched, die_task);
+      GNUNET_SCHEDULER_add_now(sched, &send_test_messages, NULL);
+    }
+#if OLD
+  if (context->first_step_done == GNUNET_NO)
+    {
+      context->peer1handle = server;
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting core to peer 2\n");
+#endif
+      context->first_step_done = GNUNET_YES;
+      /* connect p2 */
+      GNUNET_CORE_connect (sched,
+                           context->peer2->cfg,
+                           TIMEOUT,
+                           context,
+                           &init_notify,
+                           NULL,
+                           NULL,
+                           NULL,
+                           NULL,
+                           GNUNET_YES,
+                           NULL, GNUNET_YES, handlers);
+
+    }
+  else
+    {
+      context->peer2handle = server;
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Asking core (1) for transmission to peer `%4s'\n",
+                  GNUNET_i2s (&context->peer2->id));
+#endif
+      transmit_ready_scheduled++;
+      if (NULL == GNUNET_CORE_notify_transmit_ready (context->peer1->server,
+                                                     0,
+                                                     TIMEOUT,
+                                                     &context->peer2->id,
+                                                     sizeof (struct GNUNET_MessageHeader),
+                                                     &transmit_ready, NULL))
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n",
+                      GNUNET_i2s (&context->peer2->id));
+        }
+    }
+#endif
+}
+
+
+static void
+setup_handlers ()
+{
+  int i;
+  struct Connection *new_connection;
+
+  struct GNUNET_TESTING_Daemon *temp_daemon;
+  die_task = GNUNET_SCHEDULER_add_delayed (sched,
+                                           TIMEOUT,
+                                           &end_badly, "from setup_handlers");
+
+
+  /**
+   * Set up a single handler for each peer
+   */
+  for (i = 0; i < num_peers; i++)
+    {
+      new_connection = GNUNET_malloc(sizeof(struct Connection));
+      temp_daemon = GNUNET_TESTING_daemon_get(pg, i);
+      new_connection->peer = temp_daemon;
+      new_connection->server = NULL;
+      new_connection->next = global_connections;
+      global_connections = new_connection;
+
+      GNUNET_CORE_connect (sched,
+                           temp_daemon->cfg,
+                           TIMEOUT,
+                           new_connection,
+                           &init_notify,
+                           NULL,
+                           NULL,
+                           NULL,
+                           NULL,
+                           GNUNET_YES, NULL, GNUNET_YES, handlers);
+    }
+}
+
+
+
+void
+topology_callback (void *cls,
+                   const struct GNUNET_PeerIdentity *first,
+                   const struct GNUNET_PeerIdentity *second,
+                   const struct GNUNET_CONFIGURATION_Handle *first_cfg,
+                   const struct GNUNET_CONFIGURATION_Handle *second_cfg,
+                   struct GNUNET_TESTING_Daemon *first_daemon,
+                   struct GNUNET_TESTING_Daemon *second_daemon,
+                   const char *emsg)
+{
+  struct TestMessageContext *temp_context;
+  if (emsg == NULL)
+    {
+      total_connections++;
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s\n",
+               first_daemon->shortname,
+               second_daemon->shortname);
+#endif
+      temp_context = GNUNET_malloc(sizeof(struct TestMessageContext));
+      temp_context->first_step_done = 0;
+      temp_context->peer1handle = NULL;
+      temp_context->peer1 = first_daemon;
+      temp_context->peer2 = second_daemon;
+      temp_context->peer2handle = NULL;
+      temp_context->next = test_messages;
+      test_messages = temp_context;
+
+      expected_messages++;
+      if (dotOutFile != NULL)
+        fprintf(dotOutFile, "\tn%s -- n%s;\n", first_daemon->shortname, second_daemon->shortname);
+    }
+#if VERBOSE
+  else
+    {
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect peer %s to peer %s with error %s\n",
+               first_daemon->shortname,
+               second_daemon->shortname, emsg);
+    }
+#endif
+
+  if (total_connections == expected_connections)
+    {
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Created %d total connections, which is our target number!  Calling send messages.\n",
+                  total_connections);
+#endif
+
+      GNUNET_SCHEDULER_cancel (sched, die_task);
+      die_task = GNUNET_SCHEDULER_add_now (sched, &setup_handlers, NULL);
+    }
+  else
+    {
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Have %d total connections, Need %d\n",
+                  total_connections, expected_connections);
+#endif
+    }
+}
+
+
+static void
+create_topology ()
+{
+  expected_connections = -1;
+  if ((pg != NULL) && (peers_left == 0))
+    {
+      /* create_topology will read the topology information from
+         the config already contained in the peer group, so should
+         we have create_topology called from start peers?  I think
+         maybe this way is best so that the client can know both
+         when peers are started, and when they are connected.
+       */
+      expected_connections = GNUNET_TESTING_create_topology (pg);
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Have %d expected connections\n", expected_connections);
+#endif
+    }
+
+  GNUNET_SCHEDULER_cancel (sched, die_task);
+  if (expected_connections == GNUNET_SYSERR)
+    {
+      die_task = GNUNET_SCHEDULER_add_now (sched,
+                                           &end_badly, NULL);
+    }
+  die_task = GNUNET_SCHEDULER_add_delayed (sched,
+                                           TIMEOUT,
+                                           &end_badly, NULL);
+}
+
+
+static void
+my_cb (void *cls,
+       const struct GNUNET_PeerIdentity *id,
+       const struct GNUNET_CONFIGURATION_Handle *cfg,
+       struct GNUNET_TESTING_Daemon *d, const char *emsg)
+{
+  GNUNET_assert (id != NULL);
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started daemon %d out of %d\n",
+              (num_peers - peers_left) + 1, num_peers);
+#endif
+  peers_left--;
+  if (peers_left == 0)
+    {
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "All %d daemons started, now creating topology!\n",
+                  num_peers);
+#endif
+      GNUNET_SCHEDULER_cancel (sched, die_task);
+      /* Set up task in case topology creation doesn't finish
+       * within a reasonable amount of time */
+      die_task = GNUNET_SCHEDULER_add_delayed (sched,
+                                               GNUNET_TIME_relative_multiply
+                                               (GNUNET_TIME_UNIT_MINUTES, 5),
+                                               &end_badly, NULL);
+      create_topology ();
+      ok = 0;
+    }
+}
+
+
+static void
+run (void *cls,
+     struct GNUNET_SCHEDULER_Handle *s,
+     char *const *args,
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  sched = s;
+  ok = 1;
+
+  dotOutFile = fopen (dotOutFileName, "w");
+  if (dotOutFile != NULL)
+    {
+      fprintf (dotOutFile, "strict graph G {\n");
+    }
+
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting daemons based on config file %s\n", cfgfile);
+#endif
+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
+                                             &num_peers))
+    num_peers = DEFAULT_NUM_PEERS;
+
+  main_cfg = cfg;
+
+  peers_left = num_peers;
+
+  /* Set up a task to end testing if peer start fails */
+  die_task = GNUNET_SCHEDULER_add_delayed (sched,
+                                           GNUNET_TIME_relative_multiply
+                                           (GNUNET_TIME_UNIT_MINUTES, 5),
+                                           &end_badly, NULL);
+
+  pg = GNUNET_TESTING_daemons_start (sched, cfg,
+                                     peers_left, &my_cb, NULL,
+                                     &topology_callback, NULL, NULL);
+
+}
+
+static int
+check ()
+{
+  char *binary_name;
+  char *config_file_name;
+  GNUNET_asprintf(&binary_name, "test-testing-topology-%s", topology_string);
+  GNUNET_asprintf(&config_file_name, "test_testing_data_topology_%s.conf", topology_string);
+  char *const argv[] = {binary_name,
+    "-c",
+    config_file_name,
+#if VERBOSE
+    "-L", "DEBUG",
+#endif
+    NULL
+  };
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
+                      argv, binary_name, "nohelp",
+                      options, &run, &ok);
+  return ok;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+  char *binary_start_pos;
+  char *our_binary_name;
+  binary_start_pos = rindex(argv[0], '/');
+  if (strstr(binary_start_pos, "test_testing_topology_") == NULL)
+    {
+      return GNUNET_SYSERR;
+    }
+
+  topology_string = &binary_start_pos[23];
+
+  GNUNET_asprintf(&our_binary_name, "test-testing-topology_%s", topology_string);
+  GNUNET_log_setup (our_binary_name,
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "WARNING",
+#endif
+                    NULL);
+  ret = check ();
+  sleep (1);
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
+  return ret;
+}
+
+/* end of test_testing_group.c */
diff --git a/src/testing/test_testing_topology_clique.c b/src/testing/test_testing_topology_clique.c
deleted file mode 100644
index 0521145bb..000000000
--- a/src/testing/test_testing_topology_clique.c
+++ /dev/null
@@ -1,466 +0,0 @@
-/*
-     This file is part of GNUnet.
-     (C) 2009 Christian Grothoff (and other contributing authors)
-
-     GNUnet is free software; you can redistribute it and/or modify
-     it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 2, or (at your
-     option) any later version.
-
-     GNUnet is distributed in the hope that it will be useful, but
-     WITHOUT ANY WARRANTY; without even the implied warranty of
-     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-     General Public License for more details.
-
-     You should have received a copy of the GNU General Public License
-     along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
-*/
-/**
- * @file testing/test_testing_group.c
- * @brief testcase for functions to connect two peers in testing.c
- */
-#include "platform.h"
-#include "gnunet_testing_lib.h"
-#include "gnunet_core_service.h"
-
-#define VERBOSE GNUNET_NO
-
-/**
- * How long until we give up on connecting the peers?
- */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
-
-#define DEFAULT_NUM_PEERS 4;
-
-static int ok;
-
-static unsigned long long num_peers;
-
-static unsigned int total_connections;
-
-static unsigned int expected_connections;
-
-static int peers_left;
-
-static struct GNUNET_TESTING_PeerGroup *pg;
-
-static struct GNUNET_SCHEDULER_Handle *sched;
-
-const struct GNUNET_CONFIGURATION_Handle *main_cfg;
-
-GNUNET_SCHEDULER_TaskIdentifier die_task;
-
-static struct GNUNET_CORE_Handle *peer1handle;
-
-static struct GNUNET_CORE_Handle *peer2handle;
-
-#define MTYPE 12345
-
-static void
-finish_testing ()
-{
-  GNUNET_assert (pg != NULL);
-
-  if (peer1handle != NULL)
-    GNUNET_CORE_disconnect(peer1handle);
-  if (peer2handle != NULL)
-    GNUNET_CORE_disconnect(peer2handle);
-
-  GNUNET_TESTING_daemons_stop (pg);
-  ok = 0;
-}
-
-static int
-process_mtype (void *cls,
-               const struct GNUNET_PeerIdentity *peer,
-               const struct GNUNET_MessageHeader *message,
-               struct GNUNET_TIME_Relative latency,
-               uint32_t distance)
-{
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving message from `%4s' of type %d.\n", GNUNET_i2s (peer), ntohs(message->type));
-#endif
-  GNUNET_SCHEDULER_cancel (sched, die_task);
-  GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
-  return GNUNET_OK;
-}
-
-
-static void
-connect_notify (void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-                struct GNUNET_TIME_Relative latency,
-                uint32_t distance)
-{
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Encrypted connection established to peer `%4s' with latency %llu\n",
-              GNUNET_i2s (peer), latency.value);
-#endif
-}
-
-
-static void
-disconnect_notify (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
-{
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Encrypted connection to `%4s' cut\n", GNUNET_i2s (peer));
-#endif
-}
-
-static int
-outbound_notify (void *cls,
-                 const struct GNUNET_PeerIdentity *other,
-                 const struct GNUNET_MessageHeader *message,
-                 struct GNUNET_TIME_Relative latency,
-                 uint32_t distance)
-{
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Core notifies about outbound data for `%4s'.\n",
-              GNUNET_i2s (other));
-#endif
-  return GNUNET_OK;
-}
-
-static void
-end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
-{
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "End badly was called... stopping daemons.\n");
-#endif
-
-  if (peer1handle != NULL)
-    {
-      GNUNET_CORE_disconnect(peer1handle);
-      peer1handle = NULL;
-    }
-  if (peer2handle != NULL)
-    {
-      GNUNET_CORE_disconnect(peer2handle);
-      peer2handle = NULL;
-    }
-
-  if (pg != NULL)
-    {
-      GNUNET_TESTING_daemons_stop (pg);
-      ok = 7331;                /* Opposite of leet */
-    }
-  else
-    ok = 401;                   /* Never got peers started */
-}
-
-static size_t
-transmit_ready (void *cls, size_t size, void *buf)
-{
-  struct GNUNET_MessageHeader *m;
-
-  GNUNET_assert (buf != NULL);
-  m = (struct GNUNET_MessageHeader *) buf;
-  m->type = htons (MTYPE);
-  m->size = htons (sizeof (struct GNUNET_MessageHeader));
-  GNUNET_SCHEDULER_cancel(sched, die_task);
-  die_task =
-    GNUNET_SCHEDULER_add_delayed (sched,
-        TIMEOUT, &end_badly, "from transmit ready");
-
-  return sizeof (struct GNUNET_MessageHeader);
-}
-
-
-static struct GNUNET_CORE_MessageHandler handlers[] = {
-  {&process_mtype, MTYPE, sizeof (struct GNUNET_MessageHeader)},
-  {NULL, 0, 0}
-};
-
-
-static void
-init_notify (void *cls,
-             struct GNUNET_CORE_Handle *server,
-             const struct GNUNET_PeerIdentity *my_identity,
-             const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
-{
-  struct GNUNET_TESTING_Daemon *connected_peer = cls;
-  struct GNUNET_TESTING_Daemon *peer1;
-  struct GNUNET_TESTING_Daemon *peer2;
-
-  peer1 = GNUNET_TESTING_daemon_get(pg, 0);
-  peer2 = GNUNET_TESTING_daemon_get(pg, 1);
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Core connection to `%4s' established, setting up handles\n",
-              GNUNET_i2s (my_identity));
-#endif
-
-  if (connected_peer == peer1)
-    {
-      peer1handle = server;
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting core to peer 2\n");
-#endif
-      /* connect p2 */
-      GNUNET_CORE_connect (sched,
-                           peer2->cfg,
-                           TIMEOUT,
-                           peer2,
-                           &init_notify,
-                           NULL,
-                           &connect_notify,
-                           &disconnect_notify,
-                           NULL,
-                           GNUNET_YES,
-                           &outbound_notify, GNUNET_YES, handlers);
-    }
-  else
-    {
-      GNUNET_assert(connected_peer == peer2);
-      peer2handle = server;
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Asking core (1) for transmission to peer `%4s'\n",
-                  GNUNET_i2s (&peer2->id));
-#endif
-
-      if (NULL == GNUNET_CORE_notify_transmit_ready (peer1->server,
-                                                     0,
-                                                     TIMEOUT,
-                                                     &peer2->id,
-                                                     sizeof (struct GNUNET_MessageHeader),
-                                                     &transmit_ready, &peer1))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n",
-                      GNUNET_i2s (&peer2->id));
-        }
-
-    }
-}
-
-
-static void
-send_test_messages ()
-{
-  struct GNUNET_TESTING_Daemon *peer1;
-  struct GNUNET_TESTING_Daemon *peer2;
-
-  peer1 = GNUNET_TESTING_daemon_get(pg, 0);
-  peer2 = GNUNET_TESTING_daemon_get(pg, 1);
-
-  die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                           TIMEOUT,
-                                           &end_badly, "from send test messages");
-
-  /* Send a message from peer 1 to peer 2 */
-  GNUNET_CORE_connect (sched,
-                       peer1->cfg,
-                       TIMEOUT,
-                       peer1,
-                       &init_notify,
-                       NULL,
-                       &connect_notify,
-                       &disconnect_notify,
-                       NULL,
-                       GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
-}
-
-void
-topology_callback (void *cls,
-                   const struct GNUNET_PeerIdentity *first,
-                   const struct GNUNET_PeerIdentity *second,
-                   const struct GNUNET_CONFIGURATION_Handle *first_cfg,
-                   const struct GNUNET_CONFIGURATION_Handle *second_cfg,
-                   struct GNUNET_TESTING_Daemon *first_daemon,
-                   struct GNUNET_TESTING_Daemon *second_daemon,
-                   const char *emsg)
-{
-  /* Keep track of connections here if the client needs to know?
-   * Still, we have no real handle to say the i'th peer of the peer group
-   * even though we know that X peers exist in i...  But we may want to
-   * know about the peer for logging purposes here (I'm sure we will actually
-   * so the API may need changed).  Question, should the API expose what
-   * a peer group is, or provide convenience/accessor functions?
-   *
-   * For now, I've added accessor functions, which seems like a software
-   * engineering kind of solution, but who knows/cares. */
-  if (emsg == NULL)
-    {
-      total_connections++;
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s\n",
-               first_daemon->shortname,
-               second_daemon->shortname);
-#endif
-    }
-#if VERBOSE
-  else
-    {
-
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect peer %s to peer %s with error %s\n",
-               first_daemon->shortname,
-               second_daemon->shortname, emsg);
-    }
-#endif
-
-  if (total_connections == expected_connections)
-    {
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Created %d total connections, which is our target number!  Ending test.\n",
-                  total_connections);
-#endif
-
-      GNUNET_SCHEDULER_cancel (sched, die_task);
-      die_task = GNUNET_SCHEDULER_add_now (sched, &send_test_messages, NULL);
-    }
-  else
-    {
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Have %d total connections, Need %d\n",
-                  total_connections, expected_connections);
-#endif
-    }
-}
-
-
-static void
-create_topology ()
-{
-  expected_connections = -1;
-  if ((pg != NULL) && (peers_left == 0))
-    {
-      /* create_topology will read the topology information from
-         the config already contained in the peer group, so should
-         we have create_topology called from start peers?  I think
-         maybe this way is best so that the client can know both
-         when peers are started, and when they are connected.
-       */
-      expected_connections = GNUNET_TESTING_create_topology (pg);
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Have %d expected connections\n", expected_connections);
-#endif
-    }
-
-  GNUNET_SCHEDULER_cancel (sched, die_task);
-  die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                           TIMEOUT,
-                                           &end_badly, NULL);
-}
-
-
-static void
-my_cb (void *cls,
-       const struct GNUNET_PeerIdentity *id,
-       const struct GNUNET_CONFIGURATION_Handle *cfg,
-       struct GNUNET_TESTING_Daemon *d, const char *emsg)
-{
-  GNUNET_assert (id != NULL);
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started daemon %d out of %d\n",
-              (num_peers - peers_left) + 1, num_peers);
-#endif
-  peers_left--;
-  if (peers_left == 0)
-    {
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All %d daemons started, now creating topology!\n",
-                  num_peers);
-#endif
-      GNUNET_SCHEDULER_cancel (sched, die_task);
-      /* Set up task in case topology creation doesn't finish
-       * within a reasonable amount of time */
-      die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                               GNUNET_TIME_relative_multiply
-                                               (GNUNET_TIME_UNIT_MINUTES, 5),
-                                               &end_badly, NULL);
-      create_topology ();
-      ok = 477;
-    }
-}
-
-
-static void
-run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
-     char *const *args,
-     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
-{
-  sched = s;
-  ok = 1;
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting daemons based on config file %s\n", cfgfile);
-#endif
-  if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
-                                             &num_peers))
-    num_peers = DEFAULT_NUM_PEERS;
-
-  main_cfg = cfg;
-
-  peers_left = num_peers;
-
-  /* Set up a task to end testing if peer start fails */
-  die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                           GNUNET_TIME_relative_multiply
-                                           (GNUNET_TIME_UNIT_MINUTES, 5),
-                                           &end_badly, NULL);
-
-  pg = GNUNET_TESTING_daemons_start (sched, cfg,
-                                     peers_left, &my_cb, NULL,
-                                     &topology_callback, NULL, NULL);
-
-  /*
-     if (ret != GNUNET_SYSERR)
-     ret = send_test_messages (pg);
-   */
-
-}
-
-static int
-check ()
-{
-  char *const argv[] = { "test-testing-topology-clique",
-    "-c",
-    "test_testing_data_topology_clique.conf",
-#if VERBOSE
-    "-L", "DEBUG",
-#endif
-    NULL
-  };
-  struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_OPTION_END
-  };
-  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-testing-topology-clique", "nohelp",
-                      options, &run, &ok);
-  return ok;
-}
-
-int
-main (int argc, char *argv[])
-{
-  int ret;
-
-  GNUNET_log_setup ("test-testing-topology_clique",
-#if VERBOSE
-                    "DEBUG",
-#else
-                    "WARNING",
-#endif
-                    NULL);
-  ret = check ();
-  sleep (1);
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
-  return ret;
-}
-
-/* end of test_testing_group.c */
diff --git a/src/testing/testing.c b/src/testing/testing.c
index 1e9f6cf5e..78ef9bb1f 100644
--- a/src/testing/testing.c
+++ b/src/testing/testing.c
@@ -840,44 +840,6 @@ send_hello(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 }
 
 
-#if HIDDEN
-/*
- * Accessor function since we have hidden what GNUNET_TESTING_Daemon is
- *
- * FIXME: Either expose members or figure out a better way!
- */
-char *
-GNUNET_TESTING_daemon_get_shortname (struct GNUNET_TESTING_Daemon *d)
-{
-  return d->shortname;
-}
-
-char *
-GNUNET_TESTING_daemon_get_hostname (struct GNUNET_TESTING_Daemon *d)
-{
-  return d->hostname;
-}
-
-char *
-GNUNET_TESTING_daemon_get_username (struct GNUNET_TESTING_Daemon *d)
-{
-  return d->username;
-}
-
-struct GNUNET_PeerIdentity *
-GNUNET_TESTING_daemon_get_peer (struct GNUNET_TESTING_Daemon *d)
-{
-  return &d->id;
-}
-
-struct GNUNET_CONFIGURATION_Handle *
-GNUNET_TESTING_daemon_get_config (struct GNUNET_TESTING_Daemon *d)
-{
-  return d->cfg;
-}
-#endif
-
-
 /**
  * Establish a connection between two GNUnet daemons.
  *
diff --git a/src/testing/testing_group.c b/src/testing/testing_group.c
index 54eb1eb19..2c7cc80a5 100644
--- a/src/testing/testing_group.c
+++ b/src/testing/testing_group.c
@@ -393,7 +393,7 @@ create_small_world_ring(struct GNUNET_TESTING_PeerGroup *pg)
 
   connect_attempts += smallWorldConnections;
 
-  return GNUNET_OK;
+  return connect_attempts;
 }
 
 
@@ -410,7 +410,7 @@ create_nated_internet (struct GNUNET_TESTING_PeerGroup *pg)
   if (p_string != NULL)
     nat_percentage = atof(p_string);
   else
-    nat_percentage = 0.0; /* FIXME: default modifier? */
+    nat_percentage = 0.6; /* FIXME: default modifier? */
 
   GNUNET_free_non_null(p_string);
 
@@ -566,7 +566,7 @@ create_small_world (struct GNUNET_TESTING_PeerGroup *pg)
                       _("Total connections added for small world: %d!\n"),
                       smallWorldConnections);
 #endif
-  return GNUNET_OK;
+  return connect_attempts;
 }
 
 
@@ -589,9 +589,9 @@ create_erdos_renyi (struct GNUNET_TESTING_PeerGroup *pg)
     }
   else
     {
-      probability = 0.0; /* FIXME: default probability? */
+      probability = 0.5; /* FIXME: default probability? */
     }
-  GNUNET_free (p_string);
+  GNUNET_free_non_null (p_string);
   for (outer_count = 0; outer_count < pg->total - 1; outer_count++)
     {
       for (inner_count = outer_count + 1; inner_count < pg->total;