src/mesh/test_mesh_tree_api.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2011 Christian Grothoff (and other contributing authors)
   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., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file mesh/test_mesh_tree_api.c
  23  * @brief test mesh tree api: test of tree & path management api
  24  * @author Bartlomiej Polot
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_common.h"
  29 #include "gnunet_util_lib.h"
  30 #include "gnunet_dht_service.h"
  31 #include "gnunet_mesh_service.h"
  32 #include "mesh.h"
  33 #ifndef MESH_TUNNEL_TREE_C
  34 #include "mesh_tunnel_tree.c"
  35 #define MESH_TUNNEL_TREE_C
  36 #endif
  37
  38 #define VERBOSE 1
  39
  40 int failed;
  41 int cb_call;
  42 struct GNUNET_PeerIdentity *pi[10];
  43 struct MeshTunnelTree *tree;
  44
  45 static void
  46 cb (void *cls, GNUNET_PEER_Id peer_id)
  47 {
  48   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: CB: Disconnected %u\n", peer_id);
  49   if (0 == cb_call)
  50   {
  51     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test:      and it shouldn't!\n");
  52     failed++;
  53   }
  54   cb_call--;
  55 }
  56
  57
  58 /**
  59  * Check if a node has all expected properties.
  60  *
  61  * @param peer_id Short ID of the peer to test.
  62  * @param status Expected status of the peer.
  63  * @param children Expected number of children of the peer.
  64  * @param first_hop Short ID of the expected first hop towards the peer.
  65  */
  66 static void
  67 test_assert (GNUNET_PEER_Id peer_id, enum MeshPeerState status,
  68              unsigned int children, GNUNET_PEER_Id first_hop)
  69 {
  70   struct MeshTunnelTreeNode *n;
  71   struct MeshTunnelTreeNode *c;
  72   unsigned int i;
  73   int pre_failed;
  74
  75   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Checking peer %u\n", peer_id);
  76   pre_failed = failed;
  77   n = tree_find_peer (tree, peer_id);
  78   if (n->peer != peer_id)
  79   {
  80     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
  81                 "Retrieved peer has wrong ID! (Got %u, expected %u)\n",
  82                 n->peer, peer_id);
  83     failed++;
  84   }
  85   if (n->status != status)
  86   {
  87     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
  88                 "Retrieved peer has wrong status! (Got %u, expected %u)\n",
  89                 n->status,
  90                 status);
  91     failed++;
  92   }
  93   for (c = n->children_head, i = 0; NULL != c; c = c->next, i++) ;
  94   if (i != children)
  95   {
  96     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
  97                 "Retrieved peer wrong has number of children! (Got %u, expected %u)\n",
  98                 i, children);
  99     failed++;
 100   }
 101   if (0 != first_hop &&
 102       GNUNET_PEER_search (tree_get_first_hop (tree, peer_id)) != first_hop)
 103   {
 104     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Wrong first hop! (Got %u, expected %u)\n",
 105                 GNUNET_PEER_search (tree_get_first_hop (tree, peer_id)),
 106                 first_hop);
 107     failed++;
 108   }
 109   if (pre_failed != failed)
 110   {
 111     struct GNUNET_PeerIdentity id;
 112
 113     GNUNET_PEER_resolve (peer_id, &id);
 114     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 115                 "*** Peer %s (%u) has failed %d checks!\n",
 116                 GNUNET_i2s (&id), peer_id, failed - pre_failed);
 117   }
 118 }
 119
 120
 121 static void
 122 finish (void)
 123 {
 124   unsigned int i;
 125
 126   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Finishing...\n");
 127   for (i = 0; i < 10; i++)
 128   {
 129     GNUNET_free (pi[i]);
 130   }
 131 }
 132
 133 /**
 134  * Convert an integer int to a peer identity
 135  */
 136 static struct GNUNET_PeerIdentity *
 137 get_pi (uint32_t id)
 138 {
 139   struct GNUNET_PeerIdentity *pi;
 140
 141   pi = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
 142   pi->hashPubKey.bits[0] = id + 1;
 143   return pi;
 144 }
 145
 146
 147 int
 148 main (int argc, char *argv[])
 149 {
 150   struct MeshTunnelTreeNode *node;
 151   struct MeshPeerPath *path;
 152   struct MeshPeerPath *path1;
 153   unsigned int i;
 154
 155   failed = 0;
 156   cb_call = 0;
 157   GNUNET_log_setup ("test_mesh_api_tree",
 158 #if VERBOSE
 159                     "DEBUG",
 160 #else
 161                     "WARNING",
 162 #endif
 163                     NULL);
 164   for (i = 0; i < 10; i++)
 165   {
 166     pi[i] = get_pi (i);
 167     GNUNET_break (i + 1 == GNUNET_PEER_intern (pi[i]));
 168     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Peer %u: %s\n", i + 1,
 169                 GNUNET_h2s (&pi[i]->hashPubKey));
 170   }
 171   tree = tree_new (1);
 172   tree->me = tree->root;
 173   path = path_new (4);
 174   path->peers[0] = 1;
 175   path->peers[1] = 2;
 176   path->peers[2] = 3;
 177   path->peers[3] = 4;
 178   path->length = 4;
 179
 180   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Adding first path: 1 2 3 4\n");
 181   tree_add_path (tree, path, &cb, NULL);
 182   tree_debug (tree);
 183   path1 = tree_get_path_to_peer (tree, 4);
 184   if (path->length != path1->length ||
 185       memcmp (path->peers, path1->peers, path->length) != 0)
 186   {
 187     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Retrieved path != original\n");
 188     failed++;
 189   }
 190   path_destroy (path1);
 191   test_assert (4, MESH_PEER_SEARCHING, 0, 2);
 192   test_assert (3, MESH_PEER_RELAY, 1, 0);
 193   test_assert (2, MESH_PEER_RELAY, 1, 0);
 194   test_assert (1, MESH_PEER_ROOT, 1, 0);
 195
 196   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Adding second path: 1 2 3\n");
 197   path->length--;
 198   tree_add_path (tree, path, &cb, NULL);
 199   tree_debug (tree);
 200
 201   test_assert (4, MESH_PEER_SEARCHING, 0, 2);
 202   test_assert (3, MESH_PEER_SEARCHING, 1, 2);
 203   test_assert (2, MESH_PEER_RELAY, 1, 0);
 204   test_assert (1, MESH_PEER_ROOT, 1, 0);
 205
 206   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Adding third path 1 2 3 5\n");
 207   path->length++;
 208   path->peers[3] = 5;
 209   tree_add_path (tree, path, &cb, NULL);
 210   tree_debug (tree);
 211
 212   test_assert (5, MESH_PEER_SEARCHING, 0, 2);
 213   test_assert (4, MESH_PEER_SEARCHING, 0, 2);
 214   test_assert (3, MESH_PEER_SEARCHING, 2, 2);
 215   test_assert (2, MESH_PEER_RELAY, 1, 0);
 216   test_assert (1, MESH_PEER_ROOT, 1, 0);
 217
 218   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Deleting third path (5)\n");
 219   tree_set_status(tree, 5, MESH_PEER_READY);
 220   cb_call = 1;
 221   node = tree_del_path (tree, 5, &cb, NULL);
 222   tree_debug (tree);
 223   if (cb_call != 0)
 224   {
 225     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%u callbacks missed!\n", cb_call);
 226     failed++;
 227   }
 228   if (node->peer != 5)
 229   {
 230     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Retrieved peer != original\n");
 231     failed++;
 232   }
 233
 234   test_assert (4, MESH_PEER_SEARCHING, 0, 2);
 235   test_assert (3, MESH_PEER_SEARCHING, 1, 2);
 236   test_assert (2, MESH_PEER_RELAY, 1, 0);
 237   test_assert (1, MESH_PEER_ROOT, 1, 0);
 238
 239   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Destroying node copy...\n");
 240   GNUNET_free (node);
 241
 242   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 243               "test: Adding new shorter first path...\n");
 244   path->length = 2;
 245   path->peers[1] = 4;
 246   cb_call = 1;
 247   tree_find_peer (tree, 4)->status = MESH_PEER_READY;
 248   tree_add_path (tree, path, &cb, NULL);
 249   tree_debug (tree);
 250   if (cb_call != 0)
 251   {
 252     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%u callbacks missed!\n", cb_call);
 253     failed++;
 254   }
 255
 256   test_assert (4, MESH_PEER_SEARCHING, 0, 4);
 257   test_assert (3, MESH_PEER_SEARCHING, 0, 2);
 258   test_assert (2, MESH_PEER_RELAY, 1, 0);
 259   test_assert (1, MESH_PEER_ROOT, 2, 0);
 260
 261   GNUNET_free (path->peers);
 262   GNUNET_free (path);
 263   tree_destroy (tree);
 264
 265   /****************************************************************************/
 266
 267   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test:\n");
 268   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Testing relay trees\n");
 269   for (i = 0; i < 10; i++)
 270   {
 271     GNUNET_break (i + 1 == GNUNET_PEER_intern (pi[i]));
 272   }
 273   tree = tree_new (2);
 274   path = path_new (8);
 275   path->peers[0] = 2;
 276   path->peers[1] = 1;
 277   path->peers[2] = 3;
 278   path->length = 3;
 279
 280   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Adding first path: 2 1 3\n");
 281   tree_add_path (tree, path, &cb, NULL);
 282   tree_debug (tree);
 283
 284   test_assert (3, MESH_PEER_SEARCHING, 0, 3);
 285   test_assert (1, MESH_PEER_RELAY, 1, 0);
 286   test_assert (2, MESH_PEER_ROOT, 1, 0);
 287
 288   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Adding long path: 2 1 4 5 3\n");
 289   path->peers[2] = 4;
 290   path->peers[3] = 5;
 291   path->peers[4] = 3;
 292   path->length = 5;
 293   tree_add_path (tree, path, &cb, NULL);
 294   tree_debug (tree);
 295
 296   test_assert (3, MESH_PEER_SEARCHING, 0, 4);
 297   test_assert (5, MESH_PEER_RELAY, 1, 4);
 298   test_assert (4, MESH_PEER_RELAY, 1, 4);
 299   test_assert (1, MESH_PEER_RELAY, 1, 0);
 300   test_assert (2, MESH_PEER_ROOT, 1, 0);
 301
 302   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 303               "test: Even longer path: 2 6 1 7 8 4 5 3\n");
 304   path->peers[0] = 2;
 305   path->peers[1] = 6;
 306   path->peers[2] = 1;
 307   path->peers[3] = 7;
 308   path->peers[4] = 8;
 309   path->peers[5] = 4;
 310   path->peers[6] = 5;
 311   path->peers[7] = 3;
 312   path->length = 8;
 313   tree_add_path (tree, path, &cb, NULL);
 314   tree_debug (tree);
 315
 316   test_assert (3, MESH_PEER_SEARCHING, 0, 7);
 317   test_assert (5, MESH_PEER_RELAY, 1, 7);
 318   test_assert (4, MESH_PEER_RELAY, 1, 7);
 319   test_assert (8, MESH_PEER_RELAY, 1, 7);
 320   test_assert (7, MESH_PEER_RELAY, 1, 7);
 321   test_assert (1, MESH_PEER_RELAY, 1, 0);
 322   test_assert (6, MESH_PEER_RELAY, 1, 0);
 323   test_assert (2, MESH_PEER_ROOT, 1, 0);
 324
 325   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Adding first path: 2 1 3\n");
 326   path->peers[1] = 1;
 327   path->peers[2] = 3;
 328   path->length = 3;
 329   tree_add_path (tree, path, &cb, NULL);
 330   tree_debug (tree);
 331
 332   test_assert (3, MESH_PEER_SEARCHING, 0, 3);
 333   test_assert (1, MESH_PEER_RELAY, 1, 0);
 334   test_assert (2, MESH_PEER_ROOT, 1, 0);
 335
 336   GNUNET_free (path->peers);
 337   GNUNET_free (path);
 338   tree_destroy (tree);
 339   finish ();
 340   if (failed > 0)
 341   {
 342     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%u tests failed\n", failed);
 343     return 1;
 344   }
 345   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: OK\n");
 346
 347   return 0;
 348 }