the big core API/protocol change, breaks all testcases using core, since the code...

[oweals/gnunet.git] / src / dv / test_transport_api_dv.c

diff --git a/src/dv/test_transport_api_dv.c b/src/dv/test_transport_api_dv.c
index 31e0a370bce8283a712b44b65c002d97892793c7..d4c7eef2caa41bcf0dd540f0e7495cd843ff4bc7 100644 (file)
--- a/src/dv/test_transport_api_dv.c
+++ b/src/dv/test_transport_api_dv.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


@@ -25,7 +25,7 @@
 #include "gnunet_testing_lib.h"
 #include "gnunet_core_service.h"
 
 #include "gnunet_testing_lib.h"
 #include "gnunet_core_service.h"
 

-#define VERBOSE GNUNET_YES
+#define VERBOSE GNUNET_NO

 
 #define TEST_ALL GNUNET_NO
 
 
 #define TEST_ALL GNUNET_NO
 


@@ -75,8 +75,6 @@ static unsigned long long peers_left;
 
 static struct GNUNET_TESTING_PeerGroup *pg;
 
 
 static struct GNUNET_TESTING_PeerGroup *pg;
 

-static struct GNUNET_SCHEDULER_Handle *sched;
-

 const struct GNUNET_CONFIGURATION_Handle *main_cfg;
 
 GNUNET_SCHEDULER_TaskIdentifier die_task;
 const struct GNUNET_CONFIGURATION_Handle *main_cfg;
 
 GNUNET_SCHEDULER_TaskIdentifier die_task;


@@ -198,7 +196,6 @@ finish_testing ()
   struct PeerContext *free_peer_pos;
   struct TestMessageContext *pos;
   struct TestMessageContext *free_pos;
   struct PeerContext *free_peer_pos;
   struct TestMessageContext *pos;
   struct TestMessageContext *free_pos;

-  int count;

 
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,


@@ -215,7 +212,6 @@ finish_testing ()
     }
   all_peers = NULL;
 
     }
   all_peers = NULL;
 

-  count = 0;

   pos = test_messages;
   while (pos != NULL)
     {
   pos = test_messages;
   while (pos != NULL)
     {


@@ -233,7 +229,7 @@ finish_testing ()
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {

-          GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+          GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);

         }
       GNUNET_free(free_pos);
     }
         }
       GNUNET_free(free_pos);
     }


@@ -255,7 +251,7 @@ finish_testing ()
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {

-          GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+          GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);

         }
       GNUNET_free(free_pos);
     }
         }
       GNUNET_free(free_pos);
     }


@@ -366,7 +362,7 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {

-          GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+          GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);

         }
       GNUNET_free(free_pos);
     }
         }
       GNUNET_free(free_pos);
     }


@@ -425,28 +421,27 @@ process_mtype (void *cls,
 
   if ((total_messages_received == expected_messages) && (total_other_messages == 0))
     {
 
   if ((total_messages_received == expected_messages) && (total_other_messages == 0))
     {

-      GNUNET_SCHEDULER_cancel (sched, die_task);
-      die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                               TEST_TIMEOUT,
+      GNUNET_SCHEDULER_cancel (die_task);
+      die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,

                                                &end_badly, "waiting for DV peers to connect!");
       /*
       if ((num_peers == 3) && (total_other_expected_messages == 2))
         {
                                                &end_badly, "waiting for DV peers to connect!");
       /*
       if ((num_peers == 3) && (total_other_expected_messages == 2))
         {

-          GNUNET_SCHEDULER_add_now (sched, &send_other_messages, NULL);
+          GNUNET_SCHEDULER_add_now (&send_other_messages, NULL);

         }
       else
         {
         }
       else
         {

-          GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20), &send_other_messages, NULL);
+          GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20), &send_other_messages, NULL);

         }*/
     }
   else if ((total_other_expected_messages > 0) && (total_other_messages == total_other_expected_messages))
     {
         }*/
     }
   else if ((total_other_expected_messages > 0) && (total_other_messages == total_other_expected_messages))
     {

-      GNUNET_SCHEDULER_cancel (sched, die_task);
-      GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+      GNUNET_SCHEDULER_cancel (die_task);
+      GNUNET_SCHEDULER_add_now (&finish_testing, NULL);

     }
   else
     {
     }
   else
     {

-      pos->disconnect_task = GNUNET_SCHEDULER_add_now(sched, &disconnect_cores, pos);
+      pos->disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cores, pos);

     }
 
   return GNUNET_OK;
     }
 
   return GNUNET_OK;


