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,
 119                   ci_cls->ongoing_count);
 120       ret = 1;
 121       GNUNET_SCHEDULER_shutdown ();
 122       return GNUNET_NO;
 123     }
 124     ci_cls->cont (ci_cls->cont_cls);
 125     return GNUNET_NO;
 126   }
 127   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 128               "Set `%s' has element %.*s\n",
 129               ci_cls->what,
 130               (int) element->size,
 131               (const char *) element->data);
 132
 133   ci_cls->ongoing_count++;
 134   return GNUNET_YES;
 135 }
 136
 137
 138 static void
 139 check_count (struct GNUNET_SET_Handle *set,
 140              char *what,
 141              unsigned int expected_count,
 142              GNUNET_SCHEDULER_TaskCallback cont,
 143              void *cont_cls)
 144 {
 145   struct CountIterClosure *ci_cls = GNUNET_new (struct CountIterClosure);
 146
 147   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 148               "Checking count of %s\n",
 149               what);
 150
 151   ci_cls->expected_count = expected_count;
 152   ci_cls->ongoing_count = 0;
 153   ci_cls->cont = cont;
 154   ci_cls->cont_cls = cont_cls;
 155   ci_cls->what = what;
 156
 157   GNUNET_assert (GNUNET_YES ==
 158                  GNUNET_SET_iterate (set,
 159                                      &check_count_iter,
 160                                      ci_cls));
 161 }
 162
 163
 164 static void
 165 test_done (void *cls)
 166 {
 167   GNUNET_SCHEDULER_shutdown ();
 168 }
 169
 170
 171 static void
 172 check_new_set_count (void *cls)
 173 {
 174   check_count (set2,
 175                "new set",
 176                3,
 177                &test_done,
 178                NULL);
 179 }
 180
 181
 182 static void
 183 copy_done (void *cls,
 184            struct GNUNET_SET_Handle *new_set)
 185 {
 186   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 187               "copy done\n");
 188   set2 = new_set;
 189   remove_element_str (set2,
 190                       "k5555");
 191   add_element_str (set2,
 192                    "n66666");
 193   add_element_str (set2,
 194                    "new2butremoved");
 195   remove_element_str (set2,
 196                       "new2butremoved");
 197   remove_element_str (set2,
 198                       "new3justremoved");
 199   // Check that set1 didn't change.
 200   check_count (set1,
 201                "old set",
 202                3,
 203                &check_new_set_count,
 204                NULL);
 205 }
 206
 207
 208 static void
 209 test_copy (void *cls)
 210 {
 211   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 212               "about to copy\n");
 213   GNUNET_SET_copy_lazy (set1,
 214                         &copy_done,
 215                         NULL);
 216 }
 217
 218
 219 /**
 220  * Function run on shutdown.
 221  *
 222  * @param cls closure
 223  */
 224 static void
 225 do_shutdown (void *cls)
 226 {
 227   if (NULL != tt)
 228   {
 229     GNUNET_SCHEDULER_cancel (tt);
 230     tt = NULL;
 231   }
 232   if (NULL != set1)
 233   {
 234     GNUNET_SET_destroy (set1);
 235     set1 = NULL;
 236   }
 237   if (NULL != set2)
 238   {
 239     GNUNET_SET_destroy (set2);
 240     set2 = NULL;
 241   }
 242 }
 243
 244
 245 /**
 246  * Signature of the 'main' function for a (single-peer) testcase that
 247  * is run using #GNUNET_TESTING_peer_run().
 248  *
 249  * @param cls closure
 250  * @param cfg configuration of the peer that was started
 251  * @param peer identity of the peer that was created
 252  */
 253 static void
 254 run (void *cls,
 255      const struct GNUNET_CONFIGURATION_Handle *cfg,
 256      struct GNUNET_TESTING_Peer *peer)
 257 {
 258   tt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
 259                                      &timeout_fail,
 260                                      NULL);
 261   GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
 262                                  NULL);
 263   config = cfg;
 264   GNUNET_TESTING_peer_get_identity (peer,
 265                                     &local_id);
 266
 267   set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
 268   add_element_str (set1,
 269                    "333");
 270   add_element_str (set1,
 271                    "k444");
 272   /* duplicate -- ignored */
 273   add_element_str (set1,
 274                    "k444");
 275   remove_element_str (set1,
 276                       "333");
 277   /* non-existent -- ignored */
 278   remove_element_str (set1,
 279                       "999999999");
 280   add_element_str (set1,
 281                    "k5555");
 282   /* duplicate -- ignored */
 283   remove_element_str (set1,
 284                       "333");
 285   add_element_str (set1,
 286                    "k2");
 287
 288   check_count (set1,
 289                "initial test",
 290                3,
 291                &test_copy,
 292                NULL);
 293 }
 294
 295
 296 int
 297 main (int argc, char **argv)
 298 {
 299   if (0 != GNUNET_TESTING_peer_run ("test_set_union_copy",
 300                                     "test_set.conf",
 301                                     &run, NULL))
 302   {
 303     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 304                 "failed to start testing peer\n");
 305     return 1;
 306   }
 307   return ret;
 308 }