src/util/test_container_multipeermap.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 it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20
  21 /**
  22  * @file util/test_container_multipeermap.c
  23  * @brief Test for container_multipeermap.c
  24  * @author Christian Grothoff
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29
  30 #define ABORT() { fprintf (stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
  31                   if (NULL != m) GNUNET_CONTAINER_multipeermap_destroy (m); \
  32                   if (NULL != \
  33                       iter) \
  34                     GNUNET_CONTAINER_multipeermap_iterator_destroy (iter); \
  35                   return 1; }
  36 #define CHECK(c) { if (! (c)) ABORT (); }
  37
  38 static int
  39 testMap (int i)
  40 {
  41   struct GNUNET_CONTAINER_MultiPeerMap *m;
  42   struct GNUNET_PeerIdentity k1;
  43   struct GNUNET_PeerIdentity k2;
  44   struct GNUNET_CONTAINER_MultiPeerMapIterator *iter = NULL;
  45   struct GNUNET_PeerIdentity key_ret;
  46   const char *ret;
  47   int j;
  48
  49   CHECK (NULL != (m = GNUNET_CONTAINER_multipeermap_create (i, GNUNET_NO)));
  50   memset (&k1, 0, sizeof(k1));
  51   memset (&k2, 1, sizeof(k2));
  52   CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (m, &k1));
  53   CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (m, &k2));
  54   CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_remove (m, &k1, NULL));
  55   CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_remove (m, &k2, NULL));
  56   CHECK (NULL == GNUNET_CONTAINER_multipeermap_get (m, &k1));
  57   CHECK (NULL == GNUNET_CONTAINER_multipeermap_get (m, &k2));
  58   CHECK (0 == GNUNET_CONTAINER_multipeermap_remove_all (m, &k1));
  59   CHECK (0 == GNUNET_CONTAINER_multipeermap_size (m));
  60   CHECK (0 == GNUNET_CONTAINER_multipeermap_iterate (m, NULL, NULL));
  61   CHECK (0 == GNUNET_CONTAINER_multipeermap_get_multiple (m, &k1, NULL, NULL));
  62
  63   CHECK (GNUNET_OK ==
  64          GNUNET_CONTAINER_multipeermap_put (m, &k1, "v1",
  65                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
  66   CHECK (1 == GNUNET_CONTAINER_multipeermap_size (m));
  67   ret = GNUNET_CONTAINER_multipeermap_get (m, &k1);
  68   GNUNET_assert (ret != NULL);
  69   CHECK (0 == strcmp ("v1", ret));
  70   CHECK (GNUNET_NO ==
  71          GNUNET_CONTAINER_multipeermap_put (m, &k1, "v1",
  72                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
  73   CHECK (1 == GNUNET_CONTAINER_multipeermap_size (m));
  74   CHECK (GNUNET_OK ==
  75          GNUNET_CONTAINER_multipeermap_put (m, &k1, "v2",
  76                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  77   CHECK (GNUNET_OK ==
  78          GNUNET_CONTAINER_multipeermap_put (m, &k1, "v3",
  79                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  80   CHECK (3 == GNUNET_CONTAINER_multipeermap_size (m));
  81   CHECK (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (m, &k1, "v3"));
  82   CHECK (2 == GNUNET_CONTAINER_multipeermap_size (m));
  83   CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (m, &k1));
  84   CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_contains (m, &k2));
  85   CHECK (2 == GNUNET_CONTAINER_multipeermap_get_multiple (m, &k1, NULL, NULL));
  86   CHECK (0 == GNUNET_CONTAINER_multipeermap_get_multiple (m, &k2, NULL, NULL));
  87   CHECK (2 == GNUNET_CONTAINER_multipeermap_iterate (m, NULL, NULL));
  88   iter = GNUNET_CONTAINER_multipeermap_iterator_create (m);
  89   CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (iter,
  90                                                                     &key_ret,
  91                                                                     (const
  92                                                                      void **) &
  93                                                                     ret));
  94   CHECK (0 == memcmp (&key_ret, &k1, sizeof(key_ret)));
  95   CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (iter,
  96                                                                     &key_ret,
  97                                                                     (const
  98                                                                      void **) &
  99                                                                     ret));
 100   CHECK (0 == memcmp (&key_ret, &k1, sizeof(key_ret)));
 101   CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_iterator_next (iter, NULL,
 102                                                                    NULL));
 103   GNUNET_free (iter);
 104
 105   CHECK (2 == GNUNET_CONTAINER_multipeermap_remove_all (m, &k1));
 106   for (j = 0; j < 1024; j++)
 107     CHECK (GNUNET_OK ==
 108            GNUNET_CONTAINER_multipeermap_put (m, &k1, "v2",
 109                                               GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
 110   iter = GNUNET_CONTAINER_multipeermap_iterator_create (m);
 111   for (j = 0; j < GNUNET_CONTAINER_multipeermap_size (m); j++)
 112     CHECK (GNUNET_YES == GNUNET_CONTAINER_multipeermap_iterator_next (iter,
 113                                                                       NULL,
 114                                                                       NULL));
 115   CHECK (GNUNET_NO == GNUNET_CONTAINER_multipeermap_iterator_next (iter, NULL,
 116                                                                    NULL));
 117   GNUNET_CONTAINER_multipeermap_iterator_destroy (iter);
 118
 119   GNUNET_CONTAINER_multipeermap_destroy (m);
 120   return 0;
 121 }
 122
 123
 124 int
 125 main (int argc, char *argv[])
 126 {
 127   int failureCount = 0;
 128   int i;
 129
 130   GNUNET_log_setup ("test-container-multipeermap", "WARNING", NULL);
 131   for (i = 1; i < 255; i++)
 132     failureCount += testMap (i);
 133   if (failureCount != 0)
 134     return 1;
 135   return 0;
 136 }
 137
 138
 139 /* end of test_container_multipeermap.c */