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
 242   meta = GNUNET_CONTAINER_meta_data_create ();
 243   meta2 = GNUNET_CONTAINER_meta_data_create ();
 244   for (q = 0; q <= i; q++)
 245     {
 246       GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
 247       GNUNET_CONTAINER_meta_data_insert (meta,
 248                                          "<test>",
 249                                          EXTRACTOR_METATYPE_UNKNOWN,
 250                                          EXTRACTOR_METAFORMAT_UTF8,
 251                                          "text/plain",
 252                                          "TestTitle",
 253                                          strlen ("TestTitle")+1);
 254       GNUNET_CONTAINER_meta_data_insert (meta2,
 255                                          "<test>",
 256                                          EXTRACTOR_METATYPE_UNKNOWN,
 257                                          EXTRACTOR_METAFORMAT_UTF8,
 258                                          "text/plain",
 259                                          "TestTitle",
 260                                          strlen ("TestTitle")+1);
 261     }
 262
 263   //check meta_data_test_equal
 264   if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal(meta,meta2))
 265     {
 266       GNUNET_CONTAINER_meta_data_destroy(meta2);
 267       ABORT(meta);
 268     }
 269
 270   //check meta_data_clear
 271   GNUNET_CONTAINER_meta_data_clear(meta2);
 272   if (0 != GNUNET_CONTAINER_meta_data_iterate(meta2,NULL,NULL))
 273     {
 274       GNUNET_CONTAINER_meta_data_destroy(meta2);
 275       ABORT(meta);
 276     }
 277   //check equal branch in meta_data_test_equal
 278   if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal(meta,meta))
 279     {
 280       GNUNET_CONTAINER_meta_data_destroy(meta2);
 281       ABORT(meta);
 282     }
 283   //check "count" branch in meta_data_test_equal
 284   if (GNUNET_NO != GNUNET_CONTAINER_meta_data_test_equal(meta,meta2))
 285     {
 286       GNUNET_CONTAINER_meta_data_destroy(meta2);
 287       ABORT(meta);
 288     }
 289
 290   //check meta_data_add_publication_date
 291   GNUNET_CONTAINER_meta_data_add_publication_date(meta2);
 292
 293   //check meta_data_merge
 294   GNUNET_CONTAINER_meta_data_clear(meta2);
 295   GNUNET_CONTAINER_meta_data_merge(meta2,meta);
 296   if (100 == GNUNET_CONTAINER_meta_data_iterate(meta2,NULL,NULL))
 297     {
 298       GNUNET_CONTAINER_meta_data_destroy(meta2);
 299       ABORT(meta);
 300     }
 301
 302   //check meta_data_get_by_type
 303   GNUNET_CONTAINER_meta_data_clear(meta2);
 304   if (GNUNET_CONTAINER_meta_data_get_by_type(meta2,EXTRACTOR_METATYPE_UNKNOWN) != NULL)
 305     {
 306       GNUNET_CONTAINER_meta_data_destroy(meta2);
 307       ABORT(meta);
 308     }
 309
 310   char* str = GNUNET_CONTAINER_meta_data_get_by_type(meta,EXTRACTOR_METATYPE_UNKNOWN);
 311   if (str[0] != 'T')
 312     {
 313       GNUNET_CONTAINER_meta_data_destroy(meta2);
 314       ABORT(meta);
 315     }
 316   //check branch
 317   if (GNUNET_CONTAINER_meta_data_get_by_type(meta,EXTRACTOR_METATYPE_PUBLICATION_DATE) != NULL)
 318     {
 319       GNUNET_CONTAINER_meta_data_destroy(meta2);
 320       ABORT(meta);
 321     }
 322
 323   //check meta_data_get_first_by_types
 324   str = GNUNET_CONTAINER_meta_data_get_first_by_types(meta,
 325                                                       EXTRACTOR_METATYPE_UNKNOWN,
 326                                                       -1);
 327   if (str[0] != 'T')
 328     {
 329       GNUNET_CONTAINER_meta_data_destroy(meta2);
 330       ABORT(meta);
 331     }
 332
 333   //check meta_data_get_thumbnail
 334   unsigned char* thumb;
 335
 336   if (GNUNET_CONTAINER_meta_data_get_thumbnail(meta, &thumb) != 0)
 337     {
 338       GNUNET_CONTAINER_meta_data_destroy(meta2);
 339       ABORT(meta);
 340     }
 341
 342   //check meta_data_duplicate
 343   GNUNET_CONTAINER_meta_data_duplicate(meta);
 344   if (200 == GNUNET_CONTAINER_meta_data_iterate(meta,NULL,NULL))
 345     {
 346       GNUNET_CONTAINER_meta_data_destroy(meta2);
 347       ABORT(meta);
 348     }
 349   return 0;
 350 }
 351
 352
 353 int
 354 main (int argc, char *argv[])
 355 {
 356   int failureCount = 0;
 357   int i;
 358
 359   GNUNET_log_setup ("test-container-meta-data", "WARNING", NULL);
 360   for (i = 0; i < 255; i++)
 361     failureCount += testMeta (i);
 362   for (i = 1; i < 255; i++)
 363     failureCount += testMetaMore (i);
 364   failureCount += testMetaLink ();
 365
 366   int ret = check();
 367   if ( ret == 1)
 368     return 1;
 369
 370   if (failureCount != 0)
 371     return 1;
 372   return 0;
 373 }
 374
 375 /* end of test_container_meta_data.c */