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