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