From 53c1c40f7ea78892a3b3d8f95557ef53873565a7 Mon Sep 17 00:00:00 2001
From: Matthias Wachs <wachs@net.in.tum.de>
Date: Wed, 6 Jul 2011 15:45:29 +0000
Subject: new and modified testcases

---
 src/transport/test_transport_ats.c                | 777 ++------------------
 src/transport/test_transport_ats_multiple_peers.c | 828 ++++++++++++++++++++++
 2 files changed, 869 insertions(+), 736 deletions(-)
 create mode 100644 src/transport/test_transport_ats_multiple_peers.c

(limited to 'src/transport')

diff --git a/src/transport/test_transport_ats.c b/src/transport/test_transport_ats.c
index 314d78172..41d1ff0d6 100644
--- a/src/transport/test_transport_ats.c
+++ b/src/transport/test_transport_ats.c
@@ -19,726 +19,56 @@
 */
 /**
  * @file testing/test_transport_ats.c
- * @brief testcase for ats functionality
+ * @brief testcase for ats functionality without starting peers
  */
 #include "platform.h"
-#include "gnunet_testing_lib.h"
-#include "gnunet_transport_service.h"
-#include "gnunet_scheduler_lib.h"
-#include "gauger.h"
+#include "transport_ats.h"
+#include "gnunet_configuration_lib.h"
 
-#define VERBOSE GNUNET_NO
+#define VERBOSE GNUNET_YES
 
-#define NUM_PEERS 11
-#define MEASUREMENTS 5
+struct GNUNET_CONFIGURATION_Handle *cfg;
 
-#define DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
-#define SEND_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
+static struct ATS_Handle * ats;
 
-#define ATS_NEW 0
-#define ATS_Q_UPDATED 1
-#define ATS_C_UPDATED 2
-#define ATS_QC_UPDATED 3
-#define ATS_UNMODIFIED 4
 
