projects / oweals / gnunet.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
docu
[oweals/gnunet.git] / src / transport / test_transport_api.c
diff --git a/src/transport/test_transport_api.c b/src/transport/test_transport_api.c
index f449d375c291de89aff693d5dc05f9611854f143..1316efe252c47deed6bb47b2beaeb47ee2bf6eb4 100644 (file)
--- a/src/transport/test_transport_api.c
+++ b/src/transport/test_transport_api.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.
-     (C) 2009 Christian Grothoff (and other contributing authors)
+     (C) 2009, 2010 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
 
      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
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -27,426 +27,390 @@
  * C code apparently.
  */
 #include "platform.h"
  * C code apparently.
  */
 #include "platform.h"
-#include "gnunet_common.h"
-#include "gnunet_hello_lib.h"
-#include "gnunet_getopt_lib.h"
-#include "gnunet_os_lib.h"
-#include "gnunet_program_lib.h"
-#include "gnunet_scheduler_lib.h"
 #include "gnunet_transport_service.h"
 #include "gnunet_transport_service.h"
-#include "transport.h"
+#include "transport-testing.h"
 
 
-#define VERBOSE GNUNET_YES
-
-#define VERBOSE_ARM GNUNET_NO
-
-#define START_ARM GNUNET_YES
+/**
+ * How long until we give up on transmitting the message?
+ */
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
 
 /**
  * How long until we give up on transmitting the message?
  */
 
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 50)
+#define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
 
 
-#define MTYPE 12345
+#define TEST_MESSAGE_SIZE 2600
 
 
-struct PeerContext
-{
-  struct GNUNET_CONFIGURATION_Handle *cfg;
-  struct GNUNET_TRANSPORT_Handle *th;
-  struct GNUNET_PeerIdentity id;
-#if START_ARM
-  pid_t arm_pid;
-#endif
-};
+#define TEST_MESSAGE_TYPE 12345
 
 
-static struct PeerContext p1;
+static char *test_source;
 
 
-static struct PeerContext p2;
+static char *test_plugin;
 
 
-static struct GNUNET_SCHEDULER_Handle *sched;
+static char *test_name;
 
 static int ok;
 
 
 static int ok;
 
-static int is_tcp;
+static int s_started;
+
+static int s_connected;
+
+static int s_sending;
+
+static GNUNET_SCHEDULER_TaskIdentifier die_task;
+
+static GNUNET_SCHEDULER_TaskIdentifier send_task;
+
+static struct PeerContext *p1;
 
 
-static int is_tcp_nat;
+static struct PeerContext *p2;
 
 
-static int is_udp;
+static GNUNET_TRANSPORT_TESTING_ConnectRequest cc;
 
 
-static int is_udp_nat;
+static struct GNUNET_TRANSPORT_TransmitHandle *th;
 
 
-static int is_http;
+static struct GNUNET_TRANSPORT_TESTING_handle *tth;
 
 
-static  GNUNET_SCHEDULER_TaskIdentifier die_task;
+static char *cfg_file_p1;
 
 
-#if VERBOSE
-#define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
-#else
-#define OKPP do { ok++; } while (0)
-#endif
+static char *cfg_file_p2;
 
 
 static void
 end ()
 {
 
 
 static void
 end ()
 {
-  /* do work here */
-  GNUNET_assert (ok == 6);
-  GNUNET_SCHEDULER_cancel (sched, die_task);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
-  GNUNET_TRANSPORT_disconnect (p1.th);
-  GNUNET_TRANSPORT_disconnect (p2.th);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
 
 
-  die_task = GNUNET_SCHEDULER_NO_TASK;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transports disconnected, returning success!\n");
-  ok = 0;
+  if (send_task != GNUNET_SCHEDULER_NO_TASK)
+    GNUNET_SCHEDULER_cancel (send_task);
+
+  if (die_task != GNUNET_SCHEDULER_NO_TASK)
+    GNUNET_SCHEDULER_cancel (die_task);
+
+  if (th != NULL)
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
+  th = NULL;
+
+  GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
+  GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
 }
 
 static void
 }
 
 static void
