uncrustify as demanded.

1 files changed, 246 insertions, 249 deletions

diff --git a/src/dht/test_dht_topo.c b/src/dht/test_dht_topo.c
index a0d80e52c..32d99152d 100644
--- a/src/dht/test_dht_topo.c
+++ b/src/dht/test_dht_topo.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file dht/test_dht_topo.c
  * @author Christian Grothoff
@@ -32,19 +32,18 @@
 /**
  * How long until we give up on fetching the data?
  */
-#define GET_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
+#define GET_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120)
 
 /**
  * How frequently do we execute the PUTs?
  */
-#define PUT_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+#define PUT_FREQUENCY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
 
 
 /**
  * Information we keep for each GET operation.
  */
-struct GetOperation
-{
+struct GetOperation {
   /**
    * DLL.
    */
@@ -59,7 +58,6 @@ struct GetOperation
    * Handle for the operation.
    */
   struct GNUNET_DHT_GetHandle *get;
-
 };
 
 
@@ -107,80 +105,79 @@ static unsigned int NUM_PEERS;
 /**
  * Statistics we print out.
  */
-static struct
-{
+static struct {
   const char *subsystem;
   const char *name;
   unsigned long long total;
 } stats[] = {
-  {"core", "# bytes decrypted", 0},
-  {"core", "# bytes encrypted", 0},
-  {"core", "# type maps received", 0},
-  {"core", "# session keys confirmed via PONG", 0},
-  {"core", "# peers connected", 0},
-  {"core", "# key exchanges initiated", 0},
-  {"core", "# send requests dropped (disconnected)", 0},
-  {"core", "# transmissions delayed due to corking", 0},
-  {"core", "# messages discarded (expired prior to transmission)", 0},
-  {"core", "# messages discarded (disconnected)", 0},
-  {"core", "# discarded CORE_SEND requests", 0},
-  {"core", "# discarded lower priority CORE_SEND requests", 0},
-  {"transport", "# bytes received via TCP", 0},
-  {"transport", "# bytes transmitted via TCP", 0},
-  {"dht", "# PUT messages queued for transmission", 0},
-  {"dht", "# P2P PUT requests received", 0},
-  {"dht", "# GET messages queued for transmission", 0},
-  {"dht", "# P2P GET requests received", 0},
-  {"dht", "# RESULT messages queued for transmission", 0},
-  {"dht", "# P2P RESULTS received", 0},
-  {"dht", "# Queued messages discarded (peer disconnected)", 0},
-  {"dht", "# Peers excluded from routing due to Bloomfilter", 0},
-  {"dht", "# Peer selection failed", 0},
-  {"dht", "# FIND PEER requests ignored due to Bloomfilter", 0},
-  {"dht", "# FIND PEER requests ignored due to lack of HELLO", 0},
-  {"dht", "# P2P FIND PEER requests processed", 0},
-  {"dht", "# P2P GET requests ONLY routed", 0},
-  {"dht", "# Preference updates given to core", 0},
-  {"dht", "# REPLIES ignored for CLIENTS (no match)", 0},
-  {"dht", "# GET requests from clients injected", 0},
-  {"dht", "# GET requests received from clients", 0},
-  {"dht", "# GET STOP requests received from clients", 0},
-  {"dht", "# ITEMS stored in datacache", 0},
-  {"dht", "# Good RESULTS found in datacache", 0},
-  {"dht", "# GET requests given to datacache", 0},
-  {NULL, NULL, 0}
+  { "core", "# bytes decrypted", 0 },
+  { "core", "# bytes encrypted", 0 },
+  { "core", "# type maps received", 0 },
+  { "core", "# session keys confirmed via PONG", 0 },
+  { "core", "# peers connected", 0 },
+  { "core", "# key exchanges initiated", 0 },
+  { "core", "# send requests dropped (disconnected)", 0 },
+  { "core", "# transmissions delayed due to corking", 0 },
+  { "core", "# messages discarded (expired prior to transmission)", 0 },
+  { "core", "# messages discarded (disconnected)", 0 },
+  { "core", "# discarded CORE_SEND requests", 0 },
+  { "core", "# discarded lower priority CORE_SEND requests", 0 },
+  { "transport", "# bytes received via TCP", 0 },
+  { "transport", "# bytes transmitted via TCP", 0 },
+  { "dht", "# PUT messages queued for transmission", 0 },
+  { "dht", "# P2P PUT requests received", 0 },
+  { "dht", "# GET messages queued for transmission", 0 },
+  { "dht", "# P2P GET requests received", 0 },
+  { "dht", "# RESULT messages queued for transmission", 0 },
+  { "dht", "# P2P RESULTS received", 0 },
+  { "dht", "# Queued messages discarded (peer disconnected)", 0 },
+  { "dht", "# Peers excluded from routing due to Bloomfilter", 0 },
+  { "dht", "# Peer selection failed", 0 },
+  { "dht", "# FIND PEER requests ignored due to Bloomfilter", 0 },
+  { "dht", "# FIND PEER requests ignored due to lack of HELLO", 0 },
+  { "dht", "# P2P FIND PEER requests processed", 0 },
+  { "dht", "# P2P GET requests ONLY routed", 0 },
+  { "dht", "# Preference updates given to core", 0 },
+  { "dht", "# REPLIES ignored for CLIENTS (no match)", 0 },
+  { "dht", "# GET requests from clients injected", 0 },
+  { "dht", "# GET requests received from clients", 0 },
+  { "dht", "# GET STOP requests received from clients", 0 },
+  { "dht", "# ITEMS stored in datacache", 0 },
+  { "dht", "# Good RESULTS found in datacache", 0 },
+  { "dht", "# GET requests given to datacache", 0 },
+  { NULL, NULL, 0 }
 };
 
 
 static struct GNUNET_DHT_TEST_Context *
-stop_ops ()
+stop_ops()
 {
   struct GetOperation *get_op;
   struct GNUNET_DHT_TEST_Context *ctx = NULL;
 
   if (NULL != timeout_task)
-  {
-    ctx = GNUNET_SCHEDULER_cancel (timeout_task);
-    timeout_task = NULL;
-  }
+    {
+      ctx = GNUNET_SCHEDULER_cancel(timeout_task);
+      timeout_task = NULL;
+    }
   if (NULL != put_task)
-  {
-    GNUNET_SCHEDULER_cancel (put_task);
-    put_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(put_task);
+      put_task = NULL;
+    }
   if (NULL != get_task)
-  {
-    GNUNET_SCHEDULER_cancel (get_task);
-    get_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(get_task);
+      get_task = NULL;
+    }
   while (NULL != (get_op = get_tail))
-  {
-    GNUNET_DHT_get_stop (get_op->get);
-    GNUNET_CONTAINER_DLL_remove (get_head,
-                                 get_tail,
-                                 get_op);
-    GNUNET_free (get_op);
-  }
+    {
+      GNUNET_DHT_get_stop(get_op->get);
+      GNUNET_CONTAINER_DLL_remove(get_head,
+                                  get_tail,
+                                  get_op);
+      GNUNET_free(get_op);
+    }
   return ctx;
 }
 
@@ -193,32 +190,32 @@ stop_ops ()
  * @param emsg error message on failure
  */
 static void
-stats_finished (void *cls,
-                struct GNUNET_TESTBED_Operation *op,
-                const char *emsg)
+stats_finished(void *cls,
+               struct GNUNET_TESTBED_Operation *op,
+               const char *emsg)
 {
   struct GNUNET_DHT_TEST_Context *ctx = cls;
   unsigned int i;
 
   if (NULL != op)
-    GNUNET_TESTBED_operation_done (op);
+    GNUNET_TESTBED_operation_done(op);
   if (NULL != emsg)
-  {
-    fprintf (stderr,
-             _("Gathering statistics failed: %s\n"),
-             emsg);
-    GNUNET_SCHEDULER_cancel (put_task);
-    GNUNET_DHT_TEST_cleanup (ctx);
-    return;
-  }
+    {
+      fprintf(stderr,
+              _("Gathering statistics failed: %s\n"),
+              emsg);
+      GNUNET_SCHEDULER_cancel(put_task);
+      GNUNET_DHT_TEST_cleanup(ctx);
+      return;
+    }
   for (i = 0; NULL != stats[i].name; i++)
-    fprintf (stderr,
-             "%6s/%60s = %12llu\n",
-             stats[i].subsystem,
-             stats[i].name,
-             stats[i].total);
-  GNUNET_DHT_TEST_cleanup (ctx);
-  GNUNET_SCHEDULER_shutdown ();
+    fprintf(stderr,
+            "%6s/%60s = %12llu\n",
+            stats[i].subsystem,
+            stats[i].name,
+            stats[i].total);
+  GNUNET_DHT_TEST_cleanup(ctx);
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -234,20 +231,20 @@ stats_finished (void *cls,
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
  */
 static int
-handle_stats (void *cls,
-              const struct GNUNET_TESTBED_Peer *peer,
-              const char *subsystem,
-              const char *name,
-              uint64_t value,
-              int is_persistent)
+handle_stats(void *cls,
+             const struct GNUNET_TESTBED_Peer *peer,
+             const char *subsystem,
+             const char *name,
+             uint64_t value,
+             int is_persistent)
 {
   unsigned int i;
 
   for (i = 0; NULL != stats[i].name; i++)
-    if ( (0 == strcasecmp (subsystem,
-                           stats[i].subsystem)) &&
-         (0 == strcasecmp (name,
-                           stats[i].name)) )
+    if ((0 == strcasecmp(subsystem,
+                         stats[i].subsystem)) &&
+        (0 == strcasecmp(name,
+                         stats[i].name)))
       stats[i].total += value;
   return GNUNET_OK;
 }
@@ -260,9 +257,9 @@ handle_stats (void *cls,
  * @param cls the 'struct GNUNET_DHT_TestContext'
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
-  (void) stop_ops ();
+  (void)stop_ops();
 }
 
 
@@ -273,12 +270,12 @@ shutdown_task (void *cls)
  * @param cls the `struct GNUNET_DHT_TestContext`
  */
 static void
-timeout_cb (void *cls)
+timeout_cb(void *cls)
 {
   timeout_task = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Timeout\n");
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+             "Timeout\n");
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -298,75 +295,75 @@ timeout_cb (void *cls)
  * @param data pointer to the result data
  */
 static void
-dht_get_handler (void *cls,
-                 struct GNUNET_TIME_Absolute exp,
-                 const struct GNUNET_HashCode *key,
-                 const struct GNUNET_PeerIdentity *get_path,
-                 unsigned int get_path_length,
-                 const struct GNUNET_PeerIdentity *put_path,
-                 unsigned int put_path_length,
-                 enum GNUNET_BLOCK_Type type,
-                 size_t size,
-                 const void *data)
+dht_get_handler(void *cls,
+                struct GNUNET_TIME_Absolute exp,
+                const struct GNUNET_HashCode *key,
+                const struct GNUNET_PeerIdentity *get_path,
+                unsigned int get_path_length,
+                const struct GNUNET_PeerIdentity *put_path,
+                unsigned int put_path_length,
+                enum GNUNET_BLOCK_Type type,
+                size_t size,
+                const void *data)
 {
   struct GetOperation *get_op = cls;
   struct GNUNET_HashCode want;
   struct GNUNET_DHT_TEST_Context *ctx;
 
-  if (sizeof (struct GNUNET_HashCode) != size)
-  {
-    GNUNET_break (0);
-    return;
-  }
-  GNUNET_CRYPTO_hash (key,
-                      sizeof (*key),
-                      &want);
-  if (0 != memcmp (&want,
-                   data,
-                   sizeof (want)))
-  {
-    GNUNET_break (0);
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Get successful\n");
+  if (sizeof(struct GNUNET_HashCode) != size)
+    {
+      GNUNET_break(0);
+      return;
+    }
+  GNUNET_CRYPTO_hash(key,
+                     sizeof(*key),
+                     &want);
+  if (0 != memcmp(&want,
+                  data,
+                  sizeof(want)))
+    {
+      GNUNET_break(0);
+      return;
+    }
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Get successful\n");
 #if 0
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "PATH: (get %u, put %u)\n",
-                get_path_length,
-                put_path_length);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "  LOCAL\n");
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               "PATH: (get %u, put %u)\n",
+               get_path_length,
+               put_path_length);
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               "  LOCAL\n");
     for (int i = get_path_length - 1; i >= 0; i--)
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "  %s\n",
-                  GNUNET_i2s (&get_path[i]));
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "  %s\n",
+                 GNUNET_i2s(&get_path[i]));
     for (int i = put_path_length - 1; i >= 0; i--)
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "  %s\n",
-                  GNUNET_i2s (&put_path[i]));
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "  %s\n",
+                 GNUNET_i2s(&put_path[i]));
   }
 #endif