-static int ok;
-
-static int peers_left;
-
-static int failed_peers;
-
-static int measurement_started = GNUNET_NO;
-static char * config_file;
-
-static struct GNUNET_TESTING_PeerGroup *pg;
-
-static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
-static GNUNET_SCHEDULER_TaskIdentifier stats_task;
-static GNUNET_SCHEDULER_TaskIdentifier send_task;
-struct GNUNET_TESTING_Daemon * master_deamon;
-struct GNUNET_TESTING_Daemon * ping_deamon;
-
-struct GNUNET_STATISTICS_Handle * stats;
-
-struct TEST_result
-{
-  uint64_t timestamp;
-  uint64_t duration;
-  uint64_t mechs;
-  uint64_t peers;
-  uint64_t solution;
-  uint64_t state;
-};
-
-struct TestMessage
-{
-  struct GNUNET_MessageHeader header;
-  uint32_t num;
-};
-
-
-static int count;
-static int c_new;
-static int c_unmodified;
-static int c_modified;
-static int connected;
-static int peers;
-
-static int force_q_updates;
-static int force_rebuild;
-static int send_msg;
-static int machine_parsable;
-
-static struct TEST_result results_new       [MEASUREMENTS+1];
-static struct TEST_result results_modified  [MEASUREMENTS+1];
-static struct TEST_result results_unmodified[MEASUREMENTS+1];
-static struct TEST_result current;
-
-static struct GNUNET_STATISTICS_GetHandle * s_solution;
-static struct GNUNET_STATISTICS_GetHandle * s_time;
-static struct GNUNET_STATISTICS_GetHandle * s_peers;
-static struct GNUNET_STATISTICS_GetHandle * s_mechs;
-static struct GNUNET_STATISTICS_GetHandle * s_duration;
-static struct GNUNET_STATISTICS_GetHandle * s_invalid;
-static struct GNUNET_STATISTICS_GetHandle * s_state;
-
-struct GNUNET_TRANSPORT_TransmitHandle * t;
-struct GNUNET_TRANSPORT_Handle * th;
-
-/**
- * Check whether peers successfully shut down.
- */
-static void
-shutdown_callback (void *cls, const char *emsg)
-{
-  if (emsg != NULL)
-    {
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-		  "Shutdown of peers failed!\n");
-#endif
-      if (ok == 0)
-        ok = 666;
-    }
-  else
-    {
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All peers successfully shut down!\n");
-      	if (stats != NULL)
-      		GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
-      	stats = NULL;
-#endif
-    }
-}
-
-static void
-shutdown_peers()
-{
-  if (shutdown_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(shutdown_task);
-      shutdown_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(stats_task);
-      stats_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  if (send_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(send_task);
-      send_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  
-  if (t != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
-      t = NULL;
-    }
-  GNUNET_TRANSPORT_disconnect(th);  
-  if (s_time != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_time);
-      s_time = NULL;
-    }
-  if (s_peers != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_peers);
-      s_peers = NULL;
-    }
-  if (s_mechs != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_mechs);
-      s_mechs = NULL;
-    }
-  if (s_solution != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_solution);
-      s_solution = NULL;
-    }
-  if (s_duration != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_duration);
-      s_duration = NULL;
-    }
-  if (s_invalid != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_invalid);
-      s_invalid = NULL;
-    }
-  if (s_state != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_state);
-      s_state = NULL;
-    }
-  GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
-}
-
-static void 
-evaluate_measurements()
-{
-  int c;
-  //int mechs = 0;
-  double average[3];
-  double stddev[3];
-  //char * output;
-  c = 1;
-  
-  //GNUNET_asprintf(&output, "p,%i,m,%i,",peers, MEASUREMENTS, results_modified[0].mechs,
-  
-  average[0] = 0.0;
-  for (c=0; c<c_new;c++)
-    {
-      average[0] += (double) results_new[c].duration;
-    }
-  average[0] /= c_new;
-  
-  stddev[0] = 0.0;
-  for (c=0; c<c_new;c++)
-    {
-      stddev[0] += (results_new[c].duration - average[0]) * (results_new[c].duration - average[0]);
-    }
-  stddev[0] /= c_new;
-  stddev[0] = sqrt (stddev[0]);
-  if (!machine_parsable)
-    fprintf (stderr,
-	     "new, %i measurements, average: %f stddev: %f\n",
-	     c_new, average[0], stddev[0]);
-  
-  average[1] = 0.0;
-  for (c=0; c<c_modified;c++)
-    {
-      average[1] += (double) results_modified[c].duration;
-    }
-  average[1] /= c_modified;
-  
-  stddev[1] = 0.0;
-  for (c=0; c<c_modified;c++)
-    {
-      stddev[1] += (results_modified[c].duration - average[1]) * (results_modified[c].duration - average[1]);
-    }
-  stddev[1] /= c_modified;
-  stddev[1] = sqrt (stddev[1]);
-  if (!machine_parsable) 
-    fprintf (stderr,
-	     "modified, %i measurements, average: %f stddev: %f\n",
-	     c_modified, average[1], stddev[1]);
-  
-  average[2] = 0.0;
-  for (c=0; c<c_unmodified;c++)
-    {
-      average[2] += (double) results_unmodified[c].duration;
-    }
-  average[2] /= c_unmodified;
-  stddev[2] = 0.0;
-  for (c=0; c<c_unmodified;c++)
-    {
-      stddev[2] += (results_unmodified[c].duration - average[2]) * (results_unmodified[c].duration - average[2]);
-    }
-  stddev[2] /= c_unmodified;
-  stddev[2] = sqrt (stddev[2]);
-  
-  if (!machine_parsable) 
-    fprintf (stderr,
-	     "unmodified, %i measurements, average: %f stddev: %f\n",
-	     c_unmodified, average[2], stddev[2]);
-  
-  if (machine_parsable)
-    fprintf (stderr,
-	     "peers,%i,mechs,%llu,"
-	     "new,%i,%f,%f,"
-	     "mod,%i,%f,%f,"
-	     "unmod,%i,%f,%f\n",
-	     peers-1, (unsigned long long) results_unmodified[0].mechs,
-	     c_new, average[0], stddev[0],
-	     c_modified, average[1], stddev[1],
-	     c_unmodified, average[2], stddev[2]);
-  shutdown_peers();
-}
-
-
-static int 
-stats_cb (void *cls,
-	  const char *subsystem,
-	  const char *name,
-	  uint64_t value,
-	  int is_persistent)
-{
-  static int printed = GNUNET_NO;
-  //GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s = %llu\n", name ,value);
-  if (0 == strcmp (name,"ATS invalid solutions"))
-    {
-      if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-	{
-	  GNUNET_SCHEDULER_cancel(stats_task);
-	  stats_task = GNUNET_SCHEDULER_NO_TASK;
-	}
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"MLP produced invalid %llu result(s)!\n", value);
-      shutdown_peers();
-      return GNUNET_SYSERR;
-    }
-  
-  if (0 == strcmp (name,"ATS solution"))
-    {
-      s_solution = NULL;
-    }
-  
-  if (0 == strcmp (name,"ATS peers"))
-    {
-      s_peers = NULL;
-    }
-  
-  if (0 == strcmp (name,"ATS mechanisms"))
-    {
-      s_mechs = NULL;
-    }
-  
-  if (0 == strcmp (name,"ATS duration"))
-    {
-      s_duration = NULL;
-    }
-  if (0 == strcmp (name,"ATS timestamp"))
-    {
-      s_time = NULL;
-    }
-  if (0 == strcmp (name,"ATS state"))
-    {
-      s_state = NULL;
-    }
-  
-  if ( (measurement_started == GNUNET_NO) && 
-       (0 == strcmp (name, "ATS peers")) && 
-       (value == peers-1) )
-    {
-      measurement_started = GNUNET_YES;
-      count = 1;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-		  "All %llu peers connected\n", 
-		  value);
-#if !VERBOSE
-      if (! machine_parsable)	
-	fprintf(stderr, "%i", count);
-#endif
-    }
-  
-  if (measurement_started == GNUNET_YES)
-    {
-      // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s == %llu\n", name ,value);
-      if (0 == strcmp (name,"ATS timestamp"))
-	{
-	  if (current.timestamp == 0)
-	    {
-	      printed = GNUNET_NO;
-	      current.timestamp = value;
-	    }
-	  if (current.timestamp == value)
-	    {
-	      printed = GNUNET_YES;
-	    }
-	  if (current.timestamp != value)
-	    {
-	      if (current.state == ATS_NEW)
-		{
-		  if (c_new < MEASUREMENTS)
-		    {
-		      results_new[c_new] = current;
-		      c_new++;
-		    }
-		  else
-		    {
-		      force_rebuild = GNUNET_NO;
-		      force_q_updates = GNUNET_NO;
-		      send_msg = GNUNET_NO;
-		    }
-		}
-	      if (current.state == ATS_UNMODIFIED)
-		{
-		  if (c_unmodified < MEASUREMENTS)
-		    {
-		      results_unmodified[c_unmodified] = current;
-		      c_unmodified++;
-		    }
-		  
-		}
-	      if (current.state == ATS_Q_UPDATED)
-		{
-		  if (c_modified < MEASUREMENTS)
-		    {
-		      results_modified[c_modified] = current;
-		      c_modified++;
-		    }
-		  else
-		    {
-		      force_q_updates = GNUNET_NO;
-		      force_rebuild = GNUNET_YES;
-		    }
-		}
-	      count ++;
-#if VERBOSE
-	      fprintf (stderr,
-		       "(new: %i / modified: %i / unmodified: %i) of %i \n", 
-		       c_new, c_modified, c_unmodified , MEASUREMENTS);
-#endif
-	      if ((c_modified >= MEASUREMENTS) && (c_new >= MEASUREMENTS) && (c_unmodified >= MEASUREMENTS))
-		{
-#if !VERBOSE
-		  if (!machine_parsable)
-		    fprintf(stdout, "\n");
-#endif
-		  if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-		    {
-		      GNUNET_SCHEDULER_cancel(stats_task);
-		      stats_task = GNUNET_SCHEDULER_NO_TASK;
-		    }
-		  evaluate_measurements();
-		  return GNUNET_SYSERR;
-		}
-	      
-	      printed = GNUNET_NO;
-	      current.timestamp = value;
-#if !VERBOSE
-	      if (! machine_parsable)
-		fprintf(stderr, "..%i", count);
-#endif
-	      return GNUNET_OK;
-	    }
-	}
-      
-      if (0 == strcmp (name,"ATS solution"))
-	{
-	  current.solution = value;
-	  if (printed == GNUNET_NO)
-	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
-	}
-      
-      if (0 == strcmp (name,"ATS peers"))
-	{
-	  current.peers = value;
-	  if (printed == GNUNET_NO)
-	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
-	}
-      
-      if (0 == strcmp (name,"ATS mechanisms"))
-	{
-	  current.mechs = value;
-	  if (printed == GNUNET_NO) 
-	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
-	}
-      
-      if (0 == strcmp (name,"ATS duration"))
-	{
-	  current.duration = value;
-	  if (printed == GNUNET_NO) 
-	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n", count, name, value);
-	}
-      if (0 == strcmp (name,"ATS state"))
-	{
-	  current.state = value;
-	  char * cont;
-	  if (value == ATS_NEW)
-	    cont = "NEW";
-	  if (value == ATS_C_UPDATED)
-	    cont = "C_UPDATED";
-	  if (value == ATS_Q_UPDATED)
-	    cont = "Q_UPDATED";
-	  if (value == ATS_QC_UPDATED)
-	    cont = "QC_UPDATED";
-	  if (value == ATS_UNMODIFIED)
-	    cont = "UNMODIFIED";
-	  if (printed == GNUNET_NO) 
-	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-			"[%i] ATS state: %s\n", count, cont);
-	}
-    }
-  return GNUNET_OK;
-}
-
-
-static void
-stats_get_task (void *cls,
-		const struct GNUNET_SCHEDULER_TaskContext *tc)
+int init_ats (void)
 {
-  stats_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    return;
-  
-  s_time = GNUNET_STATISTICS_get (stats, "transport", "ATS timestamp", TIMEOUT, NULL, &stats_cb, NULL);
-  s_solution = GNUNET_STATISTICS_get (stats, "transport", "ATS solution", TIMEOUT, NULL, &stats_cb, NULL);
-  s_duration = GNUNET_STATISTICS_get (stats, "transport","ATS duration", TIMEOUT, NULL, &stats_cb, NULL);
-  s_peers = GNUNET_STATISTICS_get (stats, "transport", "ATS peers", TIMEOUT, NULL, &stats_cb, NULL);
-  s_mechs = GNUNET_STATISTICS_get (stats, "transport", "ATS mechanisms", TIMEOUT, NULL, &stats_cb, NULL);
-  s_invalid = GNUNET_STATISTICS_get (stats, "transport", "ATS invalid solutions", TIMEOUT, NULL, &stats_cb, NULL);
-  s_state = GNUNET_STATISTICS_get (stats, "transport", "ATS state", TIMEOUT, NULL, &stats_cb, NULL);
-  
-  stats_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100),
-					    &stats_get_task, NULL);
-}
+  int ret = 0;
 