-stop_arm (struct PeerContext *p)
+end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 {
-#if START_ARM
-  if (0 != PLIBC_KILL (p->arm_pid, SIGTERM))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-  GNUNET_OS_process_wait (p->arm_pid);
-#endif
-  GNUNET_CONFIGURATION_destroy (p->cfg);
-}
+  die_task = GNUNET_SCHEDULER_NO_TASK;
 
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
 
 
-static void
-end_badly ()
-{
-  GNUNET_break (0);
-  GNUNET_TRANSPORT_disconnect (p1.th);
-  GNUNET_TRANSPORT_disconnect (p2.th);
-  ok = 1;
+
+  if (send_task != GNUNET_SCHEDULER_NO_TASK)
+    GNUNET_SCHEDULER_cancel (send_task);
+
+  if (cc != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Fail! Could not connect peers\n"));
+    GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
+    cc = NULL;
+  }
+
+  if (th != NULL)
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer were not ready to send data\n"));
+
+  if (s_started == GNUNET_NO)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peers were not started \n"));
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peers were started \n"));
+
+  if (s_connected == GNUNET_NO)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer were not connected\n"));
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer were connected\n"));
+
+  if (s_sending == GNUNET_NO)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer were not ready to send data\n"));
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer were ready to send data\n"));
+
+  th = NULL;
+
+  if (p1 != NULL)
+    GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer 1 was not started\n"));
+  if (p2 != NULL)
+    GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer 2 was not started\n"));
+
+  ok = GNUNET_SYSERR;
 }
 
 }
 
+
 static void
 static void
-notify_receive (void *cls,
-                const struct GNUNET_PeerIdentity *peer,
+notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
                 const struct GNUNET_MessageHeader *message,
                 const struct GNUNET_MessageHeader *message,
-                struct GNUNET_TIME_Relative latency,
-               uint32_t distance)
+                const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
 {
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ok is (%d)!\n",
-              ok);
+  struct PeerContext *p = cls;
+  struct PeerContext *t = NULL;
+
+  if (0 == memcmp (peer, &p1->id, sizeof (struct GNUNET_PeerIdentity)))
+    t = p1;
+  if (0 == memcmp (peer, &p2->id, sizeof (struct GNUNET_PeerIdentity)))
+    t = p2;
+  GNUNET_assert (t != NULL);
 
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received message of type %d from peer (%p)!\n",
-                ntohs(message->type), cls);
+  char *ps = GNUNET_strdup (GNUNET_i2s (&p->id));
 
 
-  GNUNET_assert (ok == 5);
-  OKPP;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer %u (`%4s') received message of type %d and size %u size from peer %u (`%4s')!\n",
+              p->no, ps, ntohs (message->type), ntohs (message->size), t->no,
+              GNUNET_i2s (&t->id));
+  GNUNET_free (ps);
 
 
-  GNUNET_assert (MTYPE == ntohs (message->type));
-  GNUNET_assert (sizeof (struct GNUNET_MessageHeader) ==
-                 ntohs (message->size));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received message from peer (%p)!\n",
-              cls);
-  end ();
+  if ((TEST_MESSAGE_TYPE == ntohs (message->type)) &&
+      (TEST_MESSAGE_SIZE == ntohs (message->size)))
+  {
+    ok = 0;
+    end ();
+  }
+  else
+  {
+    GNUNET_break (0);
+    ok = 1;
+    end ();
+  }
 }
 
 
 static size_t
 notify_ready (void *cls, size_t size, void *buf)
 {
 }
 
 
 static size_t
 notify_ready (void *cls, size_t size, void *buf)
 {
+  struct PeerContext *p = cls;
   struct GNUNET_MessageHeader *hdr;
 
   struct GNUNET_MessageHeader *hdr;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting message to peer (%p) - %u!\n", cls, size);
-  GNUNET_assert (size >= 256);
-  GNUNET_assert (ok == 4);
-  OKPP;
+  th = NULL;
+
+  if (buf == NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout occurred while waiting for transmit_ready\n");
+    if (GNUNET_SCHEDULER_NO_TASK != die_task)
+      GNUNET_SCHEDULER_cancel (die_task);
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    ok = 42;
+    return 0;
+  }
+
+  GNUNET_assert (size >= TEST_MESSAGE_SIZE);
   if (buf != NULL)
   {
   if (buf != NULL)
   {
+    memset (buf, '\0', TEST_MESSAGE_SIZE);
     hdr = buf;
     hdr = buf;
-    hdr->size = htons (sizeof (struct GNUNET_MessageHeader));
-    hdr->type = htons (MTYPE);
+    hdr->size = htons (TEST_MESSAGE_SIZE);
+    hdr->type = htons (TEST_MESSAGE_TYPE);
   }
 
   }
 
-  return sizeof (struct GNUNET_MessageHeader);
+  char *ps = GNUNET_strdup (GNUNET_i2s (&p2->id));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer %u (`%4s') sending message with type %u and size %u bytes to peer %u (`%4s')\n",
+              p2->no, ps, ntohs (hdr->type), ntohs (hdr->size), p->no,
+              GNUNET_i2s (&p->id));
+  GNUNET_free (ps);
+
+  return TEST_MESSAGE_SIZE;
 }
 
 
 static void
 }
 
 
 static void
