-help seaspider some more

[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 e903574b2c6be72c2ce18ee828350a94bdde1f9f..5fcbd538b826391224581ba4b1450352a12217f3 100644 (file)
--- a/src/hostlist/test_gnunet_daemon_hostlist_learning.c
+++ b/src/hostlist/test_gnunet_daemon_hostlist_learning.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, 2011 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


@@ -18,59 +18,156 @@
      Boston, MA 02111-1307, USA.
 */
 /**
      Boston, MA 02111-1307, USA.
 */
 /**

- * @file hostlist/test_gnunet_daemon_hostlist_learning.c
+ * @file hostlist/test_gnunet_daemon_hostlist.c

  * @brief test for gnunet_daemon_hostslist.c
  * @brief test for gnunet_daemon_hostslist.c

- * @author Christian Grothoff, Matthias Wachs
+ * @author Christian Grothoff

  */
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_arm_service.h"
  */
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_arm_service.h"

+#include "gnunet_core_service.h"

 #include "gnunet_transport_service.h"
 #include "gnunet_transport_service.h"

+#include "gnunet_resolver_service.h"
+#include "gnunet_statistics_service.h"

 
 

+#define VERBOSE GNUNET_NO

 
 #define START_ARM GNUNET_YES
 
 
 #define START_ARM GNUNET_YES
 

+#define MAX_URL_LEN 1000
+

 /**
 /**

- * How long until we give up on transmitting the message?
+ * How long until wait until testcases fails

  */
  */

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

 
 

-static int ok;
+#define CHECK_INTERVALL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)

 
 

-static struct GNUNET_SCHEDULER_Handle *sched;

 
 

-static GNUNET_SCHEDULER_TaskIdentifier timeout_task;
-    

 struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_MessageHeader *hello;
 struct PeerContext
 {
   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
 #if START_ARM

-  pid_t arm_pid;
+  struct GNUNET_OS_Process *arm_proc;

 #endif
 };
 
 #endif
 };
 

-static struct PeerContext p1;
+static int timeout;
+
+static int adv_sent;
+
+static int adv_arrived;
+
+static int learned_hostlist_saved;
+
+static int learned_hostlist_downloaded;
+
+static char *current_adv_uri;
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+
+static GNUNET_SCHEDULER_TaskIdentifier check_task;
+
+static struct PeerContext adv_peer;
+
+static struct PeerContext learn_peer;

 
 

-static struct PeerContext p2;
+static struct GNUNET_STATISTICS_GetHandle *download_stats;
+
+static struct GNUNET_STATISTICS_GetHandle *urisrecv_stat;
+
+static struct GNUNET_STATISTICS_GetHandle *advsent_stat;

 
 
 static void
 
 
 static void

-clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_testcase ()

 {
 {

-  if (p1.th != NULL)
-    {
-      GNUNET_TRANSPORT_disconnect (p1.th);
-      p1.th = NULL;
-    }
-  if (p2.th != NULL)
-    {
-      GNUNET_TRANSPORT_disconnect (p2.th);
-      p2.th = NULL;
-    }
-  GNUNET_SCHEDULER_shutdown (sched);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown testcase....\n");
+  if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (NULL != download_stats)
+  {
+    GNUNET_STATISTICS_get_cancel (download_stats);
+    download_stats = NULL;
+  }
+  if (NULL != urisrecv_stat)
+  {
+    GNUNET_STATISTICS_get_cancel (urisrecv_stat);
+    urisrecv_stat = NULL;
+  }
+  if (NULL != advsent_stat)
+  {
+    GNUNET_STATISTICS_get_cancel (advsent_stat);
+    advsent_stat = NULL;
+  }
+  if (NULL != adv_peer.stats)
+  {
+    GNUNET_STATISTICS_destroy (adv_peer.stats, GNUNET_NO);
+    adv_peer.stats = NULL;
+  }
+  if (NULL != learn_peer.stats)
+  {
+    GNUNET_STATISTICS_destroy (learn_peer.stats, GNUNET_NO);
+    learn_peer.stats = NULL;
+  }
+  if (check_task != GNUNET_SCHEDULER_NO_TASK)
+  {
+    GNUNET_SCHEDULER_cancel (check_task);
+    check_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (NULL != current_adv_uri)
+  {
+    GNUNET_free (current_adv_uri);
+    current_adv_uri = NULL;
+  }
+  if (adv_peer.th != NULL)
+  {
+    GNUNET_TRANSPORT_disconnect (adv_peer.th);
+    adv_peer.th = NULL;
+  }
+  if (learn_peer.th != NULL)
+  {
+    GNUNET_TRANSPORT_disconnect (learn_peer.th);
+    learn_peer.th = NULL;
+  }
+  if (adv_peer.core != NULL)
+  {
+    GNUNET_CORE_disconnect (adv_peer.core);
+    adv_peer.core = NULL;
+  }
+  if (learn_peer.core != NULL)
+  {
+    GNUNET_CORE_disconnect (learn_peer.core);
+    learn_peer.core = NULL;
+  }
+#if START_ARM
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Killing hostlist server ARM process.\n");
+  if (0 != GNUNET_OS_process_kill (adv_peer.arm_proc, SIGTERM))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+  if (GNUNET_OS_process_wait (adv_peer.arm_proc) != GNUNET_OK)
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+  GNUNET_OS_process_destroy (adv_peer.arm_proc);
+  adv_peer.arm_proc = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Killing hostlist client ARM process.\n");
+  if (0 != GNUNET_OS_process_kill (learn_peer.arm_proc, SIGTERM))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+  if (GNUNET_OS_process_wait (learn_peer.arm_proc) != GNUNET_OK)
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+  GNUNET_OS_process_destroy (learn_peer.arm_proc);
+  learn_peer.arm_proc = NULL;
+#endif
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown complete....\n");

 }
 
 /**
 }
 
 /**


@@ -81,167 +178,296 @@ timeout_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   timeout_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 {
   timeout_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,

-             "Timeout trying to connect peers, test failed.\n");
-  clean_up (NULL, tc);
+              "Timeout while executing testcase, test failed.\n");
+  timeout = GNUNET_YES;
+  shutdown_testcase ();

 }
 
 
 }
 
 

-/**
- * Function called to notify transport users that another
- * peer connected to us.
- *
- * @param cls closure
- * @param peer the peer that connected
- * @param latency current latency of the connection
- * @param distance in overlay hops, as given by transport plugin
- */

 static void
 static void

-notify_connect (void *cls,
-               const struct GNUNET_PeerIdentity * peer,
-               struct GNUNET_TIME_Relative latency,
-               unsigned int distance)
+process_downloads_done (void *cls, int success)

 {
 {

-  if (peer == NULL)
-    return;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "Peers connected, shutting down.\n");
-  /*
-  ok = 0;
-  if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (sched,
-                              timeout_task);
-      timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  GNUNET_SCHEDULER_add_now (sched,
-                           &clean_up, NULL);
-                           */
+  download_stats = NULL;

 }
 
 
 static void
 }
 
 
 static void

-process_hello (void *cls,
-               const struct GNUNET_MessageHeader *message)
+do_shutdown (void *cls,
+            const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
 {

-  struct PeerContext *p = cls;
+  shutdown_testcase ();
+}

 
 

-  GNUNET_TRANSPORT_get_hello_cancel (p->th, &process_hello, p);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "Received HELLO, starting hostlist service.\n");
-  GNUNET_ARM_start_services (p->cfg, sched, "hostlist", NULL);
+
+static int
+process_downloads (void *cls, const char *subsystem, const char *name,
+                   uint64_t value, int is_persistent)
+{
+  if ((value >= 2) && (learned_hostlist_downloaded == GNUNET_NO))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Peer has successfully downloaded advertised URI\n");
+    learned_hostlist_downloaded = GNUNET_YES;
+    if ((learned_hostlist_saved == GNUNET_YES) && (adv_sent == GNUNET_YES))
+    {
+      GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
+    }
+  }
+  return GNUNET_OK;

 }
 
 
 static void
 }
 
 
 static void