@@ -533,15 +528,15 @@ init_notify_peer1 (void *cls,
   /*
    * Connect to the receiving peer
    */
   /*
    * Connect to the receiving peer
    */

-  pos->peer2handle = GNUNET_CORE_connect (sched,
-                       pos->peer2->cfg,
-                       TIMEOUT,
-                       pos,
-                       &init_notify_peer2,
-                       NULL,
-                       NULL,
-                       NULL,
-                       GNUNET_YES, NULL, GNUNET_YES, handlers);
+  pos->peer2handle = GNUNET_CORE_connect (pos->peer2->cfg,
+                                         1, 
+                                         TIMEOUT,
+                                         pos,
+                                         &init_notify_peer2,
+                                         NULL,
+                                         NULL,
+                                         NULL, NULL,
+                                         GNUNET_YES, NULL, GNUNET_YES, handlers);

 
 }
 
 
 }
 


@@ -556,14 +551,13 @@ send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 
   if (die_task == GNUNET_SCHEDULER_NO_TASK)
     {
 
   if (die_task == GNUNET_SCHEDULER_NO_TASK)
     {

-      die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                               TEST_TIMEOUT,
+      die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,

                                                &end_badly, "from create topology (timeout)");
     }
 
   if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS)
     {
                                                &end_badly, "from create topology (timeout)");
     }
 
   if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS)
     {

-      GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),

                                     &send_test_messages, pos);
       return; /* Otherwise we'll double schedule messages here! */
     }
                                     &send_test_messages, pos);
       return; /* Otherwise we'll double schedule messages here! */
     }


@@ -573,12 +567,12 @@ send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
   /*
    * Connect to the sending peer
    */
   /*
    * Connect to the sending peer
    */

-  pos->peer1handle = GNUNET_CORE_connect (sched,
-                                          pos->peer1->cfg,
+  pos->peer1handle = GNUNET_CORE_connect (pos->peer1->cfg,
+                                         1,

                                           TIMEOUT,
                                           pos,
                                           &init_notify_peer1,
                                           TIMEOUT,
                                           pos,
                                           &init_notify_peer1,

-                                          NULL,
+                                          NULL, NULL,

                                           NULL,
                                           NULL,
                                           GNUNET_NO, NULL, GNUNET_NO, no_handlers);
                                           NULL,
                                           NULL,
                                           GNUNET_NO, NULL, GNUNET_NO, no_handlers);


@@ -587,12 +581,11 @@ send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 
   if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS)
     {
 
   if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS)
     {

-      GNUNET_SCHEDULER_add_now (sched,
-                                &send_test_messages, pos->next);
+      GNUNET_SCHEDULER_add_now (&send_test_messages, pos->next);

     }
   else
     {
     }
   else
     {

-      GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),

                                     &send_test_messages, pos->next);
     }
 }
                                     &send_test_messages, pos->next);
     }
 }


@@ -654,7 +647,7 @@ send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {

-          GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+          GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);

         }
       GNUNET_free(free_pos);
     }
         }
       GNUNET_free(free_pos);
     }


@@ -663,15 +656,15 @@ send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
   total_other_expected_messages = temp_total_other_messages;
   if (total_other_expected_messages == 0)
     {
   total_other_expected_messages = temp_total_other_messages;
   if (total_other_expected_messages == 0)
     {

-      GNUNET_SCHEDULER_add_now (sched, &end_badly, "send_other_messages had 0 messages to send, no DV connections made!");
+      GNUNET_SCHEDULER_add_now (&end_badly, "send_other_messages had 0 messages to send, no DV connections made!");

     }
 #if VERBOSE
   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Preparing to send %d other test messages\n", total_other_expected_messages);
 #endif
 
     }
 #if VERBOSE
   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Preparing to send %d other test messages\n", total_other_expected_messages);
 #endif
 

-  GNUNET_SCHEDULER_add_now (sched, &send_test_messages, other_test_messages);
-  GNUNET_SCHEDULER_cancel(sched, die_task);
-  die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 250), &end_badly, "from send_other_messages");
+  GNUNET_SCHEDULER_add_now (&send_test_messages, other_test_messages);
+  GNUNET_SCHEDULER_cancel(die_task);
+  die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 250), &end_badly, "from send_other_messages");

 }
 
 void
 }
 
 void