-notify_connect (void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-                struct GNUNET_TIME_Relative latency,
-               uint32_t distance)
+sendtask (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 {
-  if (cls == &p1)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready (p1.th,
-                                             &p2.id,
-                                             256, 0, TIMEOUT, &notify_ready,
-                                             &p1);
-    }
+  send_task = GNUNET_SCHEDULER_NO_TASK;
+
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
+  char *receiver_s = GNUNET_strdup (GNUNET_i2s (&p1->id));
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
+              "Sending message from peer %u (`%4s') -> peer %u (`%s') !\n",
+              p2->no, GNUNET_i2s (&p2->id), p1->no, receiver_s);
+  GNUNET_free (receiver_s);
+  s_sending = GNUNET_YES;
+  th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, TEST_MESSAGE_SIZE, 0,
+                                               TIMEOUT_TRANSMIT, &notify_ready,
+                                               p1);
 }
 
 
 static void
 }
 
 
 static void
-notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
+notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
+                const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
 {
 {
+  static int c;
+
+  c++;
+  struct PeerContext *p = cls;
+  struct PeerContext *t = NULL;
+
+  if (0 == memcmp (peer, &p1->id, sizeof (struct GNUNET_PeerIdentity)))
+    t = p1;
+  if (0 == memcmp (peer, &p2->id, sizeof (struct GNUNET_PeerIdentity)))
+    t = p2;
+  GNUNET_assert (t != NULL);
+
+  char *ps = GNUNET_strdup (GNUNET_i2s (&p->id));
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' disconnected (%p)!\n",
-             GNUNET_i2s (peer), cls);
+              "Peer %u (`%4s'): peer %u (`%s') connected to me!\n", p->no, ps,
+              t->no, GNUNET_i2s (peer));
+  GNUNET_free (ps);
 }
 
 
 static void
 }
 
 
 static void
-setup_peer (struct PeerContext *p, const char *cfgname)
+notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
 {
-  p->cfg = GNUNET_CONFIGURATION_create ();
-#if START_ARM
-  p->arm_pid = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
-#if VERBOSE_ARM
-                                        "-L", "DEBUG",
-#endif
-                                        "-c", cfgname, NULL);
-#endif
-  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-
-  p->th = GNUNET_TRANSPORT_connect (sched, p->cfg,
-                                    p,
-                                    &notify_receive,
-                                    &notify_connect, &notify_disconnect);
-  GNUNET_assert (p->th != NULL);
+  struct PeerContext *p = cls;
+  char *ps = GNUNET_strdup (GNUNET_i2s (&p->id));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer %u (`%4s'): peer (`%s') disconnected from me!\n", p->no, ps,
+              GNUNET_i2s (peer));
+
+  GNUNET_free (ps);
+
+  if (th != NULL)
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
+  th = NULL;
 }
 
 
 static void
 }
 
 
 static void
-exchange_hello_last (void *cls,
-                     const struct GNUNET_MessageHeader *message)
+testing_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls)
 {
 {
-  struct PeerContext *me = cls;
+  cc = NULL;
+  char *p1_c = GNUNET_strdup (GNUNET_i2s (&p1->id));
 
 
-  GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, me);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Exchanging HELLO with peer (%p)!\n", cls);
-  GNUNET_assert (ok >= 3);
-  OKPP;
-  GNUNET_assert (message != NULL);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
-                                      message, &me->id));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Finished exchanging HELLOs, now waiting for transmission!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected: %u (%s) <-> %u (%s)\n",
+              p1->no, p1_c, p2->no, GNUNET_i2s (&p2->id));
+  GNUNET_free (p1_c);
+
+  s_connected = GNUNET_YES;
+  send_task = GNUNET_SCHEDULER_add_now (&sendtask, NULL);
 }
 
 }
 
