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", n->peer,
  82                 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, status);
  90     failed++;
  91   }
  92   for (c = n->children_head, i = 0; NULL != c; c = c->next, i++) ;
  93   if (i != children)
  94   {
  95     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
  96                 "Retrieved peer wrong has number of children! (Got %u, expected %u)\n",
  97                 i, children);
  98     failed++;
  99   }
 100   if (0 != first_hop &&
 101       GNUNET_PEER_search (tree_get_first_hop (tree, peer_id)) != first_hop)
 102   {
 103     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 104                 "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", GNUNET_i2s (&id),
 116                 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 (5);
 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 (NULL == path1 || 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: Calculating costs...\n");
 219   for (i = 1; i < 5; i++)
 220   {
 221     path->length = i;
 222     if (tree_get_path_cost (tree, path) != 0)
 223     {
 224       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "test: length %u cost failed!\n",
 225                   i);
 226       failed++;
 227     }
 228   }
 229   path->length++;
 230   path->peers[4] = 6;
 231   if (tree_get_path_cost (tree, path) != 1)
 232   {
 233     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "test: length %u cost failed!\n", i);
 234     failed++;
 235   }
 236   path->peers[3] = 7;
 237   if (tree_get_path_cost (tree, path) != 2)
 238   {
 239     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "test: length %u cost failed!\n", i);
 240     failed++;
 241   }
 242   path->length--;
 243   if (tree_get_path_cost (tree, path) != 1)
 244   {
 245     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "test: length %u cost failed!\n", i);
 246     failed++;
 247   }
 248   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Deleting third path (5)\n");
 249   tree_set_status (tree, 5, MESH_PEER_READY);
 250   cb_call = 1;
 251   node = tree_del_path (tree, 5, &cb, NULL);
 252   tree_debug (tree);
 253   if (cb_call != 0)
 254   {
 255     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%u callbacks missed!\n", cb_call);
 256     failed++;
 257   }
 258   if (node->peer != 5)
 259   {
 260     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Retrieved peer != original\n");
 261     failed++;
 262   }
 263
 264   test_assert (4, MESH_PEER_SEARCHING, 0, 2);
 265   test_assert (3, MESH_PEER_SEARCHING, 1, 2);
 266   test_assert (2, MESH_PEER_RELAY, 1, 0);
 267   test_assert (1, MESH_PEER_ROOT, 1, 0);
 268
 269   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Destroying node copy...\n");
 270   GNUNET_free (node);
 271
 272   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 273               "test: Adding new shorter first path...\n");
 274   path->length = 2;
 275   path->peers[1] = 4;
 276   cb_call = 1;
 277   tree_find_peer (tree, 4)->status = MESH_PEER_READY;
 278   tree_add_path (tree, path, &cb, NULL);
 279   tree_debug (tree);
 280   if (cb_call != 0)
 281   {
 282     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%u callbacks missed!\n", cb_call);
 283     failed++;
 284   }
 285
 286   test_assert (4, MESH_PEER_SEARCHING, 0, 4);
 287   test_assert (3, MESH_PEER_SEARCHING, 0, 2);
 288   test_assert (2, MESH_PEER_RELAY, 1, 0);
 289   test_assert (1, MESH_PEER_ROOT, 2, 0);
 290
 291   GNUNET_free (path->peers);
 292   GNUNET_free (path);
 293   tree_destroy (tree);
 294
 295   /****************************************************************************/
 296
 297   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test:\n");
 298   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Testing relay trees\n");
 299   for (i = 0; i < 10; i++)
 300   {
 301     GNUNET_break (i + 1 == GNUNET_PEER_intern (pi[i]));
 302   }
 303   tree = tree_new (2);
 304   path = path_new (8);
 305   path->peers[0] = 2;
 306   path->peers[1] = 1;
 307   path->peers[2] = 3;
 308   path->length = 3;
 309
 310   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Adding first path: 2 1 3\n");
 311   tree_add_path (tree, path, &cb, NULL);
 312   tree_debug (tree);
 313
 314   test_assert (3, MESH_PEER_SEARCHING, 0, 3);
 315   test_assert (1, MESH_PEER_RELAY, 1, 0);
 316   test_assert (2, MESH_PEER_ROOT, 1, 0);
 317
 318   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Adding long path: 2 1 4 5 3\n");
 319   path->peers[2] = 4;
 320   path->peers[3] = 5;
 321   path->peers[4] = 3;
 322   path->length = 5;
 323   tree_add_path (tree, path, &cb, NULL);
 324   tree_debug (tree);
 325
 326   test_assert (3, MESH_PEER_SEARCHING, 0, 4);
 327   test_assert (5, MESH_PEER_RELAY, 1, 4);
 328   test_assert (4, MESH_PEER_RELAY, 1, 4);
 329   test_assert (1, MESH_PEER_RELAY, 1, 0);
 330   test_assert (2, MESH_PEER_ROOT, 1, 0);
 331
 332   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 333               "test: Even longer path: 2 6 1 7 8 4 5 3\n");
 334   path->peers[0] = 2;
 335   path->peers[1] = 6;
 336   path->peers[2] = 1;
 337   path->peers[3] = 7;
 338   path->peers[4] = 8;
 339   path->peers[5] = 4;
 340   path->peers[6] = 5;
 341   path->peers[7] = 3;
 342   path->length = 8;
 343   tree_add_path (tree, path, &cb, NULL);
 344   tree_debug (tree);
 345
 346   test_assert (3, MESH_PEER_SEARCHING, 0, 7);
 347   test_assert (5, MESH_PEER_RELAY, 1, 7);
 348   test_assert (4, MESH_PEER_RELAY, 1, 7);
 349   test_assert (8, MESH_PEER_RELAY, 1, 7);
 350   test_assert (7, MESH_PEER_RELAY, 1, 7);
 351   test_assert (1, MESH_PEER_RELAY, 1, 0);
 352   test_assert (6, MESH_PEER_RELAY, 1, 0);
 353   test_assert (2, MESH_PEER_ROOT, 1, 0);
 354
 355   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Adding first path: 2 1 3\n");
 356   path->peers[1] = 1;
 357   path->peers[2] = 3;
 358   path->length = 3;
 359   tree_add_path (tree, path, &cb, NULL);
 360   tree_debug (tree);
 361
 362   test_assert (3, MESH_PEER_SEARCHING, 0, 3);
 363   test_assert (1, MESH_PEER_RELAY, 1, 0);
 364   test_assert (2, MESH_PEER_ROOT, 1, 0);
 365
 366   GNUNET_free (path->peers);
 367   GNUNET_free (path);
 368   tree_destroy (tree);
 369   finish ();
 370   if (failed > 0)
 371   {
 372     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%u tests failed\n", failed);
 373     return 1;
 374   }
 375   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: OK\n");
 376
 377   return 0;
 378 }