@@ -720,27 +713,26 @@ topology_callback (void *cls,
     {
 #if VERBOSE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
     {
 #if VERBOSE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-                  "Created %d total connections, which is our target number!  Calling send messages.\n",
+                  "Created %u total connections, which is our target number!  Calling send messages.\n",

                   total_connections);
 #endif
 
                   total_connections);
 #endif
 

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

       die_task = GNUNET_SCHEDULER_NO_TASK;
       die_task = GNUNET_SCHEDULER_NO_TASK;

-      GNUNET_SCHEDULER_add_now (sched, &send_test_messages, test_messages);
+      GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages);

     }
   else if (total_connections + failed_connections == expected_connections)
     {
       if (failed_connections < (unsigned int)(fail_percentage * total_connections))
         {
     }
   else if (total_connections + failed_connections == expected_connections)
     {
       if (failed_connections < (unsigned int)(fail_percentage * total_connections))
         {

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

           die_task = GNUNET_SCHEDULER_NO_TASK;
           die_task = GNUNET_SCHEDULER_NO_TASK;

-          GNUNET_SCHEDULER_add_now (sched, &send_test_messages, test_messages);
+          GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages);

         }
       else
         {
         }
       else
         {

-          GNUNET_SCHEDULER_cancel (sched, die_task);
-          die_task = GNUNET_SCHEDULER_add_now (sched,
-                                               &end_badly, "from topology_callback (too many failed connections)");
+          GNUNET_SCHEDULER_cancel (die_task);
+          die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");

         }
     }
   else
         }
     }
   else


@@ -759,22 +751,20 @@ connect_topology ()
   expected_connections = -1;
   if ((pg != NULL) && (peers_left == 0))
     {
   expected_connections = -1;
   if ((pg != NULL) && (peers_left == 0))
     {

-      expected_connections = GNUNET_TESTING_connect_topology (pg, connection_topology, connect_topology_option, connect_topology_option_modifier);
+      expected_connections = GNUNET_TESTING_connect_topology (pg, connection_topology, connect_topology_option, connect_topology_option_modifier, NULL, NULL);

 #if VERBOSE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Have %d expected connections\n", expected_connections);
 #endif
     }
 
 #if VERBOSE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Have %d expected connections\n", expected_connections);
 #endif
     }
 

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

   if (expected_connections == GNUNET_SYSERR)
     {
   if (expected_connections == GNUNET_SYSERR)
     {

-      die_task = GNUNET_SCHEDULER_add_now (sched,
-                                           &end_badly, "from connect topology (bad return)");
+      die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");

     }
 
     }
 

-  die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                           TEST_TIMEOUT,
+  die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,

                                            &end_badly, "from connect topology (timeout)");
 }
 
                                            &end_badly, "from connect topology (timeout)");
 }
 


@@ -792,13 +782,11 @@ create_topology ()
     }
   else
     {
     }
   else
     {

-      GNUNET_SCHEDULER_cancel (sched, die_task);
-      die_task = GNUNET_SCHEDULER_add_now (sched,
-                                           &end_badly, "from create topology (bad return)");
+      GNUNET_SCHEDULER_cancel (die_task);
+      die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)");

     }
     }

-  GNUNET_SCHEDULER_cancel (sched, die_task);
-  die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                           TEST_TIMEOUT,
+  GNUNET_SCHEDULER_cancel (die_task);
+  die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,

                                            &end_badly, "from continue startup (timeout)");
 }
 
                                            &end_badly, "from continue startup (timeout)");
 }
 


@@ -834,6 +822,7 @@ static void all_connect_handler (void *cls,
   if (second_daemon == NULL)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Couldn't find second peer!\n");
   if (second_daemon == NULL)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Couldn't find second peer!\n");

+      GNUNET_free(second_shortname);

       return;
     }
 #if !TEST_ALL
       return;
     }
 #if !TEST_ALL


@@ -868,7 +857,7 @@ static void all_connect_handler (void *cls,
 
   if (temp_total_other_messages == num_additional_messages)
     {
 
   if (temp_total_other_messages == num_additional_messages)
     {

-      GNUNET_SCHEDULER_add_now (sched, &send_other_messages, NULL);
+      GNUNET_SCHEDULER_add_now (&send_other_messages, NULL);

     }
 }
 
     }
 }
 