+
 static void
 static void
-exchange_hello (void *cls,
-                const struct GNUNET_MessageHeader *message)
+start_cb (struct PeerContext *p, void *cls)
 {
 {
-  struct PeerContext *me = cls;
+  static int started;
 
 
-  GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, me);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Exchanging HELLO with peer (%p)!\n", cls);
-  GNUNET_assert (ok >= 2);
-  OKPP;
-  GNUNET_assert (message != NULL);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
-                                      message, &me->id));
+  started++;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer %u (`%s') started\n", p->no,
+              GNUNET_i2s (&p->id));
+
+  if (started != 2)
+    return;
+  else
+    s_started = GNUNET_YES;
+  char *sender_c = GNUNET_strdup (GNUNET_i2s (&p1->id));
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received HELLO size %d\n", GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message));
+              "Test tries to connect peer %u (`%s') -> peer %u (`%s')\n",
+              p1->no, sender_c, p2->no, GNUNET_i2s (&p2->id));
+  GNUNET_free (sender_c);
+
+  cc = GNUNET_TRANSPORT_TESTING_connect_peers (tth, p1, p2, &testing_connect_cb,
+                                               NULL);
 
 
-  GNUNET_TRANSPORT_offer_hello (p2.th, message);
-  GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
 }
 
 }
 
+
 static void
 static void
-run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
-     char *const *args,
-     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
 {
-  GNUNET_assert (ok == 1);
-  OKPP;
-  sched = s;
-
-  die_task = GNUNET_SCHEDULER_add_delayed (sched,
-      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 1), &end_badly, NULL);
-
-  if (is_udp)
-    {
-      setup_peer (&p1, "test_transport_api_udp_peer1.conf");
-      setup_peer (&p2, "test_transport_api_udp_peer2.conf");
-    }
-  else if (is_tcp)
-    {
-      setup_peer (&p1, "test_transport_api_tcp_peer1.conf");
-      setup_peer (&p2, "test_transport_api_tcp_peer2.conf");
-    }
-  else if (is_tcp_nat)
-    {
-      setup_peer (&p1, "test_transport_api_tcp_nat_peer1.conf");
-      setup_peer (&p2, "test_transport_api_tcp_nat_peer2.conf");
-    }
-  else if (is_udp_nat)
-    {
-      setup_peer (&p1, "test_transport_api_udp_nat_peer1.conf");
-      setup_peer (&p2, "test_transport_api_udp_nat_peer2.conf");
-    }
-  else if (is_http)
-    {
-      setup_peer (&p1, "test_transport_api_http_peer1.conf");
-      setup_peer (&p2, "test_transport_api_http_peer2.conf");
-    }
-
-  GNUNET_assert(p1.th != NULL);
-  GNUNET_assert(p2.th != NULL);
-
-  GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+
+  s_started = GNUNET_NO;
+  s_connected = GNUNET_NO;
+  s_sending = GNUNET_NO;
+
+  p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, cfg_file_p1, 1,
+                                            &notify_receive, &notify_connect,
+                                            &notify_disconnect, &start_cb,
+                                            NULL);
+
+  p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, cfg_file_p2, 2,
+                                            &notify_receive, &notify_connect,
+                                            &notify_disconnect, &start_cb,
+                                            NULL);
+
+  if ((p1 == NULL) || (p2 == NULL))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Fail! Could not start peers!\n");
+    if (die_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (die_task);
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
 }
 
 }
 
