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
  19 /**
  20  * @file util/test_container_meta_data.c
  21  * @brief Test for container_meta_data.c
  22  * @author Christian Grothoff
  23  */
  24
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27
  28 #define ABORT(m) { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_meta_data_destroy(m); return 1; }
  29
  30
  31 static int
  32 testMeta (int i)
  33 {
  34   struct GNUNET_CONTAINER_MetaData *m;
  35   char val[256];
  36   char *sval;
  37   int j;
  38   unsigned int size;
  39
  40   m = GNUNET_CONTAINER_meta_data_create ();
  41   if (GNUNET_OK !=
  42       GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE,
  43                                          EXTRACTOR_METAFORMAT_UTF8,
  44                                          "text/plain", "TestTitle",
  45                                          strlen ("TestTitle") + 1))
  46     ABORT (m);
  47   if (GNUNET_OK !=
  48       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
  49                                          EXTRACTOR_METATYPE_AUTHOR_NAME,
  50                                          EXTRACTOR_METAFORMAT_UTF8,
  51                                          "text/plain", "TestTitle",
  52                                          strlen ("TestTitle") + 1))
  53     ABORT (m);
  54   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen ("TestTitle") + 1))   /* dup! */
  55     ABORT (m);
  56   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_AUTHOR_NAME, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen ("TestTitle") + 1))     /* dup! */
  57     ABORT (m);
  58   if (2 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
  59     ABORT (m);
  60   if (GNUNET_OK !=
  61       GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME,
  62                                          "TestTitle", strlen ("TestTitle") + 1))
  63     ABORT (m);
  64   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME, "TestTitle", strlen ("TestTitle") + 1))        /* already gone */
  65     ABORT (m);
  66   if (1 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
  67     ABORT (m);
  68   if (GNUNET_OK !=
  69       GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE,
  70                                          "TestTitle", strlen ("TestTitle") + 1))
  71     ABORT (m);
  72   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE, "TestTitle", strlen ("TestTitle") + 1))      /* already gone */
  73     ABORT (m);
  74   if (0 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
  75     ABORT (m);
  76   for (j = 0; j < i; j++)
  77   {
  78     GNUNET_snprintf (val, sizeof (val), "%s.%d",
  79                      "A teststring that should compress well.", j);
  80     if (GNUNET_OK !=
  81         GNUNET_CONTAINER_meta_data_insert (m, "<test>",
  82                                            EXTRACTOR_METATYPE_UNKNOWN,
  83                                            EXTRACTOR_METAFORMAT_UTF8,
  84                                            "text/plain", val, strlen (val) + 1))
  85       ABORT (m);
  86   }
  87   if (i != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
  88     ABORT (m);
  89
  90   size = GNUNET_CONTAINER_meta_data_get_serialized_size (m);
  91   sval = NULL;
  92   if (size !=
  93       GNUNET_CONTAINER_meta_data_serialize (m, &sval, size,
  94                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
  95   {
  96     GNUNET_free_non_null (sval);
  97     ABORT (m);
  98   }
  99   GNUNET_CONTAINER_meta_data_destroy (m);
 100   m = GNUNET_CONTAINER_meta_data_deserialize (sval, size);
 101   GNUNET_free (sval);
 102   if (m == NULL)
 103     ABORT (m);
 104   for (j = 0; j < i; j++)
 105   {
 106     GNUNET_snprintf (val,
 107                      sizeof (val),
 108                      "%s.%d",
 109                      "A teststring that should compress well.",
 110                      j);
 111     if (GNUNET_OK !=
 112         GNUNET_CONTAINER_meta_data_delete (m,
 113                                            EXTRACTOR_METATYPE_UNKNOWN,
 114                                            val,
 115                                            strlen (val) + 1))
 116     {
 117       ABORT (m);
 118     }
 119   }
 120   if (0 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
 121     ABORT (m);
 122   GNUNET_CONTAINER_meta_data_destroy (m);
 123   return 0;
 124 }
 125
 126
 127 static 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 % 42 /* EXTRACTOR_metatype_get_max () */,
 142                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 143                                        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
 160 static int
 161 testMetaLink ()
 162 {
 163   struct GNUNET_CONTAINER_MetaData *m;
 164   char *val;
 165   unsigned int size;
 166
 167   m = GNUNET_CONTAINER_meta_data_create ();
 168   if (GNUNET_OK !=
 169       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
 170                                          EXTRACTOR_METATYPE_UNKNOWN,
 171                                          EXTRACTOR_METAFORMAT_UTF8,
 172                                          "text/plain", "link",
 173                                          strlen ("link") + 1))
 174     ABORT (m);
 175   if (GNUNET_OK !=
 176       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
 177                                          EXTRACTOR_METATYPE_FILENAME,
 178                                          EXTRACTOR_METAFORMAT_UTF8,
 179                                          "text/plain", "lib-link.m4",
 180                                          strlen ("lib-link.m4") + 1))
 181     ABORT (m);
 182   val = NULL;
 183   size =
 184       GNUNET_CONTAINER_meta_data_serialize (m, &val, (size_t) - 1,
 185                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
 186   GNUNET_CONTAINER_meta_data_destroy (m);
 187   m = GNUNET_CONTAINER_meta_data_deserialize (val, size);
 188   GNUNET_free (val);
 189   if (m == NULL)
 190     ABORT (m);
 191   GNUNET_CONTAINER_meta_data_destroy (m);
 192   return 0;
 193 }
 194
 195
 196 static int
 197 check ()
 198 {
 199   struct GNUNET_CONTAINER_MetaData *meta;
 200   struct GNUNET_CONTAINER_MetaData *meta2;
 201   int q;
 202   int i = 100;
 203   char txt[128];
 204   char *str;
 205   unsigned char *thumb;
 206
 207   meta = GNUNET_CONTAINER_meta_data_create ();
 208   meta2 = GNUNET_CONTAINER_meta_data_create ();
 209   for (q = 0; q <= i; q++)
 210   {
 211     GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
 212     GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
 213                                        EXTRACTOR_METATYPE_UNKNOWN,
 214                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 215                                        "TestTitle", strlen ("TestTitle") + 1);
 216     GNUNET_CONTAINER_meta_data_insert (meta2, "<test>",
 217                                        EXTRACTOR_METATYPE_UNKNOWN,
 218                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
 219                                        "TestTitle", 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
 354 /* end of test_container_meta_data.c */