even longer timeout, still timing out on hostkey generation (sparcbot)

[oweals/gnunet.git] / src / hostlist / test_gnunet_daemon_hostlist_learning.c

diff --git a/src/hostlist/test_gnunet_daemon_hostlist_learning.c b/src/hostlist/test_gnunet_daemon_hostlist_learning.c
index 89060b645e2084d38ed53f08011c8f54683c750f..43199bd91e571b002fd99653ca40949546d1175d 100644 (file)
--- a/src/hostlist/test_gnunet_daemon_hostlist_learning.c
+++ b/src/hostlist/test_gnunet_daemon_hostlist_learning.c
@@ -4,7 +4,7 @@
 
      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


@@ -30,7 +30,7 @@
 #include "gnunet_resolver_service.h"
 #include "gnunet_statistics_service.h"
 
 #include "gnunet_resolver_service.h"
 #include "gnunet_statistics_service.h"
 

-#define VERBOSE GNUNET_NO
+#define VERBOSE GNUNET_YES

 
 #define START_ARM GNUNET_YES
 #define MAX_URL_LEN 1000
 
 #define START_ARM GNUNET_YES
 #define MAX_URL_LEN 1000


@@ -38,17 +38,19 @@
 /**
  * How long until wait until testcases fails
  */
 /**
  * How long until wait until testcases fails
  */

-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 180)

 #define CHECK_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
 
 static int timeout;
 #define CHECK_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
 
 static int timeout;

-static int adv_arrived;

 static int adv_sent;
 static int adv_sent;

+static int adv_arrived;
+

 static int learned_hostlist_saved;
 static int learned_hostlist_downloaded;
 
 static char * current_adv_uri;
 
 static int learned_hostlist_saved;
 static int learned_hostlist_downloaded;
 
 static char * current_adv_uri;
 

+static const struct GNUNET_CONFIGURATION_Handle *cfg;

 static struct GNUNET_SCHEDULER_Handle *sched;
 
 static GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 static struct GNUNET_SCHEDULER_Handle *sched;
 
 static GNUNET_SCHEDULER_TaskIdentifier timeout_task;


@@ -59,7 +61,6 @@ struct PeerContext
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_MessageHeader *hello;
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_MessageHeader *hello;

-  struct GNUNET_ARM_Handle *arm;

   struct GNUNET_CORE_Handle *core;
   struct GNUNET_STATISTICS_Handle *stats;
 #if START_ARM
   struct GNUNET_CORE_Handle *core;
   struct GNUNET_STATISTICS_Handle *stats;
 #if START_ARM


@@ -71,62 +72,39 @@ static struct PeerContext adv_peer;
 
 static struct PeerContext learn_peer;
 
 
 static struct PeerContext learn_peer;
 

