src/set/test_set_union_copy.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2015, 2016 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 set/test_set_union_copy.c
  23  * @brief testcase for lazy copying of union sets
  24  * @author Florian Dold
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_common.h"
  29 #include "gnunet_testing_lib.h"
  30 #include "gnunet_set_service.h"
  31
  32
  33 /**
  34  * Value to return from #main().
  35  */
  36 static int ret;
  37
  38 static struct GNUNET_PeerIdentity local_id;
  39
  40 static struct GNUNET_SET_Handle *set1;
  41
  42 static struct GNUNET_SET_Handle *set2;
  43
  44 static const struct GNUNET_CONFIGURATION_Handle *config;
  45
  46 static struct GNUNET_SCHEDULER_Task *tt;
  47
  48
  49 static void
  50 add_element_str (struct GNUNET_SET_Handle *set,
  51                  char *str)
  52 {
  53   struct GNUNET_SET_Element element;
  54
  55   element.element_type = 0;
  56   element.data = str;
  57   element.size = strlen (str);
  58   GNUNET_SET_add_element (set,
  59                           &element,
  60                           NULL,
  61                           NULL);
  62 }
  63
  64
  65 static void
  66 remove_element_str (struct GNUNET_SET_Handle *set,
  67                     char *str)
  68 {
  69   struct GNUNET_SET_Element element;
  70
  71   element.element_type = 0;
  72   element.data = str;
  73   element.size = strlen (str);
  74   GNUNET_SET_remove_element (set,
  75                              &element,
  76                              NULL,
  77                              NULL);
  78 }
  79
  80
  81 /**
  82  * Signature of the main function of a task.
  83  *
  84  * @param cls closure
  85  */
  86 static void
  87 timeout_fail (void *cls)
  88 {
  89   tt = NULL;
  90   GNUNET_SCHEDULER_shutdown ();
  91   ret = 1;
  92 }
  93
  94
  95 struct CountIterClosure
  96 {
  97   unsigned int expected_count;
  98   unsigned int ongoing_count;
  99   GNUNET_SCHEDULER_TaskCallback cont;
 100   void *cont_cls;
 101   char *what;
 102 };
 103
 104
 105 static int
 106 check_count_iter (void *cls,
 107                   const struct GNUNET_SET_Element *element)
 108 {
 109   struct CountIterClosure *ci_cls = cls;
 110
 111   if (NULL == element)
 112   {
 113     if (ci_cls->expected_count != ci_cls->ongoing_count)
 114     {
 115       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 116                   "Expected count (what: %s) to be %u, but it's actually %u\n",
 117                   ci_cls->what,
 118                   ci_cls->expected_count, ci_cls->ongoing_count);
 119       ret = 1;
 120       return GNUNET_NO;
 121     }
 122     ci_cls->cont (ci_cls->cont_cls);
 123     return GNUNET_NO;
 124   }
 125
 126   ci_cls->ongoing_count += 1;
 127   return GNUNET_YES;
 128 }
 129
 130
 131 static void
 132 check_count (struct GNUNET_SET_Handle *set,
 133              char *what,
 134              unsigned int expected_count,
 135              GNUNET_SCHEDULER_TaskCallback cont,
 136              void *cont_cls)
 137 {
 138   struct CountIterClosure *ci_cls = GNUNET_new (struct CountIterClosure);
 139
 140   ci_cls->expected_count = expected_count;
 141   ci_cls->ongoing_count = 0;
 142   ci_cls->cont = cont;
 143   ci_cls->cont_cls = cont_cls;
 144   ci_cls->what = what;
 145
 146   GNUNET_assert (GNUNET_YES ==
 147                  GNUNET_SET_iterate (set,
 148                                      &check_count_iter,
 149                                      ci_cls));
 150 }
 151
 152
 153 static void
 154 test_done (void *cls)
 155 {
 156   GNUNET_SCHEDULER_shutdown ();
 157 }
 158
 159
 160 static void
 161 check_new_set_count (void *cls)
 162 {
 163   check_count (set2,
 164                "new set",
 165                4,
 166                &test_done,
 167                NULL);
 168 }
 169
 170
 171 static void
 172 copy_done (void *cls,
 173            struct GNUNET_SET_Handle *new_set)
 174 {
 175   printf ("copy done\n");
 176   set2 = new_set;
 177   remove_element_str (set2, "spam");
 178   add_element_str (set2, "new1");
 179   add_element_str (set2, "new2");
 180   remove_element_str (set2, "new2");
 181   remove_element_str (set2, "new3");
 182   // Check that set1 didn't change.
 183   check_count (set1, "old set", 3,
 184                &check_new_set_count,
 185                NULL);
 186 }
 187
 188
 189 static void
 190 test_copy (void *cls)
 191 {
 192   printf ("about to copy\n");
 193   GNUNET_SET_copy_lazy (set1,
 194                         &copy_done,
 195                         NULL);
 196 }
 197
 198
 199 /**
 200  * Function run on shutdown.
 201  *
 202  * @param cls closure
 203  */
 204 static void
 205 do_shutdown (void *cls)
 206 {
 207   if (NULL != tt)
 208   {
 209     GNUNET_SCHEDULER_cancel (tt);
 210     tt = NULL;
 211   }
 212   if (NULL != set1)
 213   {
 214     GNUNET_SET_destroy (set1);
 215     set1 = NULL;
 216   }
 217   if (NULL != set2)
 218   {
 219     GNUNET_SET_destroy (set2);
 220     set2 = NULL;
 221   }
 222 }
 223
 224
 225 /**
 226  * Signature of the 'main' function for a (single-peer) testcase that
 227  * is run using #GNUNET_TESTING_peer_run().
 228  *
 229  * @param cls closure
 230  * @param cfg configuration of the peer that was started
 231  * @param peer identity of the peer that was created
 232  */
 233 static void
 234 run (void *cls,
 235      const struct GNUNET_CONFIGURATION_Handle *cfg,
 236      struct GNUNET_TESTING_Peer *peer)
 237 {
 238   tt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
 239                                      &timeout_fail,
 240                                      NULL);
 241   GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
 242                                  NULL);
 243   config = cfg;
 244   GNUNET_TESTING_peer_get_identity (peer,
 245                                     &local_id);
 246
 247   set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
 248   add_element_str (set1, "foo");
 249   add_element_str (set1, "bar");
 250   /* duplicate -- ignored */
 251   add_element_str (set1, "bar");
 252   remove_element_str (set1, "foo");
 253   /* non-existent -- ignored */
 254   remove_element_str (set1, "nonexist1");
 255   add_element_str (set1, "spam");
 256   /* duplicate -- ignored */
 257   remove_element_str (set1, "foo");
 258   add_element_str (set1, "eggs");
 259
 260   check_count (set1,
 261                "initial test",
 262                3,
 263                &test_copy,
 264                NULL);
 265 }
 266
 267
 268 int
 269 main (int argc, char **argv)
 270 {
 271   if (0 != GNUNET_TESTING_peer_run ("test_set_union_copy",
 272                                     "test_set.conf",
 273                                     &run, NULL))
 274   {
 275     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 276                 "failed to start testing peer\n");
 277     return 1;
 278   }
 279   return ret;
 280 }