+  //ats = ats_init(cfg);
+  //GNUNET_assert (ats != NULL);
 
-static void
-delay (void *cls,
-       const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  shutdown_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    return;
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-	      "Delay over\n");
-#endif
-  shutdown_peers ();
-}
-
-static void
-connect_peers()
-{
-  shutdown_task = GNUNET_SCHEDULER_add_delayed(DELAY, &delay, NULL);
-}
-
-static size_t 
-send_dummy_data_task (void *cls, size_t size, void *buf)
-{
-  int s = sizeof (struct TestMessage);
-  struct TestMessage hdr;
-  
-  hdr.header.size = htons (s);
-  hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ATS);
-  if (force_rebuild)
-    hdr.num = htonl (1);
-  if (force_q_updates)
-    hdr.num = htonl (2);
-  memcpy (buf,&hdr, s);
-  // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i of %i\n", s, s);
-  t  = NULL;
-  return s;
-}
-
-
-static void 
-send_task_f (void *cls,
-	     const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  send_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    return;
-  
-  if (t!=NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
-      t = NULL;
-    }
-  // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i to %s\n", size, GNUNET_i2s(&master_deamon->id));
-  if (send_msg == GNUNET_YES)
-    t = GNUNET_TRANSPORT_notify_transmit_ready(th, 
-					       &master_deamon->id, 
-					       sizeof (struct TestMessage), 0, 
-					       SEND_TIMEOUT, 
-					       &send_dummy_data_task, NULL);
-  send_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,1000), 
-					   &send_task_f, NULL);
-}
-
-static void
-notify_connect (void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_TRANSPORT_ATS_Information *ats,
-                uint32_t ats_count)
-{
-  send_task = GNUNET_SCHEDULER_add_now(&send_task_f, NULL);
-}
-
-static void
-notify_disconnect (void *cls,
-		   const struct GNUNET_PeerIdentity *peer)
-{
-  if (GNUNET_SCHEDULER_NO_TASK != send_task)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-		  "Disconnect event before transmission request could be scheduled!\n");
-      GNUNET_SCHEDULER_cancel (send_task);
-      send_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  if (NULL != t)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-		  "Disconnect event before transmission request could be completed!\n");
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
-      t = NULL;
-    }
-}
-
-static void 
-daemon_connect_cb(void *cls,
-		  const struct GNUNET_PeerIdentity *first,
-		  const struct GNUNET_PeerIdentity *second,
-		  uint32_t distance,
-		  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)
-{
-  char * firstc =  strdup(GNUNET_i2s(first));
-  char * secondc =  strdup(GNUNET_i2s(second));
-  connected++;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-	      "Connected peers `%s'<->`%s' (%i/%i)\n", 
-	      firstc, secondc, connected, peers-1);
-  GNUNET_free(firstc);
-  GNUNET_free(secondc);
-  
-  if ( ( (first_daemon == ping_deamon) || 
-	 (second_daemon == ping_deamon) ) && 
-       (master_deamon != NULL) && 
-       (ping_deamon != NULL) )
-    {
-      th = GNUNET_TRANSPORT_connect (ping_deamon->cfg,
-				     &ping_deamon->id, 
-				     NULL, NULL,
-				     &notify_connect, 
-				     &notify_disconnect);
-      force_q_updates = GNUNET_YES;
-      send_msg = GNUNET_YES;
-    }
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Initializing ATS: %s \n", (ret==0)? "SUCCESFULL": "FAILED");
+  return ret;
 }
 
 
