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 2, 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
 234 static int
 235 testThumbnail ()
 236 {
 237   struct GNUNET_CONTAINER_MetaData *m;
 238   struct GNUNET_CONTAINER_MetaData *d;
 239   struct EXTRACTOR_PluginList *ex;
 240   unsigned char *thumb;
 241   size_t size;
 242   char *date;
 243
 244   ex = EXTRACTOR_plugin_add_config (NULL, "thumbnailgtk", EXTRACTOR_OPTION_DEFAULT_POLICY);
 245   if (ex == NULL)
 246     {
 247       fprintf (stderr,
 248                "Test incomplete, have no GTK thumbnail extractor available.\n");
 249       return 0;                 /* can not test, no thumbnailer */
 250     }
 251   ex = EXTRACTOR_plugin_add_config (ex, "mime", EXTRACTOR_OPTION_DEFAULT_POLICY);
 252   m = GNUNET_CONTAINER_meta_data_create ();
 253   if (3 != GNUNET_CONTAINER_meta_data_extract_from_file (m,
 254                                                          "test_container_meta_data_image.jpg",
 255                                                          ex))
 256     {
 257       GNUNET_break (0);
 258       EXTRACTOR_plugin_remove_all (ex);
 259       GNUNET_CONTAINER_meta_data_destroy (m);
 260       return 1;
 261     }
 262   EXTRACTOR_plugin_remove_all (ex);
 263   d = GNUNET_CONTAINER_meta_data_duplicate (m);
 264   GNUNET_CONTAINER_meta_data_destroy (m);
 265   thumb = NULL;
 266   size = GNUNET_CONTAINER_meta_data_get_thumbnail (d, &thumb);
 267   if (size == 0)
 268     {
 269       GNUNET_break (0);
 270       GNUNET_CONTAINER_meta_data_destroy (d);
 271       return 1;
 272     }
 273   GNUNET_free (thumb);
 274   GNUNET_CONTAINER_meta_data_add_publication_date (d);
 275   date = GNUNET_CONTAINER_meta_data_get_by_type (d,
 276                                                  EXTRACTOR_METATYPE_PUBLICATION_DATE);
 277   if (date == NULL)
 278     {
 279       GNUNET_break (0);
 280       GNUNET_CONTAINER_meta_data_destroy (d);
 281       return 1;
 282     }
 283   GNUNET_free (date);
 284   GNUNET_CONTAINER_meta_data_destroy (d);
 285   return 0;
 286 }
 287
 288
 289 int
 290 main (int argc, char *argv[])
 291 {
 292   int failureCount = 0;
 293   int i;
 294
 295   GNUNET_log_setup ("test-container-meta-data", "WARNING", NULL);
 296   for (i = 0; i < 255; i++)
 297     failureCount += testMeta (i);
 298   for (i = 1; i < 255; i++)
 299     failureCount += testMetaMore (i);
 300   failureCount += testMetaLink ();
 301   failureCount += testThumbnail ();
 302
 303   if (failureCount != 0)
 304     return 1;
 305   return 0;
 306 }
 307
 308 /* end of test_container_meta_data.c */