src/util/test_container_meta_data.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2003, 2004, 2006, 2009, 2010 Christian Grothoff (and other contributing authors)
   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., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, 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_common.h"
  29 #include "gnunet_container_lib.h"
  30
  31 #define ABORT(m) { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_meta_data_destroy(m); return 1; }
  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, sizeof (val), "%s.%d",
 109                      "A teststring that should compress well.", j);
 110     if (GNUNET_OK !=
 111         GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_UNKNOWN, val,
 112                                            strlen (val) + 1))
 113     {
 114       ABORT (m);
 115     }
 116   }
 117   if (0 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
 118     ABORT (m);
 119   GNUNET_CONTAINER_meta_data_destroy (m);
 120   return 0;
 121 }
 122
 123 int
 124 testMetaMore (int i)
 125 {
 126   struct GNUNET_CONTAINER_MetaData *meta;
 127   int q;
 128   char txt[128];
 129   char *data;
 130   unsigned long long size;
 131
 132   meta = GNUNET_CONTAINER_meta_data_create ();
 133   for (q = 0; q <= i; q++)
 134   {
 135     GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
 136     GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
 137                                        q % EXTRACTOR_metatype_get_max (),
 138                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 139                                        txt, strlen (txt) + 1);
 140   }
 141   size = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
 142   data = GNUNET_malloc (size * 4);
 143   if (size !=
 144       GNUNET_CONTAINER_meta_data_serialize (meta, &data, size * 4,
 145                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
 146   {
 147     GNUNET_free (data);
 148     ABORT (meta);
 149   }
 150   GNUNET_CONTAINER_meta_data_destroy (meta);
 151   GNUNET_free (data);
 152   return 0;
 153 }
 154
 155 static int
 156 testMetaLink ()
 157 {
 158   struct GNUNET_CONTAINER_MetaData *m;
 159   char *val;
 160   unsigned int size;
 161
 162   m = GNUNET_CONTAINER_meta_data_create ();
 163   if (GNUNET_OK !=
 164       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
 165                                          EXTRACTOR_METATYPE_UNKNOWN,
 166                                          EXTRACTOR_METAFORMAT_UTF8,
 167                                          "text/plain", "link",
 168                                          strlen ("link") + 1))
 169     ABORT (m);
 170   if (GNUNET_OK !=
 171       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
 172                                          EXTRACTOR_METATYPE_FILENAME,
 173                                          EXTRACTOR_METAFORMAT_UTF8,
 174                                          "text/plain", "lib-link.m4",
 175                                          strlen ("lib-link.m4") + 1))
 176     ABORT (m);
 177   val = NULL;
 178   size =
 179       GNUNET_CONTAINER_meta_data_serialize (m, &val, (size_t) - 1,
 180                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
 181   GNUNET_CONTAINER_meta_data_destroy (m);
 182   m = GNUNET_CONTAINER_meta_data_deserialize (val, size);
 183   GNUNET_free (val);
 184   if (m == NULL)
 185     ABORT (m);
 186   GNUNET_CONTAINER_meta_data_destroy (m);
 187   return 0;
 188 }
 189
 190 int
 191 check ()
 192 {
 193   struct GNUNET_CONTAINER_MetaData *meta;
 194   struct GNUNET_CONTAINER_MetaData *meta2;
 195   int q;
 196   int i = 100;
 197   char txt[128];
 198   char *str;
 199   unsigned char *thumb;
 200
 201   meta = GNUNET_CONTAINER_meta_data_create ();
 202   meta2 = GNUNET_CONTAINER_meta_data_create ();
 203   for (q = 0; q <= i; q++)
 204   {
 205     GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
 206     GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
 207                                        EXTRACTOR_METATYPE_UNKNOWN,
 208                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 209                                        "TestTitle", strlen ("TestTitle") + 1);
 210     GNUNET_CONTAINER_meta_data_insert (meta2, "<test>",
 211                                        EXTRACTOR_METATYPE_UNKNOWN,
 212                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 213                                        "TestTitle", strlen ("TestTitle") + 1);
 214   }
 215
 216   //check meta_data_test_equal
 217   if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal (meta, meta2))
 218   {
 219     GNUNET_CONTAINER_meta_data_destroy (meta2);
 220     ABORT (meta);
 221   }
 222
 223   //check meta_data_clear
 224   GNUNET_CONTAINER_meta_data_clear (meta2);
 225   if (0 != GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
 226   {
 227     GNUNET_CONTAINER_meta_data_destroy (meta2);
 228     ABORT (meta);
 229   }
 230   // check equal branch in meta_data_test_equal
 231   if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal (meta, meta))
 232   {
 233     GNUNET_CONTAINER_meta_data_destroy (meta2);
 234     ABORT (meta);
 235   }
 236   // check "count" branch in meta_data_test_equal
 237   if (GNUNET_NO != GNUNET_CONTAINER_meta_data_test_equal (meta, meta2))
 238   {
 239     GNUNET_CONTAINER_meta_data_destroy (meta2);
 240     ABORT (meta);
 241   }
 242
 243   // check meta_data_add_publication_date
 244   GNUNET_CONTAINER_meta_data_add_publication_date (meta2);
 245
 246   // check meta_data_merge
 247   GNUNET_CONTAINER_meta_data_clear (meta2);
 248   GNUNET_CONTAINER_meta_data_merge (meta2, meta);
 249   if (100 == GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
 250   {
 251     GNUNET_CONTAINER_meta_data_destroy (meta2);
 252     ABORT (meta);
 253   }
 254
 255   // check meta_data_get_by_type
 256   GNUNET_CONTAINER_meta_data_clear (meta2);
 257   if (NULL !=
 258       (str =
 259        GNUNET_CONTAINER_meta_data_get_by_type (meta2,
 260                                                EXTRACTOR_METATYPE_UNKNOWN)))
 261   {
 262     GNUNET_CONTAINER_meta_data_destroy (meta2);
 263     GNUNET_free (str);
 264     ABORT (meta);
 265   }
 266
 267   str =
 268       GNUNET_CONTAINER_meta_data_get_by_type (meta, EXTRACTOR_METATYPE_UNKNOWN);
 269   GNUNET_assert (NULL != str);
 270   if (str[0] != 'T')
 271   {
 272     GNUNET_CONTAINER_meta_data_destroy (meta2);
 273     GNUNET_free (str);
 274     ABORT (meta);
 275   }
 276   GNUNET_free (str);
 277
 278   // check branch
 279   if (NULL !=
 280       (str =
 281        GNUNET_CONTAINER_meta_data_get_by_type (meta,
 282                                                EXTRACTOR_METATYPE_PUBLICATION_DATE)))
 283   {
 284     GNUNET_free (str);
 285     GNUNET_CONTAINER_meta_data_destroy (meta2);
 286     ABORT (meta);
 287   }
 288
 289   //check meta_data_get_first_by_types
 290   str =
 291       GNUNET_CONTAINER_meta_data_get_first_by_types (meta,
 292                                                      EXTRACTOR_METATYPE_UNKNOWN,
 293                                                      -1);
 294   GNUNET_assert (NULL != str);
 295   if (str[0] != 'T')
 296   {
 297     GNUNET_CONTAINER_meta_data_destroy (meta2);
 298     GNUNET_free (str);
 299     ABORT (meta);
 300   }
 301   GNUNET_free (str);
 302
 303   //check meta_data_get_thumbnail
 304   if (GNUNET_CONTAINER_meta_data_get_thumbnail (meta, &thumb) != 0)
 305   {
 306     GNUNET_free (thumb);
 307     GNUNET_CONTAINER_meta_data_destroy (meta2);
 308     ABORT (meta);
 309   }
 310   GNUNET_CONTAINER_meta_data_destroy (meta2);
 311   //check meta_data_duplicate
 312   meta2 = GNUNET_CONTAINER_meta_data_duplicate (meta);
 313   if (200 == GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
 314   {
 315     GNUNET_CONTAINER_meta_data_destroy (meta2);
 316     ABORT (meta);
 317   }
 318   GNUNET_CONTAINER_meta_data_destroy (meta2);
 319   GNUNET_CONTAINER_meta_data_destroy (meta);
 320   return 0;
 321 }
 322
 323
 324 int
 325 main (int argc, char *argv[])
 326 {
 327   int failureCount = 0;
 328   int i;
 329
 330   GNUNET_log_setup ("test-container-meta-data", "WARNING", NULL);
 331   for (i = 0; i < 255; i++)
 332     failureCount += testMeta (i);
 333   for (i = 1; i < 255; i++)
 334     failureCount += testMetaMore (i);
 335   failureCount += testMetaLink ();
 336
 337   int ret = check ();
 338
 339   if (ret == 1)
 340     return 1;
 341
 342   if (failureCount != 0)
 343     return 1;
 344   return 0;
 345 }
 346
 347 /* end of test_container_meta_data.c */