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