@@ -893,7 +882,14 @@ peers_started_callback (void *cls,
   GNUNET_assert(GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_put(peer_daemon_hash, &id->hashPubKey, d, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
   new_peer = GNUNET_malloc(sizeof(struct PeerContext));
   GNUNET_assert(GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_put(peer_daemon_hash, &id->hashPubKey, d, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
   new_peer = GNUNET_malloc(sizeof(struct PeerContext));

-  new_peer->peer_handle = GNUNET_CORE_connect(sched, cfg, GNUNET_TIME_UNIT_FOREVER_REL, d, NULL, &all_connect_handler, NULL, NULL, GNUNET_NO, NULL, GNUNET_NO, no_handlers);
+  new_peer->peer_handle = GNUNET_CORE_connect(cfg, 
+                                             1,
+                                             GNUNET_TIME_UNIT_FOREVER_REL,
+                                             d, NULL,
+                                             &all_connect_handler, 
+                                             NULL, NULL, NULL, 
+                                             GNUNET_NO, NULL, GNUNET_NO,
+                                             no_handlers);

   new_peer->daemon = d;
   new_peer->next = all_peers;
   all_peers = new_peer;
   new_peer->daemon = d;
   new_peer->next = all_peers;
   all_peers = new_peer;


@@ -906,11 +902,10 @@ peers_started_callback (void *cls,
                   "All %d daemons started, now creating topology!\n",
                   num_peers);
 #endif
                   "All %d daemons started, now creating topology!\n",
                   num_peers);
 #endif

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

       /* Set up task in case topology creation doesn't finish
        * within a reasonable amount of time */
       /* Set up task in case topology creation doesn't finish
        * within a reasonable amount of time */

-      die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                               GNUNET_TIME_relative_multiply
+      die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply

                                                (GNUNET_TIME_UNIT_MINUTES, 5),
                                                &end_badly, "from peers_started_callback");
 
                                                (GNUNET_TIME_UNIT_MINUTES, 5),
                                                &end_badly, "from peers_started_callback");
 


@@ -950,21 +945,19 @@ void hostkey_callback (void *cls,
                     "All %d hostkeys created, now creating topology!\n",
                     num_peers);
 #endif
                     "All %d hostkeys created, now creating topology!\n",
                     num_peers);
 #endif

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

         /* Set up task in case topology creation doesn't finish
          * within a reasonable amount of time */
         /* Set up task in case topology creation doesn't finish
          * within a reasonable amount of time */

-        die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                                 GNUNET_TIME_relative_multiply
+        die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply

                                                  (GNUNET_TIME_UNIT_MINUTES, 5),
                                                  &end_badly, "from hostkey_callback");
                                                  (GNUNET_TIME_UNIT_MINUTES, 5),
                                                  &end_badly, "from hostkey_callback");

-        GNUNET_SCHEDULER_add_now(sched, &create_topology, NULL);
+        GNUNET_SCHEDULER_add_now(&create_topology, NULL);

         ok = 0;
       }
 }
 
 static void
 run (void *cls,
         ok = 0;
       }
 }
 
 static void
 run (void *cls,

-     struct GNUNET_SCHEDULER_Handle *s,

      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {


@@ -973,7 +966,6 @@ run (void *cls,
   char * blacklist_topology_str;
   char * connect_topology_option_str;
   char * connect_topology_option_modifier_string;
   char * blacklist_topology_str;
   char * connect_topology_option_str;
   char * connect_topology_option_modifier_string;

-  sched = s;

   ok = 1;
 
   dotOutFile = fopen (dotOutFileName, "w");
   ok = 1;
 
   dotOutFile = fopen (dotOutFileName, "w");


@@ -1059,16 +1051,16 @@ run (void *cls,
 
   main_cfg = cfg;
 
 
   main_cfg = cfg;
 

+  GNUNET_assert(num_peers > 0 && num_peers < (unsigned int)-1);

   peers_left = num_peers;
 
   /* Set up a task to end testing if peer start fails */
   peers_left = num_peers;
 
   /* Set up a task to end testing if peer start fails */

-  die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                           GNUNET_TIME_relative_multiply
+  die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply

                                            (GNUNET_TIME_UNIT_MINUTES, 5),
                                            &end_badly, "didn't start all daemons in reasonable amount of time!!!");
 
   peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create(peers_left);
                                            (GNUNET_TIME_UNIT_MINUTES, 5),
                                            &end_badly, "didn't start all daemons in reasonable amount of time!!!");
 
   peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create(peers_left);

-  pg = GNUNET_TESTING_daemons_start (sched, cfg,
+  pg = GNUNET_TESTING_daemons_start (cfg,

                                      peers_left, TIMEOUT, &hostkey_callback, NULL, &peers_started_callback, NULL,
                                      &topology_callback, NULL, NULL);
 
                                      peers_left, TIMEOUT, &hostkey_callback, NULL, &peers_started_callback, NULL,
                                      &topology_callback, NULL, NULL);
 


@@ -1123,4 +1115,4 @@ main (int argc, char *argv[])
   return ret;
 }
 
   return ret;
 }
 

-/* end of test_testing_topology.c */
+/* end of test_transport_api_dv.c */