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