-
-static void
-waitpid_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  struct PeerContext *p = cls;
-
-#if START_ARM
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Killing ARM process.\n");
-  if (0 != PLIBC_KILL (p->arm_pid, SIGTERM))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-  if (GNUNET_OS_process_wait(p->arm_pid) != GNUNET_OK)
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "ARM process %u stopped\n", p->arm_pid);
-#endif
-  GNUNET_CONFIGURATION_destroy (p->cfg);
-}
-
-
-static void
-stop_cb (void *cls,
-         int success)
-{
-  struct PeerContext *p = cls;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              success
-              ? "ARM stopped core service\n"
-              : "ARM failed to stop core service\n");
-  GNUNET_ARM_disconnect (p->arm);
-  p->arm = NULL;
-  /* make sure this runs after all other tasks are done */
-  GNUNET_SCHEDULER_add_delayed (sched,
-                                GNUNET_TIME_UNIT_SECONDS,
-                                &waitpid_task, p);
-}
-
+static struct GNUNET_STATISTICS_GetHandle * download_stats;
+static struct GNUNET_STATISTICS_GetHandle * urisrecv_stat;
+static struct GNUNET_STATISTICS_GetHandle * advsent_stat;

 
 static void shutdown_testcase()
 {
 
 static void shutdown_testcase()
 {

+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown testcase....\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Timeout Task.\n");

   if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
   {
   if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
   {

-    GNUNET_SCHEDULER_cancel (sched,
-                             timeout_task);
+    GNUNET_SCHEDULER_cancel (sched, timeout_task);

     timeout_task = GNUNET_SCHEDULER_NO_TASK;
   }
     timeout_task = GNUNET_SCHEDULER_NO_TASK;
   }

-  if (check_task != GNUNET_SCHEDULER_NO_TASK)
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Statistics Task.\n");
+/*
+  if ((NULL != learn_peer.stats) && (NULL != download_stats))
+    GNUNET_STATISTICS_get_cancel (download_stats);
+  if ((NULL != learn_peer.stats) && (NULL != urisrecv_stat))
+    GNUNET_STATISTICS_get_cancel (urisrecv_stat);
+  if ((NULL != adv_peer.stats) && (NULL != advsent_stat))
+    GNUNET_STATISTICS_get_cancel (advsent_stat);
+*/
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping Statistics Check Task.\n");
+  if ((check_task != GNUNET_SCHEDULER_NO_TASK) && (sched !=NULL))

   {
   {

-    GNUNET_SCHEDULER_cancel (sched,
-        check_task);
+    GNUNET_SCHEDULER_cancel (sched, check_task);

     check_task = GNUNET_SCHEDULER_NO_TASK;
   }
     check_task = GNUNET_SCHEDULER_NO_TASK;
   }

-  if ( NULL != current_adv_uri ) GNUNET_free (current_adv_uri);

 
 

+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Freeing uri\n");
+  if ( NULL != current_adv_uri ) GNUNET_free (current_adv_uri);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from Transport.\n");

   if (adv_peer.th != NULL)
   {
     GNUNET_TRANSPORT_disconnect (adv_peer.th);
   if (adv_peer.th != NULL)
   {
     GNUNET_TRANSPORT_disconnect (adv_peer.th);


@@ -137,6 +115,8 @@ static void shutdown_testcase()
     GNUNET_TRANSPORT_disconnect (learn_peer.th);
     learn_peer.th = NULL;
   }
     GNUNET_TRANSPORT_disconnect (learn_peer.th);
     learn_peer.th = NULL;
   }

+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from Core.\n");

   if (adv_peer.core != NULL)
   {
     GNUNET_CORE_disconnect (adv_peer.core);
   if (adv_peer.core != NULL)
   {
     GNUNET_CORE_disconnect (adv_peer.core);


@@ -149,14 +129,35 @@ static void shutdown_testcase()
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Asking ARM to stop core services\n");
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Asking ARM to stop core services\n");

-  learn_peer.arm = GNUNET_ARM_connect (learn_peer.cfg, sched, NULL);
-  GNUNET_ARM_stop_service (learn_peer.arm, "core", GNUNET_TIME_UNIT_SECONDS,
-                           &stop_cb, &learn_peer);
-  adv_peer.arm = GNUNET_ARM_connect (adv_peer.cfg, sched, NULL);
-  GNUNET_ARM_stop_service (adv_peer.arm, "core", GNUNET_TIME_UNIT_SECONDS,
-                           &stop_cb, &adv_peer);

 
 

+
+#if START_ARM
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Killing hostlist server ARM process.\n");
+  if (0 != PLIBC_KILL (adv_peer.arm_pid, SIGTERM))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+  if (GNUNET_OS_process_wait(adv_peer.arm_pid) != GNUNET_OK)
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Hostlist server ARM process %u stopped\n", adv_peer.arm_pid);
+#endif
+  
+
+#if START_ARM
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Killing hostlist client ARM process.\n");
+  if (0 != PLIBC_KILL (learn_peer.arm_pid, SIGTERM))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+  if (GNUNET_OS_process_wait(learn_peer.arm_pid) != GNUNET_OK)
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Hostlist client ARM process %u stopped\n", learn_peer.arm_pid);
+#endif
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down scheduler\n");

   GNUNET_SCHEDULER_shutdown (sched);
   GNUNET_SCHEDULER_shutdown (sched);

+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown complete....\n");
+

 }
 
 /**
 }
 
 /**


@@ -166,6 +167,8 @@ static void
 timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   timeout_task = GNUNET_SCHEDULER_NO_TASK;
 timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   timeout_task = GNUNET_SCHEDULER_NO_TASK;

+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    return;

   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
               "Timeout while executing testcase, test failed.\n");
   timeout = GNUNET_YES;
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
               "Timeout while executing testcase, test failed.\n");
   timeout = GNUNET_YES;


@@ -179,14 +182,14 @@ process_downloads (void *cls,
               uint64_t value,
               int is_persistent)
 {
               uint64_t value,
               int is_persistent)
 {

-  if ( (value == 1) && (learned_hostlist_downloaded == GNUNET_NO) )
+  download_stats = NULL;
+  if ( (value == 2) && (learned_hostlist_downloaded == GNUNET_NO) )

   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,

-                _("Client has successfully downloaded advertised URI \n"));
+                _("Peer has successfully downloaded advertised URI \n"));

     learned_hostlist_downloaded = GNUNET_YES;
     learned_hostlist_downloaded = GNUNET_YES;

-  }
-  if ( GNUNET_NO != learned_hostlist_downloaded )

     shutdown_testcase();
     shutdown_testcase();

+  }

   return GNUNET_OK;
 }
 
   return GNUNET_OK;
 }
 


@@ -197,10 +200,11 @@ process_uris_recv (void *cls,
               uint64_t value,
               int is_persistent)
 {
               uint64_t value,
               int is_persistent)
 {

-  if ( (value == 1) && (learned_hostlist_saved == GNUNET_NO))
+  urisrecv_stat = NULL;
+  if ( ((struct PeerContext *) cls == &learn_peer) && (value == 1) && (learned_hostlist_saved == GNUNET_NO))

   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,

-                _("Client has successfully saved advertised URI \n"));
+                _("Peer has successfully saved advertised URI \n"));

     learned_hostlist_saved = GNUNET_YES;
   }
   return GNUNET_OK;
     learned_hostlist_saved = GNUNET_YES;
   }
   return GNUNET_OK;


@@ -213,7 +217,8 @@ process_adv_sent (void *cls,
               uint64_t value,
               int is_persistent)
 {
               uint64_t value,
               int is_persistent)
 {

-  if ( (value == 1) && (adv_sent == GNUNET_NO))
+  advsent_stat = NULL;
+  if ( (value >= 1) && (adv_sent == GNUNET_NO))

   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _("Server has successfully sent advertisement\n"));
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 _("Server has successfully sent advertisement\n"));


@@ -230,31 +235,43 @@ static void
 check_statistics (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   char *stat;
 check_statistics (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   char *stat;

+
+  check_task = GNUNET_SCHEDULER_NO_TASK;
+    if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+      return;
+

   GNUNET_asprintf (&stat,
   GNUNET_asprintf (&stat,

-                   gettext_noop("Advertised URI `%s' downloaded"),
+                   gettext_noop("# advertised URI `%s' downloaded"),

                    current_adv_uri);
                    current_adv_uri);

-  GNUNET_STATISTICS_get (learn_peer.stats,
-                         "hostlist",
-                         stat,
-                         GNUNET_TIME_UNIT_MINUTES,
-                         NULL,
-                         &process_downloads,
-                         NULL);
+  if ( NULL != learn_peer.stats)
+  {
+    download_stats = GNUNET_STATISTICS_get (learn_peer.stats,
+                           "hostlist",
+                           stat,
+                           GNUNET_TIME_UNIT_MINUTES,
+                           NULL,
+                           &process_downloads,
+                           &learn_peer);
+
+    urisrecv_stat = GNUNET_STATISTICS_get (learn_peer.stats,
+                           "hostlist",
+                           gettext_noop("# advertised hostlist URIs"),
+                           GNUNET_TIME_UNIT_MINUTES,
+                           NULL,
+                           &process_uris_recv,
+                           &learn_peer);
+  }

   GNUNET_free (stat);
   GNUNET_free (stat);

-  GNUNET_STATISTICS_get (learn_peer.stats,
-                         "hostlist",
-                         gettext_noop("# advertised hostlist URIs"),
-                         GNUNET_TIME_UNIT_MINUTES,
-                         NULL,
-                         &process_uris_recv,
-                         NULL);
-  GNUNET_STATISTICS_get (adv_peer.stats,
-                         "hostlist",
-                         gettext_noop("# hostlist advertisements send"),
-                         GNUNET_TIME_UNIT_MINUTES,
-                         NULL,
-                         &process_adv_sent,
-                         NULL);
+  if ( NULL != adv_peer.stats)
+  {
+    advsent_stat = GNUNET_STATISTICS_get (adv_peer.stats,
+                           "hostlist",
+                           gettext_noop("# hostlist advertisements send"),
+                           GNUNET_TIME_UNIT_MINUTES,
+                           NULL,
+                           &process_adv_sent,
+                           NULL);
+  }

   check_task = GNUNET_SCHEDULER_add_delayed (sched,
                                 CHECK_INTERVALL,
                                 &check_statistics,
   check_task = GNUNET_SCHEDULER_add_delayed (sched,
                                 CHECK_INTERVALL,
                                 &check_statistics,


@@ -271,10 +288,8 @@ static int ad_arrive_handler (void *cls,
                              uint32_t distance)
 {
   char *hostname;
                              uint32_t distance)
 {
   char *hostname;

-  char *expected_uri = GNUNET_malloc (MAX_URL_LEN);
-
+  char *expected_uri;

   unsigned long long port;
   unsigned long long port;

-  size_t size;

   const struct GNUNET_MessageHeader * incoming;
 
   if (-1 == GNUNET_CONFIGURATION_get_value_number (adv_peer.cfg,
   const struct GNUNET_MessageHeader * incoming;
 
   if (-1 == GNUNET_CONFIGURATION_get_value_number (adv_peer.cfg,


@@ -282,40 +297,35 @@ static int ad_arrive_handler (void *cls,
                                                    "HTTPPORT",
                                                    &port))
     {
                                                    "HTTPPORT",
                                                    &port))
     {

-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Could not read advertising server's configuration\n" );
-    return GNUNET_SYSERR;
-    }
-  hostname = GNUNET_RESOLVER_local_hostname_get ();
-  if (NULL != hostname)
-    {
-      size = strlen (hostname);
-      if (size + 15 > MAX_URL_LEN)
-        {
-          GNUNET_break (0);
-        }
-      else
-        {
-          GNUNET_asprintf (&expected_uri,
-                           "http://%s:%u/",
-                           hostname,
-                           (unsigned int) port);
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                 "Could not read advertising server's configuration\n" );
+      return GNUNET_SYSERR;

     }
 
     }
 

+  if ( GNUNET_SYSERR  == GNUNET_CONFIGURATION_get_value_string (adv_peer.cfg,
+                                                   "HOSTLIST",
+                                                   "EXTERNAL_DNS_NAME",
+                                                   &hostname))
+    hostname = GNUNET_RESOLVER_local_fqdn_get ();
+
+  GNUNET_asprintf (&expected_uri,
+                  "http://%s:%u/",
+                  hostname != NULL ? hostname : "localhost",
+                  (unsigned int) port);   

   incoming = (const struct GNUNET_MessageHeader *) message;
   current_adv_uri = strdup ((char*) &incoming[1]);
   if ( 0 == strcmp( expected_uri, current_adv_uri ) )
   incoming = (const struct GNUNET_MessageHeader *) message;
   current_adv_uri = strdup ((char*) &incoming[1]);
   if ( 0 == strcmp( expected_uri, current_adv_uri ) )

-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Recieved hostlist advertisement with URI `%s'as expected\n", current_adv_uri);
-    adv_arrived = GNUNET_YES;
-  }
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                 "Recieved hostlist advertisement with URI `%s' as expected\n", current_adv_uri);
+      adv_arrived = GNUNET_YES;
+      adv_sent = GNUNET_YES;
+    }

   else
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Expected URI `%s' and recieved URI `%s' differ\n", expected_uri, current_adv_uri);
   else
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Expected URI `%s' and recieved URI `%s' differ\n", expected_uri, current_adv_uri);

-  GNUNET_free ( expected_uri );
-  GNUNET_free ( hostname );
+  GNUNET_free (expected_uri);
+  GNUNET_free_non_null (hostname);

   return GNUNET_OK;
 }
 
   return GNUNET_OK;
 }
 


@@ -357,16 +367,14 @@ setup_learn_peer (struct PeerContext *p, const char *cfgname)
   }
   if ( NULL != filename)  GNUNET_free ( filename );
 
   }
   if ( NULL != filename)  GNUNET_free ( filename );
 

-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
-

   p->core = GNUNET_CORE_connect (sched, p->cfg,
   p->core = GNUNET_CORE_connect (sched, p->cfg,

-                              GNUNET_TIME_UNIT_FOREVER_REL,
-                              NULL,
-                              NULL,
-                              NULL, NULL,
-                              NULL, GNUNET_NO,
-                              NULL, GNUNET_NO,
-                              learn_handlers );
+                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                NULL,
+                                NULL,
+                                NULL, NULL, NULL,
+                                NULL, GNUNET_NO,
+                                NULL, GNUNET_NO,
+                                learn_handlers );

   GNUNET_assert ( NULL != p->core );
   p->stats = GNUNET_STATISTICS_create (sched, "hostlist", p->cfg);
   GNUNET_assert ( NULL != p->stats );
   GNUNET_assert ( NULL != p->core );
   p->stats = GNUNET_STATISTICS_create (sched, "hostlist", p->cfg);
   GNUNET_assert ( NULL != p->stats );


@@ -376,6 +384,7 @@ setup_learn_peer (struct PeerContext *p, const char *cfgname)
 static void
 setup_adv_peer (struct PeerContext *p, const char *cfgname)
 {
 static void
 setup_adv_peer (struct PeerContext *p, const char *cfgname)
 {

+

   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_pid = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_pid = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",


@@ -386,9 +395,9 @@ setup_adv_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));

-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);

   p->stats = GNUNET_STATISTICS_create (sched, "hostlist", p->cfg);
   GNUNET_assert ( NULL != p->stats );
   p->stats = GNUNET_STATISTICS_create (sched, "hostlist", p->cfg);
   GNUNET_assert ( NULL != p->stats );

+

 }
 
 static void
 }
 
 static void


@@ -396,32 +405,36 @@ run (void *cls,
      struct GNUNET_SCHEDULER_Handle *s,
      char *const *args,
      const char *cfgfile, 
      struct GNUNET_SCHEDULER_Handle *s,
      char *const *args,
      const char *cfgfile, 

-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const struct GNUNET_CONFIGURATION_Handle *c)

 {
   timeout = GNUNET_NO;
 {
   timeout = GNUNET_NO;

-  adv_arrived = GNUNET_NO;

   adv_sent =GNUNET_NO;
   adv_sent =GNUNET_NO;

+
+  adv_arrived = 0;
+  learned_hostlist_saved = GNUNET_NO;

   learned_hostlist_downloaded = GNUNET_NO;
   learned_hostlist_downloaded = GNUNET_NO;

+
+  cfg = c;

   sched = s;
   sched = s;

+
+  setup_adv_peer (&adv_peer, "test_learning_adv_peer.conf");
+  setup_learn_peer (&learn_peer, "test_learning_learn_peer.conf");

   timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
                                                TIMEOUT,
                                                &timeout_error,
                                                NULL);
   timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
                                                TIMEOUT,
                                                &timeout_error,
                                                NULL);

+

   check_task = GNUNET_SCHEDULER_add_delayed (sched,
                                 CHECK_INTERVALL,
                                 &check_statistics,
                                 NULL);
   check_task = GNUNET_SCHEDULER_add_delayed (sched,
                                 CHECK_INTERVALL,
                                 &check_statistics,
                                 NULL);

-
-  setup_adv_peer (&adv_peer, "test_learning_adv_peer.conf");
-  setup_learn_peer (&learn_peer, "test_learning_learn_peer.conf");

 }
 
 }
 

-

 static int
 check ()
 {
   unsigned int failed;
 static int
 check ()
 {
   unsigned int failed;

-  char *const argv[] = { "test-gnunet-daemon-hostlist",
+  char *const argv[] = { "test-gnunet-daemon-hostlist-learning",

     "-c", "learning_data.conf",
 #if VERBOSE
     "-L", "DEBUG",
     "-c", "learning_data.conf",
 #if VERBOSE
     "-L", "DEBUG",


@@ -433,36 +446,38 @@ check ()
   };
 
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
   };
 
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,

-                      argv, "test-gnunet-daemon-hostlist",
+                      argv, "test-gnunet-daemon-hostlist-learning",

                       "nohelp", options, &run, NULL);
 
   failed = GNUNET_NO;
 
                       "nohelp", options, &run, NULL);
 
   failed = GNUNET_NO;
 

+  if (learned_hostlist_downloaded == GNUNET_YES)
+    return GNUNET_NO;
+

   if (timeout == GNUNET_YES)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Testcase could not set up two communicating peers, timeout\n");
     failed = GNUNET_YES;
   }
   if (timeout == GNUNET_YES)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Testcase could not set up two communicating peers, timeout\n");
     failed = GNUNET_YES;
   }

-  if (adv_arrived == GNUNET_NO)
+  if (adv_arrived != GNUNET_YES)

   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,

-                "Learning peer did not recieve advertisement from server\n");
+                "Learning peer did not receive advertisement from server\n");

     failed = GNUNET_YES;
   }
   if ( learned_hostlist_saved == GNUNET_NO )
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
     failed = GNUNET_YES;
   }
   if ( learned_hostlist_saved == GNUNET_NO )
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,

-                  "Advertised hostlist was not saved in datastore\n");
+                  "Peer1: Advertised hostlist was not saved in datastore\n");

       failed = GNUNET_YES;
     }
   if (learned_hostlist_downloaded == GNUNET_NO)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
       failed = GNUNET_YES;
     }
   if (learned_hostlist_downloaded == GNUNET_NO)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,

-                "Advertised hostlist could not be downloaded from server\n");
+                "Peer1: Advertised hostlist could not be downloaded from server\n");

     failed = GNUNET_YES;
   }
     failed = GNUNET_YES;
   }

-

   if (adv_sent == GNUNET_NO)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
   if (adv_sent == GNUNET_NO)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,


@@ -493,6 +508,12 @@ main (int argc, char *argv[])
   ret = check ();
   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-hostlist-peer-1");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-hostlist-peer-2");
   ret = check ();
   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-hostlist-peer-1");
   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-hostlist-peer-2");

+  if ( GNUNET_YES == GNUNET_DISK_file_test ("hostlists_learn_peer.file") )
+    {
+      if ( remove ("hostlists_learn_peer.file")  == 0)
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+            _("Hostlist file hostlists_learn_peer.file was removed\n"));
+    }

   return ret; 
 }
 
   return ret; 
 }