-setup_peer (struct PeerContext *p, const char *cfgname)
+process_uris_recv_done (void *cls, int success)

 {
 {

-  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
-                                        "-L", "DEBUG",
-#endif
-                                        "-c", cfgname, NULL);
-#endif
-  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  GNUNET_ARM_start_services (p->cfg, sched, "core", NULL);
-  p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, p, NULL, 
-                                   &notify_connect, NULL);
-  GNUNET_assert (p->th != NULL);
-  GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
+  urisrecv_stat = NULL;
+}
+
+
+static int
+process_uris_recv (void *cls, const char *subsystem, const char *name,
+                   uint64_t value, int is_persistent)
+{
+  if (((struct PeerContext *) cls == &learn_peer) && (value == 1) &&
+      (learned_hostlist_saved == GNUNET_NO))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Peer has successfully saved advertised URI\n");
+    learned_hostlist_saved = GNUNET_YES;
+    if ((learned_hostlist_downloaded == GNUNET_YES) && (adv_sent == GNUNET_YES))
+      shutdown_testcase ();
+  }
+  return GNUNET_OK;

 }
 
 
 static void
 }
 
 
 static void

-waitpid_task (void *cls, 
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+process_adv_sent_done (void *cls, int success)

 {
 {

-  struct PeerContext *p = cls;
+  advsent_stat = NULL;
+}

 
 

-#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 int
+process_adv_sent (void *cls, const char *subsystem, const char *name,
+                  uint64_t value, int is_persistent)
+{
+  if ((value >= 1) && (adv_sent == GNUNET_NO))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Server has successfully sent advertisement\n");
+    adv_sent = GNUNET_YES;
+    if ((learned_hostlist_downloaded == GNUNET_YES) &&
+        (learned_hostlist_saved == GNUNET_YES))
+      shutdown_testcase ();
+  }
+  return GNUNET_OK;

 }
 
 
 }
 
 

+/**
+ * Check the server statistics regularly
+ */

 static void
 static void

-stop_cb (void *cls, 
-        int success)
+check_statistics (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
 {

-  struct PeerContext *p = cls;
+  char *stat;

 
 

-  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);
+  check_task = GNUNET_SCHEDULER_NO_TASK;
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+    return;
+  GNUNET_asprintf (&stat, gettext_noop ("# advertised URI `%s' downloaded"),
+                   current_adv_uri);
+  if (NULL != learn_peer.stats)
+  {
+    if (NULL != download_stats)
+      GNUNET_STATISTICS_get_cancel (download_stats);
+    download_stats =
+        GNUNET_STATISTICS_get (learn_peer.stats, "hostlist", stat,
+                               GNUNET_TIME_UNIT_MINUTES,
+                               &process_downloads_done, &process_downloads,
+                               &learn_peer);
+    if (NULL != urisrecv_stat)
+      GNUNET_STATISTICS_get_cancel (urisrecv_stat);
+    urisrecv_stat =
+        GNUNET_STATISTICS_get (learn_peer.stats, "hostlist",
+                               gettext_noop ("# advertised hostlist URIs"),
+                               GNUNET_TIME_UNIT_MINUTES,
+                               &process_uris_recv_done, &process_uris_recv,
+                               &learn_peer);
+  }
+  GNUNET_free (stat);
+  if (NULL != adv_peer.stats)
+  {
+    if (NULL != advsent_stat)
+      GNUNET_STATISTICS_get_cancel (advsent_stat);
+    advsent_stat =
+        GNUNET_STATISTICS_get (adv_peer.stats, "hostlist",
+                               gettext_noop ("# hostlist advertisements send"),
+                               GNUNET_TIME_UNIT_MINUTES, &process_adv_sent_done,
+                               &process_adv_sent, NULL);
+  }
+  check_task =
+      GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL, &check_statistics, NULL);

 }
 
 
 }
 
 

