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