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