+
 static int
 check ()
 {
 static int
 check ()
 {
-
-  char *const argv[] = { "test-transport-api",
+  static char *const argv[] = { "test-transport-api",
     "-c",
     "test_transport_api_data.conf",
     "-c",
     "test_transport_api_data.conf",
-#if VERBOSE
-    "-L", "DEBUG",
-#endif
     NULL
   };
     NULL
   };
-
-#if WRITECONFIG
-  setTransportOptions("test_transport_api_data.conf");
-#endif
-
-  struct GNUNET_GETOPT_CommandLineOption options[] = {
+  static struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
 
     GNUNET_GETOPT_OPTION_END
   };
 
-  ok = 1;
-  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-transport-api", "nohelp",
-                      options, &run, &ok);
-  stop_arm (&p1);
-  stop_arm (&p2);
-  return ok;
-}
-
-
-static char *
-get_path_from_PATH ()
-{
-  char *path;
-  char *pos;
-  char *end;
-  char *buf;
-  const char *p;
-
-  p = getenv ("PATH");
-  if (p == NULL)
-    return NULL;
-  path = GNUNET_strdup (p);     /* because we write on it */
-  buf = GNUNET_malloc (strlen (path) + 20);
-  pos = path;
-
-  while (NULL != (end = strchr (pos, ':')))
-    {
-      *end = '\0';
-      sprintf (buf, "%s/%s", pos, "gnunet-nat-server");
-      if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
-        {
-          GNUNET_free (path);
-          return buf;
-        }
-      pos = end + 1;
-    }
-  sprintf (buf, "%s/%s", pos, "gnunet-nat-server");
-  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
-    {
-      GNUNET_free (path);
-      return buf;
-    }
-  GNUNET_free (buf);
-  GNUNET_free (path);
-  return NULL;
-}
+  send_task = GNUNET_SCHEDULER_NO_TASK;
 
 
+  ok = 1;
+  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv, test_name,
+                      "nohelp", options, &run, &ok);
 
 
-static int 
-check_gnunet_nat_server()
-{
-  struct stat statbuf;
-  char *p;
-
-  p = get_path_from_PATH ();
-  if (p == NULL)
-    return GNUNET_NO;
-  if (0 != STAT (p, &statbuf))
-    {
-      GNUNET_free (p);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free (p);
-  if ( (0 != (statbuf.st_mode & S_ISUID)) && 
-       (statbuf.st_uid == 0) )    
-    return GNUNET_YES;
-  return GNUNET_NO;
+  return ok;
 }
 
 int
 main (int argc, char *argv[])
 {
   int ret;
 }
 
 int
 main (int argc, char *argv[])
 {
   int ret;
-#ifdef MINGW
-  return GNUNET_SYSERR;
-#endif
-  if (strstr(argv[0], "tcp_nat") != NULL)
-    {
-      is_tcp_nat = GNUNET_YES;
-      if (check_gnunet_nat_server() != GNUNET_OK)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "`%s' not properly installed, cannot run NAT test!\n",
-                      "gnunet-nat-server");
-          return 0;
-        }
-    }
-  else if (strstr(argv[0], "tcp") != NULL)
-    {
-      is_tcp = GNUNET_YES;
-    }
-  else if (strstr(argv[0], "udp_nat") != NULL)
-    {
-      is_udp_nat = GNUNET_YES;
-      if (check_gnunet_nat_server() != GNUNET_OK)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "`%s' not properly installed, cannot run NAT test!\n",
-                     "gnunet-nat-server");
-          return 0;
-        }
-    }
-  else if (strstr(argv[0], "udp") != NULL)
-    {
-      is_udp = GNUNET_YES;
-    }
-  else if (strstr(argv[0], "http") != NULL)
-    {
-      is_http = GNUNET_YES;
-    }
-
-  GNUNET_log_setup ("test-transport-api",
-#if VERBOSE
-                    "DEBUG",
-#else
+
+  GNUNET_TRANSPORT_TESTING_get_test_name (argv[0], &test_name);
+  GNUNET_TRANSPORT_TESTING_get_test_source_name (__FILE__, &test_source);
+  GNUNET_TRANSPORT_TESTING_get_test_plugin_name (argv[0], test_source,
+                                                 &test_plugin);
+
+  GNUNET_log_setup (test_name,
                     "WARNING",
                     "WARNING",
-#endif
                     NULL);
                     NULL);
+  tth = GNUNET_TRANSPORT_TESTING_init ();
+
+  GNUNET_TRANSPORT_TESTING_get_config_name (argv[0], &cfg_file_p1, 1);
+  GNUNET_TRANSPORT_TESTING_get_config_name (argv[0], &cfg_file_p2, 2);
+
   ret = check ();
   ret = check ();
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-transport-peer-1");
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-transport-peer-2");
+
+  GNUNET_free (cfg_file_p1);
+  GNUNET_free (cfg_file_p2);
+
+  GNUNET_free (test_source);
+  GNUNET_free (test_plugin);
+  GNUNET_free (test_name);
+
+  GNUNET_TRANSPORT_TESTING_done (tth);
+
   return ret;
 }
 
   return ret;
 }
 
Unnamed repository; edit this file 'description' to name the repository.