-static void
-stop_arm (struct PeerContext *p)
+/**
+ * Core handler for p2p hostlist advertisements
+ */
+static int
+ad_arrive_handler (void *cls, const struct GNUNET_PeerIdentity *peer,
+                   const struct GNUNET_MessageHeader *message,
+                   const struct GNUNET_ATS_Information *atsi,
+                   unsigned int atsi_count)

 {
 {

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "Asking ARM to stop core service\n");
-  p->arm = GNUNET_ARM_connect (p->cfg, sched, NULL);
-  GNUNET_ARM_stop_service (p->arm, "core", GNUNET_TIME_UNIT_SECONDS,
-                          &stop_cb, p);
+  char *hostname;
+  char *expected_uri;
+  unsigned long long port;
+  const struct GNUNET_MessageHeader *incoming;
+  const char *end;
+
+  if (-1 ==
+      GNUNET_CONFIGURATION_get_value_number (adv_peer.cfg, "HOSTLIST",
+                                             "HTTPPORT", &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;
+  end = (const char *) &incoming[1];
+  if ('\0' !=
+      end[ntohs (message->size) - sizeof (struct GNUNET_MessageHeader) - 1])
+  {
+    GNUNET_break (0);
+    GNUNET_free (expected_uri);
+    GNUNET_free_non_null (hostname);
+    return GNUNET_SYSERR;
+  }
+  current_adv_uri = GNUNET_strdup (end);
+  if (0 == strcmp (expected_uri, current_adv_uri))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Received 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);
+  GNUNET_free (expected_uri);
+  GNUNET_free_non_null (hostname);
+  return GNUNET_OK;

 }
 
 
 /**
 }
 
 
 /**

- * Try again to connect to transport service.
+ * List of handlers if we are learning.

  */
  */

+static struct GNUNET_CORE_MessageHandler learn_handlers[] = {
+  {&ad_arrive_handler, GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, 0},
+  {NULL, 0, 0}
+};
+
+

 static void
 static void

-shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+setup_learn_peer (struct PeerContext *p, const char *cfgname)

 {
 {

-  stop_arm (&p1);
-  stop_arm (&p2);
+  char *filename;
+  unsigned int result;
+
+  p->cfg = GNUNET_CONFIGURATION_create ();
+#if START_ARM
+  p->arm_proc =
+    GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
+                               "gnunet-service-arm",
+#if VERBOSE
+                               "-L", "DEBUG",
+#endif
+                               "-c", cfgname, NULL);
+#endif
+  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
+  if (GNUNET_OK ==
+      GNUNET_CONFIGURATION_get_value_string (p->cfg, "HOSTLIST", "HOSTLISTFILE",
+                                             &filename))
+  {
+    if (GNUNET_YES == GNUNET_DISK_file_test (filename))
+    {
+      result = UNLINK (filename);
+      if (result == 0)
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    _("Hostlist file `%s' was removed\n"), filename);
+    }
+    GNUNET_free (filename);
+  }
+  p->core =
+      GNUNET_CORE_connect (p->cfg, 1, NULL, NULL, NULL, NULL, NULL, GNUNET_NO,
+                           NULL, GNUNET_NO, learn_handlers);
+  GNUNET_assert (NULL != p->core);
+  p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
+  GNUNET_assert (NULL != p->stats);

 }
 
 
 static void
 }
 
 
 static void

