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