src/testbed/test_testbed_api_statistics.c

   1 /*
   2       This file is part of GNUnet
   3       Copyright (C) 2008--2013 GNUnet e.V.
   4
   5       GNUnet is free software; you can redistribute it and/or modify
   6       it under the terms of the GNU General Public License as published
   7       by the Free Software Foundation; either version 3, or (at your
   8       option) any later version.
   9
  10       GNUnet is distributed in the hope that it will be useful, but
  11       WITHOUT ANY WARRANTY; without even the implied warranty of
  12       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13       General Public License for more details.
  14
  15       You should have received a copy of the GNU General Public License
  16       along with GNUnet; see the file COPYING.  If not, write to the
  17       Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18       Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * @file testbed/test_testbed_api_statistics.c
  23  * @brief testcase for testing GNUNET_TESTBED_get_statistics() implementation
  24  * @author Sree Harsha Totakura <sreeharsha@totakura.in>
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_testbed_service.h"
  30
  31 /**
  32  * Number of peers we want to start
  33  */
  34 #define NUM_PEERS 5
  35
  36 /**
  37  * The array of peers; we get them from the testbed
  38  */
  39 static struct GNUNET_TESTBED_Peer **peers;
  40
  41 /**
  42  * Operation handle
  43  */
  44 static struct GNUNET_TESTBED_Operation *op;
  45
  46 /**
  47  * dummy pointer
  48  */
  49 static void *dummy_cls = (void *) 0xDEAD0001;
  50
  51 /**
  52  * Abort task identifier
  53  */
  54 static struct GNUNET_SCHEDULER_Task * abort_task;
  55
  56 /**
  57  * Global testing result
  58  */
  59 static int result;
  60
  61 /**
  62  * The peers we have seen in the statistics iterator
  63  */
  64 static struct GNUNET_TESTBED_Peer **seen_peers;
  65
  66 /**
  67  * Number of peers in the above array
  68  */
  69 static unsigned int num_seen_peers;
  70
  71
  72 /**
  73  * Fail testcase
  74  */
  75 #define FAIL_TEST(cond, ret) do {                               \
  76     if (!(cond)) {                                              \
  77       GNUNET_break(0);                                          \
  78       if (NULL != abort_task)               \
  79         GNUNET_SCHEDULER_cancel (abort_task);                   \
  80       abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);  \
  81       ret;                                                      \
  82     }                                                           \
  83   } while (0)
  84
  85
  86 /**
  87  * Abort task
  88  *
  89  * @param cls NULL
  90  * @param tc scheduler task context
  91  */
  92 static void
  93 do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  94 {
  95   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test timed out -- Aborting\n");
  96   abort_task = NULL;
  97   if (NULL != op)
  98   {
  99     GNUNET_TESTBED_operation_done (op);
 100     op = NULL;
 101   }
 102   result = GNUNET_SYSERR;
 103 }
 104
 105
 106 /**
 107  * Callback function to process statistic values from all peers.
 108  *
 109  * @param cls closure
 110  * @param peer the peer the statistic belong to
 111  * @param subsystem name of subsystem that created the statistic
 112  * @param name the name of the datum
 113  * @param value the current value
 114  * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not
 115  * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
 116  */
 117 static int
 118 stats_iterator (void *cls,
 119                 const struct GNUNET_TESTBED_Peer *peer,
 120                 const char *subsystem, const char *name, uint64_t value,
 121                 int is_persistent)
 122 {
 123   unsigned int cnt;
 124
 125   FAIL_TEST (cls == dummy_cls, return GNUNET_SYSERR);
 126   for (cnt = 0; cnt < num_seen_peers; cnt++)
 127     FAIL_TEST (peer != seen_peers[cnt], return GNUNET_SYSERR);
 128   FAIL_TEST (NULL != subsystem, return GNUNET_SYSERR);
 129   FAIL_TEST (NULL != name, return GNUNET_SYSERR);
 130   GNUNET_array_append (seen_peers, num_seen_peers,
 131                        (struct GNUNET_TESTBED_Peer *) peer);
 132   return GNUNET_SYSERR;
 133 }
 134
 135
 136 /**
 137  * Callback to be called when an operation is completed
 138  *
 139  * @param cls the callback closure from functions generating an operation
 140  * @param op the operation that has been finished
 141  * @param emsg error message in case the operation has failed; will be NULL if
 142  *          operation has executed successfully.
 143  */
 144 static void
 145 op_comp_cb (void *cls,
 146             struct GNUNET_TESTBED_Operation *op,
 147             const char *emsg)
 148 {
 149   FAIL_TEST (cls == dummy_cls, return);
 150   result = GNUNET_OK;
 151   GNUNET_TESTBED_operation_done (op);
 152   op = NULL;
 153   GNUNET_SCHEDULER_cancel (abort_task);
 154   GNUNET_SCHEDULER_shutdown ();
 155 }
 156
 157
 158 /**
 159  * Signature of a main function for a testcase.
 160  *
 161  * @param cls closure
 162  * @param h the run handle
 163  * @param num_peers number of peers in 'peers'
 164  * @param peers_ handle to peers run in the testbed
 165  * @param links_succeeded the number of overlay link connection attempts that
 166  *          succeeded
 167  * @param links_failed the number of overlay link connection attempts that
 168  *          failed
 169  */
 170 static void
 171 test_master (void *cls,
 172              struct GNUNET_TESTBED_RunHandle *h,
 173              unsigned int num_peers,
 174              struct GNUNET_TESTBED_Peer **peers_,
 175              unsigned int links_succeeded,
 176              unsigned int links_failed)
 177 {
 178   FAIL_TEST (NUM_PEERS == num_peers, return);
 179   peers = peers_;
 180   op = GNUNET_TESTBED_get_statistics (num_peers, peers,
 181                                       NULL, NULL,
 182                                       &stats_iterator,
 183                                       &op_comp_cb,
 184                                       dummy_cls);
 185   abort_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
 186                                              (GNUNET_TIME_UNIT_MINUTES, 1),
 187                                              &do_abort, NULL);
 188 }
 189
 190
 191 /**
 192  * Main function
 193  */
 194 int
 195 main (int argc, char **argv)
 196 {
 197   (void) GNUNET_TESTBED_test_run ("test_testbed_api_statistics",
 198                                   "test_testbed_api_statistics.conf",
 199                                   NUM_PEERS,
 200                                   1LL, NULL, NULL,
 201                                   &test_master, NULL);
 202   GNUNET_free_non_null (seen_peers);
 203   if (GNUNET_OK != result)
 204     return 1;
 205   return 0;
 206 }