-run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
-     char *const *args,
-     const char *cfgfile, 
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+setup_adv_peer (struct PeerContext *p, const char *cfgname)

 {
 {

-  GNUNET_assert (ok == 1);
-  ok++;
-  sched = s;
-
-  timeout_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                              TIMEOUT,
-                                              &timeout_error,
-                                              NULL);
-  GNUNET_SCHEDULER_add_delayed (sched,
-                               GNUNET_TIME_UNIT_FOREVER_REL,
-                               &shutdown_task,
-                               NULL);
-  setup_peer (&p1, "learning_peer1.conf");
-  setup_peer (&p2, "learning_peer2.conf");
+  p->cfg = GNUNET_CONFIGURATION_create ();
+#if START_ARM
+  p->arm_proc =
+    GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
+                               "gnunet-service-arm",
+#if VERBOSE
+                               "-L", "DEBUG",
+#endif
+                               "-c", cfgname, NULL);
+#endif
+  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
+  p->stats = GNUNET_STATISTICS_create ("hostlist", p->cfg);
+  GNUNET_assert (NULL != p->stats);
+}
+
+
+static void
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  timeout = GNUNET_NO;
+  adv_sent = GNUNET_NO;
+
+  adv_arrived = 0;
+  learned_hostlist_saved = GNUNET_NO;
+  learned_hostlist_downloaded = GNUNET_NO;
+
+  cfg = c;
+
+  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 (TIMEOUT, &timeout_error, NULL);
+
+  check_task =
+      GNUNET_SCHEDULER_add_delayed (CHECK_INTERVALL, &check_statistics, NULL);

 }
 
 
 static int
 check ()
 {
 }
 
 
 static int
 check ()
 {

-  char *const argv[] = { "test_gnunet_daemon_hostlist_learning",
+  unsigned int failed;
+
+  char *const argv[] = {
+    "test-gnunet-daemon-hostlist-learning",

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


@@ -251,33 +477,77 @@ check ()
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };

-  ok = 1;
-  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test_gnunet_daemon_hostlist_learning",
-                     "nohelp", options, &run, &ok);

 
 

-  return ok;
+  GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
+                      "test-gnunet-daemon-hostlist-learning", "nohelp", options,
+                      &run, NULL);
+  failed = GNUNET_NO;
+  if (timeout == GNUNET_YES)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase timeout\n");
+    failed = GNUNET_YES;
+  }
+  if (adv_arrived != GNUNET_YES)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Learning peer did not receive advertisement from server\n");
+    failed = GNUNET_YES;
+  }
+  if (learned_hostlist_saved == GNUNET_NO)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Advertised hostlist was not saved in datastore\n");
+    failed = GNUNET_YES;
+  }
+  if (learned_hostlist_downloaded == GNUNET_NO)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Advertised hostlist could not be downloaded from server\n");
+    failed = GNUNET_YES;
+  }
+  if (adv_sent == GNUNET_NO)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Advertised was not sent from server to client\n");
+    failed = GNUNET_YES;
+  }
+  if (GNUNET_YES == failed)
+    return GNUNET_YES;
+  return GNUNET_NO;

 }
 
 
 int
 main (int argc, char *argv[])
 {
 }
 
 
 int
 main (int argc, char *argv[])
 {

-  

   int ret;
   int ret;

-  GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-hostlist-peer-1");
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-hostlist-peer-2");
-  GNUNET_log_setup ("test-gnunet-daemon-hostlist_learning",
+
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
+  GNUNET_log_setup ("test-gnunet-daemon-hostlist",

 #if VERBOSE
                     "DEBUG",
 #else
                     "WARNING",
 #endif
                     NULL);
 #if VERBOSE
                     "DEBUG",
 #else
                     "WARNING",
 #endif
                     NULL);

+#if !WINDOWS
+  system ("gnunet-peerinfo -s -c test_learning_adv_peer.conf > /dev/null");
+  system ("gnunet-peerinfo -s -c test_learning_learn_peer.conf > /dev/null");
+#else
+  system ("gnunet-peerinfo -s -c test_learning_adv_peer.conf > NUL");
+  system ("gnunet-peerinfo -s -c test_learning_learn_peer.conf > NUL");
+#endif

   ret = check ();
   ret = check ();

-  GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-hostlist-peer-1");
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-hostlist-peer-2");
-  return ret; 
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-1");
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-hostlist-peer-2");
+  if (GNUNET_YES == GNUNET_DISK_file_test ("hostlists_learn_peer.file"))
+  {
+    if (0 == UNLINK ("hostlists_learn_peer.file"))
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Hostlist file hostlists_learn_peer.file was removed\n");
+  }
+  return ret;

 }
 
 /* end of test_gnunet_daemon_hostlist.c */
 }
 
 /* end of test_gnunet_daemon_hostlist.c */