-
-static void
-daemon_start_cb (void *cls,
-		 const struct GNUNET_PeerIdentity *id,
-		 const struct GNUNET_CONFIGURATION_Handle *cfg,
-		 struct GNUNET_TESTING_Daemon *d, const char *emsg)
+int shutdown_ats (void)
 {
-  if (id == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Start callback called with error (too long starting peers), aborting test!\n");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-		  "Error from testing: `%s'\n");
-      failed_peers++;
-      if (failed_peers == peers_left)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Too many peers failed, ending test!\n");
-          ok = 1;
-      	shutdown_peers ();
-        }
-      return;
-    }
-  peers_left--;
+  int ret = 0;
 
-  if (master_deamon == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-		  "Master peer `%s' '%s'\n",
-		  GNUNET_i2s(id), d->cfgfile);      
-      master_deamon = d;
-      stats = GNUNET_STATISTICS_create("transport", master_deamon->cfg);
-      GNUNET_assert (stats != NULL);
-      stats_task = GNUNET_SCHEDULER_add_now(&stats_get_task, NULL);
-    }
-  else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-		  "Connecting peer `%s'\n", 
-		  GNUNET_i2s(id), GNUNET_i2s(&master_deamon->id));
-      GNUNET_TESTING_daemons_connect(d, master_deamon, TIMEOUT, 0, GNUNET_YES,&daemon_connect_cb, NULL);
-    }
-  
-  if (peers_left == 0)
-    {
-      if (ping_deamon == NULL)
-	{
-	  ping_deamon = d;
-	  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-		      "Ping peer `%s' '%s'\n", GNUNET_i2s(id), d->cfgfile);
-	}
-      
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All peers started successfully!\n");
-      connect_peers();
-      ok = 0;
-    }
-  else if (failed_peers == peers_left)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Too many peers failed, ending test!\n");
-      shutdown_peers();
-      ok = 1;
-    }
-}
-
-
-static void
-run (void *cls,
-     char *const *args,
-     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
-{
-  ok = 1;
-  measurement_started = GNUNET_NO;
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting %i peers.\n", peers);
-#endif
-  peers_left = peers;
-  pg = GNUNET_TESTING_daemons_start (cfg,
-                                     peers_left, /* Total number of peers */
-                                     peers_left, /* Number of outstanding connections */
-                                     peers_left, /* Number of parallel ssh connections, or peers being started at once */
-                                     TIMEOUT,
-                                     NULL, NULL,
-                                     &daemon_start_cb, NULL, NULL, NULL, NULL);
-  GNUNET_assert (pg != NULL);
+  //ats_delete_problem (ats);
+  //ats_shutdown (ats);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Shutdown ATS: %s \n", (ret==0)? "SUCCESFULL": "FAILED");
+  return ret;
 }
 
-
-static int
-check ()
+/* To make compiler happy */
+void dummy(void)
 {
-  char *const argv[] = { "test-testing",
-    "-c",
-    config_file,
-#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-transport-ats", "nohelp",
-                      options, &run, &ok);
-  return ok;
+  struct ATS_quality_metric * q = qm;
+  q = NULL;
+  struct ATS_ressource * r = ressources;
+  r = NULL;
 }
 
-
 int
 main (int argc, char *argv[])
 {
-  int ret;
+  int ret = 0;
 
   GNUNET_log_setup ("test-transport-ats",
 #if VERBOSE
@@ -747,53 +77,28 @@ main (int argc, char *argv[])
                     "INFO",
 #endif
                     NULL);
+#if !HAVE_LIBGLPK
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "HAVE_LIBGLPK not set, exiting testcase\n");
+#endif
 
 #if !HAVE_LIBGLPK
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-	      "GLPK not installed, exiting testcase\n");
-  return 0;
+  return ret;
 #endif
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
-  machine_parsable = GNUNET_NO;
-  peers = NUM_PEERS;
-  config_file = "test_transport_ats_4addr.conf";
 
-  int c = 0;
-  if (argc >= 2)
-    {
-      for (c=0; c<argc; c++)
-	{
-	  /* set peers */
-	  if ((strcmp(argv[c], "-p") == 0) && c < (argc-1))
-	    {
-	      peers = atoi(argv[c+1]);
-	      peers++;
-	    }
-	  /* set machine parsable */
-	  if (strcmp(argv[c], "-m") == 0)
-	    {
-	      machine_parsable = GNUNET_YES;
-	    }
-	  /* set config file */
-	  if ((strcmp(argv[c], "-c") == 0) && c < (argc-1))
-	    {
-	      config_file = argv[c+1];
-	    }
-	 }
-    }
 
+  cfg = GNUNET_CONFIGURATION_create();
+  GNUNET_CONFIGURATION_load(cfg, "test_transport_ats_1addr.conf");
 