-  GNUNET_DHT_get_stop (get_op->get);
-  GNUNET_CONTAINER_DLL_remove (get_head,
-                               get_tail,
-                               get_op);
-  GNUNET_free (get_op);
+  GNUNET_DHT_get_stop(get_op->get);
+  GNUNET_CONTAINER_DLL_remove(get_head,
+                              get_tail,
+                              get_op);
+  GNUNET_free(get_op);
   if (NULL != get_head)
     return;
   /* all DHT GET operations successful; get stats! */
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "All DHT operations successful. Obtaining stats!\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "All DHT operations successful. Obtaining stats!\n");
   ok = 0;
-  ctx = stop_ops ();
-  GNUNET_assert (NULL != ctx);
-  (void) GNUNET_TESTBED_get_statistics (NUM_PEERS,
-                                        my_peers,
-                                        NULL, NULL,
-                                        &handle_stats,
-                                        &stats_finished,
-                                        ctx);
+  ctx = stop_ops();
+  GNUNET_assert(NULL != ctx);
+  (void)GNUNET_TESTBED_get_statistics(NUM_PEERS,
+                                      my_peers,
+                                      NULL, NULL,
+                                      &handle_stats,
+                                      &stats_finished,
+                                      ctx);
 }
 
 
@@ -377,38 +374,38 @@ dht_get_handler (void *cls,
  * @param tc Task context
  */
 static void
-do_puts (void *cls)
+do_puts(void *cls)
 {
   struct GNUNET_DHT_Handle **hs = cls;
   struct GNUNET_HashCode key;
   struct GNUNET_HashCode value;
 
   put_task = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Putting values into DHT\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Putting values into DHT\n");
   for (unsigned int i = 0; i < NUM_PEERS; i++)
-  {
-    GNUNET_CRYPTO_hash (&i,
-                        sizeof (i),
-                        &key);
-    GNUNET_CRYPTO_hash (&key,
-                        sizeof (key),
-                        &value);
-    GNUNET_DHT_put (hs[i],
-                    &key,
-                    10U,
-                    GNUNET_DHT_RO_RECORD_ROUTE |
-                    GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
-                    GNUNET_BLOCK_TYPE_TEST,
-                    sizeof (value),
-                    &value,
-                    GNUNET_TIME_UNIT_FOREVER_ABS,
-                    NULL,
-                    NULL);
-  }
-  put_task = GNUNET_SCHEDULER_add_delayed (PUT_FREQUENCY,
-                                           &do_puts,
-                                           hs);
+    {
+      GNUNET_CRYPTO_hash(&i,
+                         sizeof(i),
+                         &key);
+      GNUNET_CRYPTO_hash(&key,
+                         sizeof(key),
+                         &value);
+      GNUNET_DHT_put(hs[i],
+                     &key,
+                     10U,
+                     GNUNET_DHT_RO_RECORD_ROUTE |
+                     GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+                     GNUNET_BLOCK_TYPE_TEST,
+                     sizeof(value),
+                     &value,
+                     GNUNET_TIME_UNIT_FOREVER_ABS,
+                     NULL,
+                     NULL);
+    }
+  put_task = GNUNET_SCHEDULER_add_delayed(PUT_FREQUENCY,
+                                          &do_puts,
+                                          hs);
 }
 
 
@@ -416,7 +413,7 @@ do_puts (void *cls)
  * Start GET operations.
  */
 static void
-start_get (void *cls)
+start_get(void *cls)
 {
   struct GNUNET_DHT_Handle **dhts = cls;
   unsigned int i;
@@ -425,26 +422,26 @@ start_get (void *cls)
   struct GetOperation *get_op;
 
   get_task = NULL;
-  for (i=0;i<NUM_PEERS;i++)
-  {
-    GNUNET_CRYPTO_hash (&i, sizeof (i), &key);
-    for (j=0;j<NUM_PEERS;j++)
+  for (i = 0; i < NUM_PEERS; i++)
     {
-      get_op = GNUNET_new (struct GetOperation);
-      GNUNET_CONTAINER_DLL_insert (get_head,
-                                   get_tail,
-                                   get_op);
-      get_op->get = GNUNET_DHT_get_start (dhts[j],
-                                          GNUNET_BLOCK_TYPE_TEST, /* type */
-                                          &key,      /*key to search */
-                                          4U,     /* replication level */
-                                          GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
-                                          NULL,        /* xquery */
-                                          0,      /* xquery bits */
-                                          &dht_get_handler,
-                                          get_op);
+      GNUNET_CRYPTO_hash(&i, sizeof(i), &key);
+      for (j = 0; j < NUM_PEERS; j++)
+        {
+          get_op = GNUNET_new(struct GetOperation);
+          GNUNET_CONTAINER_DLL_insert(get_head,
+                                      get_tail,
+                                      get_op);
+          get_op->get = GNUNET_DHT_get_start(dhts[j],
+                                             GNUNET_BLOCK_TYPE_TEST, /* type */
+                                             &key,   /*key to search */
+                                             4U,  /* replication level */
+                                             GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+                                             NULL,     /* xquery */
+                                             0,   /* xquery bits */
+                                             &dht_get_handler,
+                                             get_op);
+        }
     }
-  }
 }
 
 
@@ -458,26 +455,26 @@ start_get (void *cls)
  * @param dhts handle to each of the DHTs of the peers
  */
 static void
-run (void *cls,
-     struct GNUNET_DHT_TEST_Context *ctx,
-     unsigned int num_peers,
-     struct GNUNET_TESTBED_Peer **peers,
-     struct GNUNET_DHT_Handle **dhts)
+run(void *cls,
+    struct GNUNET_DHT_TEST_Context *ctx,
+    unsigned int num_peers,
+    struct GNUNET_TESTBED_Peer **peers,
+    struct GNUNET_DHT_Handle **dhts)
 {
-  GNUNET_assert (NUM_PEERS == num_peers);
+  GNUNET_assert(NUM_PEERS == num_peers);
   my_peers = peers;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peers setup, starting test\n");
-  put_task = GNUNET_SCHEDULER_add_now (&do_puts,
-                                       dhts);
-  get_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                           &start_get,
-                                           dhts);
-  timeout_task = GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT,
-                                               &timeout_cb,
-                                               ctx);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
-                                 ctx);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Peers setup, starting test\n");
+  put_task = GNUNET_SCHEDULER_add_now(&do_puts,
+                                      dhts);
+  get_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS,
+                                          &start_get,
+                                          dhts);
+  timeout_task = GNUNET_SCHEDULER_add_delayed(GET_TIMEOUT,
+                                              &timeout_cb,
+                                              ctx);
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
+                                ctx);
 }
 
 
