src/util/test_container_meta_data.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2003, 2004, 2006, 2009, 2010 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_meta_data.c
  23  * @brief Test for container_meta_data.c
  24  * @author Christian Grothoff
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29
  30 #define ABORT(m) { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_meta_data_destroy(m); return 1; }
  31
  32
  33 static int
  34 testMeta (int i)
  35 {
  36   struct GNUNET_CONTAINER_MetaData *m;
  37   char val[256];
  38   char *sval;
  39   int j;
  40   unsigned int size;
  41
  42   m = GNUNET_CONTAINER_meta_data_create ();
  43   if (GNUNET_OK !=
  44       GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE,
  45                                          EXTRACTOR_METAFORMAT_UTF8,
  46                                          "text/plain", "TestTitle",
  47                                          strlen ("TestTitle") + 1))
  48     ABORT (m);
  49   if (GNUNET_OK !=
  50       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
  51                                          EXTRACTOR_METATYPE_AUTHOR_NAME,
  52                                          EXTRACTOR_METAFORMAT_UTF8,
  53                                          "text/plain", "TestTitle",
  54                                          strlen ("TestTitle") + 1))
  55     ABORT (m);
  56   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen ("TestTitle") + 1))   /* dup! */
  57     ABORT (m);
  58   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_AUTHOR_NAME, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen ("TestTitle") + 1))     /* dup! */
  59     ABORT (m);
  60   if (2 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
  61     ABORT (m);
  62   if (GNUNET_OK !=
  63       GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME,
  64                                          "TestTitle", strlen ("TestTitle") + 1))
  65     ABORT (m);
  66   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME, "TestTitle", strlen ("TestTitle") + 1))        /* already gone */
  67     ABORT (m);
  68   if (1 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
  69     ABORT (m);
  70   if (GNUNET_OK !=
  71       GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE,
  72                                          "TestTitle", strlen ("TestTitle") + 1))
  73     ABORT (m);
  74   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE, "TestTitle", strlen ("TestTitle") + 1))      /* already gone */
  75     ABORT (m);
  76   if (0 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
  77     ABORT (m);
  78   for (j = 0; j < i; j++)
  79   {
  80     GNUNET_snprintf (val, sizeof (val), "%s.%d",
  81                      "A teststring that should compress well.", j);
  82     if (GNUNET_OK !=
  83         GNUNET_CONTAINER_meta_data_insert (m, "<test>",
  84                                            EXTRACTOR_METATYPE_UNKNOWN,
  85                                            EXTRACTOR_METAFORMAT_UTF8,
  86                                            "text/plain", val, strlen (val) + 1))
  87       ABORT (m);
  88   }
  89   if (i != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
  90     ABORT (m);
  91
  92   size = GNUNET_CONTAINER_meta_data_get_serialized_size (m);
  93   sval = NULL;
  94   if (size !=
  95       GNUNET_CONTAINER_meta_data_serialize (m, &sval, size,
  96                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
  97   {
  98     GNUNET_free_non_null (sval);
  99     ABORT (m);
 100   }
 101   GNUNET_CONTAINER_meta_data_destroy (m);
 102   m = GNUNET_CONTAINER_meta_data_deserialize (sval, size);
 103   GNUNET_free (sval);
 104   if (m == NULL)
 105     ABORT (m);
 106   for (j = 0; j < i; j++)
 107   {
 108     GNUNET_snprintf (val,
 109                      sizeof (val),
 110                      "%s.%d",
 111                      "A teststring that should compress well.",
 112                      j);
 113     if (GNUNET_OK !=
 114         GNUNET_CONTAINER_meta_data_delete (m,
 115                                            EXTRACTOR_METATYPE_UNKNOWN,
 116                                            val,
 117                                            strlen (val) + 1))
 118     {
 119       ABORT (m);
 120     }
 121   }
 122   if (0 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
 123     ABORT (m);
 124   GNUNET_CONTAINER_meta_data_destroy (m);
 125   return 0;
 126 }
 127
 128
 129 static int
 130 testMetaMore (int i)
 131 {
 132   struct GNUNET_CONTAINER_MetaData *meta;
 133   int q;
 134   char txt[128];
 135   char *data;
 136   unsigned long long size;
 137
 138   meta = GNUNET_CONTAINER_meta_data_create ();
 139   for (q = 0; q <= i; q++)
 140   {
 141     GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
 142     GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
 143                                        q % 42 /* EXTRACTOR_metatype_get_max () */,
 144                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 145                                        txt, strlen (txt) + 1);
 146   }
 147   size = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
 148   data = GNUNET_malloc (size * 4);
 149   if (size !=
 150       GNUNET_CONTAINER_meta_data_serialize (meta, &data, size * 4,
 151                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
 152   {
 153     GNUNET_free (data);
 154     ABORT (meta);
 155   }
 156   GNUNET_CONTAINER_meta_data_destroy (meta);
 157   GNUNET_free (data);
 158   return 0;
 159 }
 160
 161
 162 static int
 163 testMetaLink ()
 164 {
 165   struct GNUNET_CONTAINER_MetaData *m;
 166   char *val;
 167   unsigned int size;
 168
 169   m = GNUNET_CONTAINER_meta_data_create ();
 170   if (GNUNET_OK !=
 171       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
 172                                          EXTRACTOR_METATYPE_UNKNOWN,
 173                                          EXTRACTOR_METAFORMAT_UTF8,
 174                                          "text/plain", "link",
 175                                          strlen ("link") + 1))
 176     ABORT (m);
 177   if (GNUNET_OK !=
 178       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
 179                                          EXTRACTOR_METATYPE_FILENAME,
 180                                          EXTRACTOR_METAFORMAT_UTF8,
 181                                          "text/plain", "lib-link.m4",
 182                                          strlen ("lib-link.m4") + 1))
 183     ABORT (m);
 184   val = NULL;
 185   size =
 186       GNUNET_CONTAINER_meta_data_serialize (m, &val, (size_t) - 1,
 187                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
 188   GNUNET_CONTAINER_meta_data_destroy (m);
 189   m = GNUNET_CONTAINER_meta_data_deserialize (val, size);
 190   GNUNET_free (val);
 191   if (m == NULL)
 192     ABORT (m);
 193   GNUNET_CONTAINER_meta_data_destroy (m);
 194   return 0;
 195 }
 196
 197
 198 static int
 199 check ()
 200 {
 201   struct GNUNET_CONTAINER_MetaData *meta;
 202   struct GNUNET_CONTAINER_MetaData *meta2;
 203   int q;
 204   int i = 100;
 205   char txt[128];
 206   char *str;
 207   unsigned char *thumb;
 208
 209   meta = GNUNET_CONTAINER_meta_data_create ();
 210   meta2 = GNUNET_CONTAINER_meta_data_create ();
 211   for (q = 0; q <= i; q++)
 212   {
 213     GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
 214     GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
 215                                        EXTRACTOR_METATYPE_UNKNOWN,
 216                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 217                                        "TestTitle", strlen ("TestTitle") + 1);
 218     GNUNET_CONTAINER_meta_data_insert (meta2, "<test>",
 219                                        EXTRACTOR_METATYPE_UNKNOWN,
 220                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 221                                        "TestTitle", strlen ("TestTitle") + 1);
 222   }
 223
 224   //check meta_data_test_equal
 225   if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal (meta, meta2))
 226   {
 227     GNUNET_CONTAINER_meta_data_destroy (meta2);
 228     ABORT (meta);
 229   }
 230
 231   //check meta_data_clear
 232   GNUNET_CONTAINER_meta_data_clear (meta2);
 233   if (0 != GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
 234   {
 235     GNUNET_CONTAINER_meta_data_destroy (meta2);
 236     ABORT (meta);
 237   }
 238   // check equal branch in meta_data_test_equal
 239   if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal (meta, meta))
 240   {
 241     GNUNET_CONTAINER_meta_data_destroy (meta2);
 242     ABORT (meta);
 243   }
 244   // check "count" branch in meta_data_test_equal
 245   if (GNUNET_NO != GNUNET_CONTAINER_meta_data_test_equal (meta, meta2))
 246   {
 247     GNUNET_CONTAINER_meta_data_destroy (meta2);
 248     ABORT (meta);
 249   }
 250
 251   // check meta_data_add_publication_date
 252   GNUNET_CONTAINER_meta_data_add_publication_date (meta2);
 253
 254   // check meta_data_merge
 255   GNUNET_CONTAINER_meta_data_clear (meta2);
 256   GNUNET_CONTAINER_meta_data_merge (meta2, meta);
 257   if (100 == GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
 258   {
 259     GNUNET_CONTAINER_meta_data_destroy (meta2);
 260     ABORT (meta);
 261   }
 262
 263   // check meta_data_get_by_type
 264   GNUNET_CONTAINER_meta_data_clear (meta2);
 265   if (NULL !=
 266       (str =
 267        GNUNET_CONTAINER_meta_data_get_by_type (meta2,
 268                                                EXTRACTOR_METATYPE_UNKNOWN)))
 269   {
 270     GNUNET_CONTAINER_meta_data_destroy (meta2);
 271     GNUNET_free (str);
 272     ABORT (meta);
 273   }
 274
 275   str =
 276       GNUNET_CONTAINER_meta_data_get_by_type (meta, EXTRACTOR_METATYPE_UNKNOWN);
 277   GNUNET_assert (NULL != str);
 278   if (str[0] != 'T')
 279   {
 280     GNUNET_CONTAINER_meta_data_destroy (meta2);
 281     GNUNET_free (str);
 282     ABORT (meta);
 283   }
 284   GNUNET_free (str);
 285
 286   // check branch
 287   if (NULL !=
 288       (str =
 289        GNUNET_CONTAINER_meta_data_get_by_type (meta,
 290                                                EXTRACTOR_METATYPE_PUBLICATION_DATE)))
 291   {
 292     GNUNET_free (str);
 293     GNUNET_CONTAINER_meta_data_destroy (meta2);
 294     ABORT (meta);
 295   }
 296
 297   //check meta_data_get_first_by_types
 298   str =
 299       GNUNET_CONTAINER_meta_data_get_first_by_types (meta,
 300                                                      EXTRACTOR_METATYPE_UNKNOWN,
 301                                                      -1);
 302   GNUNET_assert (NULL != str);
 303   if (str[0] != 'T')
 304   {
 305     GNUNET_CONTAINER_meta_data_destroy (meta2);
 306     GNUNET_free (str);
 307     ABORT (meta);
 308   }
 309   GNUNET_free (str);
 310
 311   //check meta_data_get_thumbnail
 312   if (GNUNET_CONTAINER_meta_data_get_thumbnail (meta, &thumb) != 0)
 313   {
 314     GNUNET_free (thumb);
 315     GNUNET_CONTAINER_meta_data_destroy (meta2);
 316     ABORT (meta);
 317   }
 318   GNUNET_CONTAINER_meta_data_destroy (meta2);
 319   //check meta_data_duplicate
 320   meta2 = GNUNET_CONTAINER_meta_data_duplicate (meta);
 321   if (200 == GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
 322   {
 323     GNUNET_CONTAINER_meta_data_destroy (meta2);
 324     ABORT (meta);
 325   }
 326   GNUNET_CONTAINER_meta_data_destroy (meta2);
 327   GNUNET_CONTAINER_meta_data_destroy (meta);
 328   return 0;
 329 }
 330
 331
 332 int
 333 main (int argc, char *argv[])
 334 {
 335   int failureCount = 0;
 336   int i;
 337
 338   GNUNET_log_setup ("test-container-meta-data", "WARNING", NULL);
 339   for (i = 0; i < 255; i++)
 340     failureCount += testMeta (i);
 341   for (i = 1; i < 255; i++)
 342     failureCount += testMetaMore (i);
 343   failureCount += testMetaLink ();
 344
 345   int ret = check ();
 346
 347   if (ret == 1)
 348     return 1;
 349
 350   if (failureCount != 0)
 351     return 1;
 352   return 0;
 353 }
 354
 355
 356 /* end of test_container_meta_data.c */