+  /* Testing */
+  ats = NULL;
+  ret += init_ats ();
+  ret += shutdown_ats ();
 
-  ret = check ();
-  /**
-   * Still need to remove the base testing directory here,
-   * because group starts will create subdirectories under this
-   * main dir.  However, we no longer need to sleep, as the
-   * shutdown sequence won't return until everything is cleaned
-   * up.
-   */
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
+  /* Shutdown */
+  GNUNET_CONFIGURATION_destroy(cfg);
   return ret;
+
 }
 
 /* end of test_transport_ats.c*/
diff --git a/src/transport/test_transport_ats_multiple_peers.c b/src/transport/test_transport_ats_multiple_peers.c
new file mode 100644
index 000000000..e0cf58c6d
--- /dev/null
+++ b/src/transport/test_transport_ats_multiple_peers.c
@@ -0,0 +1,828 @@
+/*
+     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 3, 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_transport_ats_multiple_peers.c
+ * @brief testcase for ats functionality by starting multiple peers
+ */
+#include "platform.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_transport_service.h"
+#include "gnunet_scheduler_lib.h"
+#include "gauger.h"
+
+#define VERBOSE GNUNET_NO
+
+#define NUM_PEERS 11
+#define MEASUREMENTS 5
+
+#define DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
+#define SEND_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
+
+#define ATS_NEW 0
+#define ATS_Q_UPDATED 1
+#define ATS_C_UPDATED 2
+#define ATS_QC_UPDATED 3
+#define ATS_UNMODIFIED 4
+
+static int ok;
+
+static int peers_left;
+
+static int failed_peers;
+
+static int measurement_started = GNUNET_NO;
+static char * config_file;
+
+static struct GNUNET_TESTING_PeerGroup *pg;
+
+static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
+static GNUNET_SCHEDULER_TaskIdentifier stats_task;
+static GNUNET_SCHEDULER_TaskIdentifier send_task;
+struct GNUNET_TESTING_Daemon * master_deamon;
+struct GNUNET_TESTING_Daemon * ping_deamon;
+
+struct GNUNET_STATISTICS_Handle * stats;
+
+struct TEST_result
+{
+  uint64_t timestamp;
+  uint64_t duration;
+  uint64_t mechs;
+  uint64_t peers;
+  uint64_t solution;
+  uint64_t state;
+};
+
+struct TestMessage
+{
+  struct GNUNET_MessageHeader header;
+  uint32_t num;
+};
+
+
+static int count;
+static int c_new;
+static int c_unmodified;
+static int c_modified;
+static int connected;
+static int peers;
+
+static int force_q_updates;
+static int force_rebuild;
+static int send_msg;
+static int machine_parsable;
+
+static struct TEST_result results_new       [MEASUREMENTS+1];
+static struct TEST_result results_modified  [MEASUREMENTS+1];
+static struct TEST_result results_unmodified[MEASUREMENTS+1];
+static struct TEST_result current;
+
+static struct GNUNET_STATISTICS_GetHandle * s_solution;
+static struct GNUNET_STATISTICS_GetHandle * s_time;
+static struct GNUNET_STATISTICS_GetHandle * s_peers;
+static struct GNUNET_STATISTICS_GetHandle * s_mechs;
+static struct GNUNET_STATISTICS_GetHandle * s_duration;
+static struct GNUNET_STATISTICS_GetHandle * s_invalid;
+static struct GNUNET_STATISTICS_GetHandle * s_state;
+
+struct GNUNET_TRANSPORT_TransmitHandle * t;
+struct GNUNET_TRANSPORT_Handle * th;
+
+/**
+ * Check whether peers successfully shut down.
+ */
+static void
+shutdown_callback (void *cls, const char *emsg)
+{
+  if (emsg != NULL)
+    {
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+		  "Shutdown of peers failed!\n");
+#endif
+      if (ok == 0)
+        ok = 666;
+    }
+  else
+    {
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "All peers successfully shut down!\n");
+      	if (stats != NULL)
+      		GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
+      	stats = NULL;
+#endif
+    }
+}
+
+static void
+shutdown_peers()
+{
+  if (shutdown_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel(shutdown_task);
+      shutdown_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+  if (stats_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel(stats_task);
+      stats_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+  if (send_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel(send_task);
+      send_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+  
+  if (t != NULL)
+    {
+      GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
+      t = NULL;
+    }
+  GNUNET_TRANSPORT_disconnect(th);  
+  if (s_time != NULL)
+    {
+      GNUNET_STATISTICS_get_cancel(s_time);
+      s_time = NULL;
+    }
+  if (s_peers != NULL)
+    {
+      GNUNET_STATISTICS_get_cancel(s_peers);
+      s_peers = NULL;
+    }
+  if (s_mechs != NULL)
+    {
+      GNUNET_STATISTICS_get_cancel(s_mechs);
+      s_mechs = NULL;
+    }
+  if (s_solution != NULL)
+    {
+      GNUNET_STATISTICS_get_cancel(s_solution);
+      s_solution = NULL;
+    }
+  if (s_duration != NULL)
+    {
+      GNUNET_STATISTICS_get_cancel(s_duration);
+      s_duration = NULL;
+    }
+  if (s_invalid != NULL)
+    {
+      GNUNET_STATISTICS_get_cancel(s_invalid);
+      s_invalid = NULL;
+    }
+  if (s_state != NULL)
+    {
+      GNUNET_STATISTICS_get_cancel(s_state);
+      s_state = NULL;
+    }
+  GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
+}
+
+static void 
+evaluate_measurements()
+{
+  int c;
+  //int mechs = 0;
+  double average[3];
+  double stddev[3];
+  //char * output;
+  c = 1;
+  
+  //GNUNET_asprintf(&output, "p,%i,m,%i,",peers, MEASUREMENTS, results_modified[0].mechs,
+  
+  average[0] = 0.0;
+  for (c=0; c<c_new;c++)
+    {
+      average[0] += (double) results_new[c].duration;
+    }
+  average[0] /= c_new;
+  
+  stddev[0] = 0.0;
+  for (c=0; c<c_new;c++)
+    {
+      stddev[0] += (results_new[c].duration - average[0]) *
+          (results_new[c].duration - average[0]);
+    }
+  stddev[0] /= c_new;
+  stddev[0] = sqrt (stddev[0]);
+  if (!machine_parsable)
+    fprintf (stderr,
+	     "new, %i measurements, average: %f stddev: %f\n",
+	     c_new, average[0], stddev[0]);
+  
+  average[1] = 0.0;
+  for (c=0; c<c_modified;c++)
+    {
+      average[1] += (double) results_modified[c].duration;
+    }
+  average[1] /= c_modified;
+  
+  stddev[1] = 0.0;
+  for (c=0; c<c_modified;c++)
+    {
+      stddev[1] += (results_modified[c].duration - average[1]) *
+          (results_modified[c].duration - average[1]);
+    }
+  stddev[1] /= c_modified;
+  stddev[1] = sqrt (stddev[1]);
+  if (!machine_parsable) 
+    fprintf (stderr,
+	     "modified, %i measurements, average: %f stddev: %f\n",
+	     c_modified, average[1], stddev[1]);
+  
+  average[2] = 0.0;
+  for (c=0; c<c_unmodified;c++)
+    {
+      average[2] += (double) results_unmodified[c].duration;
+    }
+  average[2] /= c_unmodified;
+  stddev[2] = 0.0;
+  for (c=0; c<c_unmodified;c++)
+    {
+      stddev[2] += (results_unmodified[c].duration - average[2]) *
+          (results_unmodified[c].duration - average[2]);
+    }
+  stddev[2] /= c_unmodified;
+  stddev[2] = sqrt (stddev[2]);
+  
+  if (!machine_parsable) 
+    fprintf (stderr,
+	     "unmodified, %i measurements, average: %f stddev: %f\n",
+	     c_unmodified, average[2], stddev[2]);
+  
+  if (machine_parsable)
+    fprintf (stderr,
+	     "peers,%i,mechs,%llu,"
+	     "new,%i,%f,%f,"
+	     "mod,%i,%f,%f,"
+	     "unmod,%i,%f,%f\n",
+	     peers-1, (unsigned long long) results_unmodified[0].mechs,
+	     c_new, average[0], stddev[0],
+	     c_modified, average[1], stddev[1],
+	     c_unmodified, average[2], stddev[2]);
+  shutdown_peers();
+}
+
+
+static int 
+stats_cb (void *cls,
+	  const char *subsystem,
+	  const char *name,
+	  uint64_t value,
+	  int is_persistent)
+{
+  static int printed = GNUNET_NO;
+  //GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s = %llu\n", name ,value);
+  if (0 == strcmp (name,"ATS invalid solutions"))
+    {
+      if (stats_task != GNUNET_SCHEDULER_NO_TASK)
+	{
+	  GNUNET_SCHEDULER_cancel(stats_task);
+	  stats_task = GNUNET_SCHEDULER_NO_TASK;
+	}
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"MLP produced invalid %llu result(s)!\n",
+          value);
+      shutdown_peers();
+      return GNUNET_SYSERR;
+    }
+  
+  if (0 == strcmp (name,"ATS solution"))
+    {
+      s_solution = NULL;
+    }
+  
+  if (0 == strcmp (name,"ATS peers"))
+    {
+      s_peers = NULL;
+    }
+  
+  if (0 == strcmp (name,"ATS mechanisms"))
+    {
+      s_mechs = NULL;
+    }
+  
+  if (0 == strcmp (name,"ATS duration"))
+    {
+      s_duration = NULL;
+    }
+  if (0 == strcmp (name,"ATS timestamp"))
+    {
+      s_time = NULL;
+    }
+  if (0 == strcmp (name,"ATS state"))
+    {
+      s_state = NULL;
+    }
+  
+  if ( (measurement_started == GNUNET_NO) && 
+       (0 == strcmp (name, "ATS peers")) && 
+       (value == peers-1) )
+    {
+      measurement_started = GNUNET_YES;
+      count = 1;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+		  "All %llu peers connected\n", 
+		  value);
+#if !VERBOSE
+      if (! machine_parsable)	
+	fprintf(stderr, "%i", count);
+#endif
+    }
+  
+  if (measurement_started == GNUNET_YES)
+    {
+      // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s == %llu\n", name ,value);
+      if (0 == strcmp (name,"ATS timestamp"))
+	{
+	  if (current.timestamp == 0)
+	    {
+	      printed = GNUNET_NO;
+	      current.timestamp = value;
+	    }
+	  if (current.timestamp == value)
+	    {
+	      printed = GNUNET_YES;
+	    }
+	  if (current.timestamp != value)
+	    {
+	      if (current.state == ATS_NEW)
+		{
+		  if (c_new < MEASUREMENTS)
+		    {
+		      results_new[c_new] = current;
+		      c_new++;
+		    }
+		  else
+		    {
+		      force_rebuild = GNUNET_NO;
+		      force_q_updates = GNUNET_NO;
+		      send_msg = GNUNET_NO;
+		    }
+		}
+	      if (current.state == ATS_UNMODIFIED)
+		{
+		  if (c_unmodified < MEASUREMENTS)
+		    {
+		      results_unmodified[c_unmodified] = current;
+		      c_unmodified++;
+		    }
+		  
+		}
+	      if (current.state == ATS_Q_UPDATED)
+		{
+		  if (c_modified < MEASUREMENTS)
+		    {
+		      results_modified[c_modified] = current;
+		      c_modified++;
+		    }
+		  else
+		    {
+		      force_q_updates = GNUNET_NO;
+		      force_rebuild = GNUNET_YES;
+		    }
+		}
+	      count ++;
+#if VERBOSE
+	      fprintf (stderr,
+		       "(new: %i / modified: %i / unmodified: %i) of %i \n", 
+		       c_new, c_modified, c_unmodified , MEASUREMENTS);
+#endif
+	      if ((c_modified >= MEASUREMENTS) &&
+	          (c_new >= MEASUREMENTS) &&
+	          (c_unmodified >= MEASUREMENTS))
+		{
+#if !VERBOSE
+		  if (!machine_parsable)
+		    fprintf(stdout, "\n");
+#endif
+		  if (stats_task != GNUNET_SCHEDULER_NO_TASK)
+		    {
+		      GNUNET_SCHEDULER_cancel(stats_task);
+		      stats_task = GNUNET_SCHEDULER_NO_TASK;
+		    }
+		  evaluate_measurements();
+		  return GNUNET_SYSERR;
+		}
+	      
+	      printed = GNUNET_NO;
+	      current.timestamp = value;
+#if !VERBOSE
+	      if (! machine_parsable)
+		fprintf(stderr, "..%i", count);
+#endif
+	      return GNUNET_OK;
+	    }
+	}
+      
+      if (0 == strcmp (name,"ATS solution"))
+	{
+	  current.solution = value;
+	  if (printed == GNUNET_NO)
+	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+	        count, name, value);
+	}
+      
+      if (0 == strcmp (name,"ATS peers"))
+	{
+	  current.peers = value;
+	  if (printed == GNUNET_NO)
+	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+	        count, name, value);
+	}
+      
+      if (0 == strcmp (name,"ATS mechanisms"))
+	{
+	  current.mechs = value;
+	  if (printed == GNUNET_NO) 
+	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+	        count, name, value);
+	}
+      
+      if (0 == strcmp (name,"ATS duration"))
+	{
+	  current.duration = value;
+	  if (printed == GNUNET_NO) 
+	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+	        count, name, value);
+	}
+      if (0 == strcmp (name,"ATS state"))
+	{
+	  current.state = value;
+	  char * cont;
+	  if (value == ATS_NEW)
+	    cont = "NEW";
+	  if (value == ATS_C_UPDATED)
+	    cont = "C_UPDATED";
+	  if (value == ATS_Q_UPDATED)
+	    cont = "Q_UPDATED";
+	  if (value == ATS_QC_UPDATED)
+	    cont = "QC_UPDATED";
+	  if (value == ATS_UNMODIFIED)
+	    cont = "UNMODIFIED";
+	  if (printed == GNUNET_NO) 
+	    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+			"[%i] ATS state: %s\n", count, cont);
+	}
+    }
+  return GNUNET_OK;
+}
+
+
+static void
+stats_get_task (void *cls,
+		const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  stats_task = GNUNET_SCHEDULER_NO_TASK;
+  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
+  
+  s_time = GNUNET_STATISTICS_get (stats, "transport", "ATS timestamp",
+      TIMEOUT, NULL, &stats_cb, NULL);
+  s_solution = GNUNET_STATISTICS_get (stats, "transport", "ATS solution",
+      TIMEOUT, NULL, &stats_cb, NULL);
+  s_duration = GNUNET_STATISTICS_get (stats, "transport","ATS duration",
+      TIMEOUT, NULL, &stats_cb, NULL);
+  s_peers = GNUNET_STATISTICS_get (stats, "transport", "ATS peers",
+      TIMEOUT, NULL, &stats_cb, NULL);
+  s_mechs = GNUNET_STATISTICS_get (stats, "transport", "ATS mechanisms",
+      TIMEOUT, NULL, &stats_cb, NULL);
+  s_invalid = GNUNET_STATISTICS_get (stats, "transport", "ATS invalid solutions",
+      TIMEOUT, NULL, &stats_cb, NULL);
+  s_state = GNUNET_STATISTICS_get (stats, "transport", "ATS state",
+      TIMEOUT, NULL, &stats_cb, NULL);
+  
+  stats_task = GNUNET_SCHEDULER_add_delayed(
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100),
+      &stats_get_task,
+      NULL);
+}
+
+
+static void
+delay (void *cls,
+       const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  shutdown_task = GNUNET_SCHEDULER_NO_TASK;
+  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
+	      "Delay over\n");
+#endif
+  shutdown_peers ();
+}
+
+static void
+connect_peers()
+{
+  shutdown_task = GNUNET_SCHEDULER_add_delayed(DELAY, &delay, NULL);
+}
+
+static size_t 
+send_dummy_data_task (void *cls, size_t size, void *buf)
+{
+  int s = sizeof (struct TestMessage);
+  struct TestMessage hdr;
+  
+  hdr.header.size = htons (s);
+  hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ATS);
+  if (force_rebuild)
+    hdr.num = htonl (1);
+  if (force_q_updates)
+    hdr.num = htonl (2);
+  memcpy (buf,&hdr, s);
+  // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i of %i\n", s, s);
+  t  = NULL;
+  return s;
+}
+
+
+static void 
+send_task_f (void *cls,
+	     const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  send_task = GNUNET_SCHEDULER_NO_TASK;
+  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
+  
+  if (t!=NULL)
+    {
+      GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
+      t = NULL;
+    }
+
+  if (send_msg == GNUNET_YES)
+    t = GNUNET_TRANSPORT_notify_transmit_ready(th, 
+					       &master_deamon->id, 
+					       sizeof (struct TestMessage), 0, 
+					       SEND_TIMEOUT, 
+					       &send_dummy_data_task, NULL);
+  send_task = GNUNET_SCHEDULER_add_delayed(
+      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,1000),
+      &send_task_f,
+      NULL);
+
+}
+
+static void
+notify_connect (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                const struct GNUNET_TRANSPORT_ATS_Information *ats,
+                uint32_t ats_count)
+{
+  send_task = GNUNET_SCHEDULER_add_now(&send_task_f, NULL);
+}
+
+static void
+notify_disconnect (void *cls,
+		   const struct GNUNET_PeerIdentity *peer)
+{
+  if (GNUNET_SCHEDULER_NO_TASK != send_task)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+		  "Disconnect event before transmission request could be scheduled!\n");
+      GNUNET_SCHEDULER_cancel (send_task);
+      send_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+  if (NULL != t)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+		  "Disconnect event before transmission request could be completed!\n");
+      GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
+      t = NULL;
+    }
+}
+
+static void 
+daemon_connect_cb(void *cls,
+		  const struct GNUNET_PeerIdentity *first,
+		  const struct GNUNET_PeerIdentity *second,
+		  uint32_t distance,
+		  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)
+{
+  char * firstc =  strdup(GNUNET_i2s(first));
+  char * secondc =  strdup(GNUNET_i2s(second));
+  connected++;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+	      "Connected peers `%s'<->`%s' (%i/%i)\n", 
+	      firstc, secondc, connected, peers-1);
+  GNUNET_free(firstc);
+  GNUNET_free(secondc);
+  
+  if ( ( (first_daemon == ping_deamon) || 
+	 (second_daemon == ping_deamon) ) && 
+       (master_deamon != NULL) && 
+       (ping_deamon != NULL) )
+    {
+      th = GNUNET_TRANSPORT_connect (ping_deamon->cfg,
+				     &ping_deamon->id, 
+				     NULL, NULL,
+				     &notify_connect, 
+				     &notify_disconnect);
+      force_q_updates = GNUNET_YES;
+      send_msg = GNUNET_YES;
+    }
+}
+
+
+
+static void
+daemon_start_cb (void *cls,
+		 const struct GNUNET_PeerIdentity *id,
+		 const struct GNUNET_CONFIGURATION_Handle *cfg,
+		 struct GNUNET_TESTING_Daemon *d, const char *emsg)
+{
+  if (id == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Start callback called with error (too long starting peers), aborting test!\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+		  "Error from testing: `%s'\n");
+      failed_peers++;
+      if (failed_peers == peers_left)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Too many peers failed, ending test!\n");
+          ok = 1;
+      	shutdown_peers ();
+        }
+      return;
+    }
+  peers_left--;
+
+  if (master_deamon == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+		  "Master peer `%s' '%s'\n",
+		  GNUNET_i2s(id), d->cfgfile);      
+      master_deamon = d;
+      stats = GNUNET_STATISTICS_create("transport", master_deamon->cfg);
+      GNUNET_assert (stats != NULL);
+      stats_task = GNUNET_SCHEDULER_add_now(&stats_get_task, NULL);
+    }
+  else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+		  "Connecting peer `%s'\n", 
+		  GNUNET_i2s(id), GNUNET_i2s(&master_deamon->id));
+      GNUNET_TESTING_daemons_connect(d,
+          master_deamon,
+          TIMEOUT,
+          0,
+          GNUNET_YES,
+          &daemon_connect_cb,
+          NULL);
+    }
+  
+  if (peers_left == 0)
+    {
+      if (ping_deamon == NULL)
+	{
+	  ping_deamon = d;
+	  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+		      "Ping peer `%s' '%s'\n", GNUNET_i2s(id), d->cfgfile);
+	}
+      
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "All peers started successfully!\n");
+      connect_peers();
+      ok = 0;
+    }
+  else if (failed_peers == peers_left)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Too many peers failed, ending test!\n");
+      shutdown_peers();
+      ok = 1;
+    }
+}
+
+
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  ok = 1;
+  measurement_started = GNUNET_NO;
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting %i peers.\n", peers);
+#endif
+  peers_left = peers;
+  pg = GNUNET_TESTING_daemons_start (cfg,
+                                     peers_left, /* Total number of peers */
+                                     peers_left, /* Number of outstanding connections */
+                                     peers_left, /* Number of parallel ssh connections, or peers being started at once */
+                                     TIMEOUT,
+                                     NULL, NULL,
+                                     &daemon_start_cb, NULL, NULL, NULL, NULL);
+  GNUNET_assert (pg != NULL);
+}
+
+
+static int
+check ()
+{
+  char *const argv[] = { "test-testing",
+    "-c",
+    config_file,
+#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-transport-ats", "nohelp",
+                      options, &run, &ok);
+  return ok;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+
+  GNUNET_log_setup ("test-transport-ats-multiple-peers",
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "INFO",
+#endif
+                    NULL);
+
+#if !HAVE_LIBGLPK && !HAVE_GLPK
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
+	      "GLPK not installed, exiting testcase\n");
+  return 0;
+#endif
+
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
+  machine_parsable = GNUNET_NO;
+  peers = NUM_PEERS;
+  config_file = "test_transport_ats_4addr.conf";
+
+  int c = 0;
+  if (argc >= 2)
+    {
+      for (c=0; c<argc; c++)
+	{
+	  /* set peers */
+	  if ((strcmp(argv[c], "-p") == 0) && c < (argc-1))
+	    {
+	      peers = atoi(argv[c+1]);
+	      peers++;
+	    }
+	  /* set machine parsable */
+	  if (strcmp(argv[c], "-m") == 0)
+	    {
+	      machine_parsable = GNUNET_YES;
+	    }
+	  /* set config file */
+	  if ((strcmp(argv[c], "-c") == 0) && c < (argc-1))
+	    {
+	      config_file = argv[c+1];
+	    }
+	 }
+    }
+
+
+
+  ret = check ();
+  /**
+   * Still need to remove the base testing directory here,
+   * because group starts will create subdirectories under this
+   * main dir.  However, we no longer need to sleep, as the
+   * shutdown sequence won't return until everything is cleaned
+   * up.
+   */
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-testing");
+  return ret;
+}
+
+/* end of test_transport_ats_multiple_peers.c*/
-- 
cgit v1.2.3