@@ -485,44 +482,44 @@ run (void *cls,
  * Main: start test
  */
 int
-main (int xargc, char *xargv[])
+main(int xargc, char *xargv[])
 {
   const char *cfg_filename;
   const char *test_name;
 
-  if (NULL != strstr (xargv[0], "test_dht_2dtorus"))
-  {
-    cfg_filename = "test_dht_2dtorus.conf";
-    test_name = "test-dht-2dtorus";
-    NUM_PEERS = 16;
-  }
-  else if (NULL != strstr (xargv[0], "test_dht_line"))
-  {
-    cfg_filename = "test_dht_line.conf";
-    test_name = "test-dht-line";
-    NUM_PEERS = 5;
-  }
-  else if (NULL != strstr (xargv[0], "test_dht_twopeer"))
-  {
-    cfg_filename = "test_dht_line.conf";
-    test_name = "test-dht-twopeer";
-    NUM_PEERS = 2;
-  }
-  else if (NULL != strstr (xargv[0], "test_dht_multipeer"))
-  {
-    cfg_filename = "test_dht_multipeer.conf";
-    test_name = "test-dht-multipeer";
-    NUM_PEERS = 10;
-  }
+  if (NULL != strstr(xargv[0], "test_dht_2dtorus"))
+    {
+      cfg_filename = "test_dht_2dtorus.conf";
+      test_name = "test-dht-2dtorus";
+      NUM_PEERS = 16;
+    }
+  else if (NULL != strstr(xargv[0], "test_dht_line"))
+    {
+      cfg_filename = "test_dht_line.conf";
+      test_name = "test-dht-line";
+      NUM_PEERS = 5;
+    }
+  else if (NULL != strstr(xargv[0], "test_dht_twopeer"))
+    {
+      cfg_filename = "test_dht_line.conf";
+      test_name = "test-dht-twopeer";
+      NUM_PEERS = 2;
+    }
+  else if (NULL != strstr(xargv[0], "test_dht_multipeer"))
+    {
+      cfg_filename = "test_dht_multipeer.conf";
+      test_name = "test-dht-multipeer";
+      NUM_PEERS = 10;
+    }
   else
-  {
-    GNUNET_break (0);
-    return 1;
-  }
-  GNUNET_DHT_TEST_run (test_name,
-                       cfg_filename,
-                       NUM_PEERS,
-                       &run, NULL);
+    {
+      GNUNET_break(0);
+      return 1;
+    }
+  GNUNET_DHT_TEST_run(test_name,
+                      cfg_filename,
+                      NUM_PEERS,
+                      &run, NULL);
   return ok;
 }