src/util/test_container_meta_data.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2003, 2004, 2006, 2009 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;
  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, EXTRACTOR_TITLE, "TestTitle"))
  44     ABORT (m);
  45   if (GNUNET_OK !=
  46       GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_AUTHOR, "TestTitle"))
  47     ABORT (m);
  48   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_TITLE, "TestTitle")) /* dup! */
  49     ABORT (m);
  50   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_AUTHOR, "TestTitle"))        /* dup! */
  51     ABORT (m);
  52   if (2 != GNUNET_CONTAINER_meta_data_get_contents (m, NULL, NULL))
  53     ABORT (m);
  54   if (GNUNET_OK !=
  55       GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_AUTHOR, "TestTitle"))
  56     ABORT (m);
  57   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_AUTHOR, "TestTitle"))        /* already gone */
  58     ABORT (m);
  59   if (1 != GNUNET_CONTAINER_meta_data_get_contents (m, NULL, NULL))
  60     ABORT (m);
  61   if (GNUNET_OK !=
  62       GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_TITLE, "TestTitle"))
  63     ABORT (m);
  64   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_TITLE, "TestTitle")) /* already gone */
  65     ABORT (m);
  66   if (0 != GNUNET_CONTAINER_meta_data_get_contents (m, NULL, NULL))
  67     ABORT (m);
  68   val = GNUNET_malloc (256);
  69   for (j = 0; j < i; j++)
  70     {
  71       GNUNET_snprintf (val, 256, "%s.%d",
  72                        "A teststring that should compress well.", j);
  73       if (GNUNET_OK !=
  74           GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_UNKNOWN, val))
  75         {
  76           GNUNET_free (val);
  77           ABORT (m);
  78         }
  79     }
  80   GNUNET_free (val);
  81   if (i != GNUNET_CONTAINER_meta_data_get_contents (m, NULL, NULL))
  82     ABORT (m);
  83
  84   size =
  85     GNUNET_CONTAINER_meta_data_get_serialized_size (m,
  86                                                     GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
  87   val = GNUNET_malloc (size);
  88   if (size != GNUNET_CONTAINER_meta_data_serialize (m, val, size,
  89                                                     GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
  90     {
  91       GNUNET_free (val);
  92       ABORT (m);
  93     }
  94   GNUNET_CONTAINER_meta_data_destroy (m);
  95   m = GNUNET_CONTAINER_meta_data_deserialize (val, size);
  96   GNUNET_free (val);
  97   if (m == NULL)
  98     ABORT (m);
  99   val = GNUNET_malloc (256);
 100   for (j = 0; j < i; j++)
 101     {
 102       GNUNET_snprintf (val, 256, "%s.%d",
 103                        "A teststring that should compress well.", j);
 104       if (GNUNET_OK !=
 105           GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_UNKNOWN, val))
 106         {
 107           GNUNET_free (val);
 108           ABORT (m);
 109         }
 110     }
 111   GNUNET_free (val);
 112   if (0 != GNUNET_CONTAINER_meta_data_get_contents (m, NULL, NULL))
 113     {
 114       ABORT (m);
 115     }
 116   GNUNET_CONTAINER_meta_data_destroy (m);
 117   return 0;
 118 }
 119
 120 int
 121 testMetaMore (int i)
 122 {
 123   struct GNUNET_CONTAINER_MetaData *meta;
 124   int q;
 125   char txt[128];
 126   char *data;
 127   unsigned long long size;
 128
 129   meta = GNUNET_CONTAINER_meta_data_create ();
 130   for (q = 0; q <= i; q++)
 131     {
 132       GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
 133       GNUNET_CONTAINER_meta_data_insert (meta,
 134                                          q %
 135                                          EXTRACTOR_getHighestKeywordTypeNumber
 136                                          (), txt);
 137     }
 138   size =
 139     GNUNET_CONTAINER_meta_data_get_serialized_size (meta,
 140                                                     GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
 141   data = GNUNET_malloc (size * 4);
 142   if (size != GNUNET_CONTAINER_meta_data_serialize (meta,
 143                                                     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, EXTRACTOR_UNKNOWN, "link"))
 164     ABORT (m);
 165   if (GNUNET_OK !=
 166       GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_FILENAME,
 167                                          "lib-link.m4"))
 168     ABORT (m);
 169   size =
 170     GNUNET_CONTAINER_meta_data_get_serialized_size (m,
 171                                                     GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
 172   val = GNUNET_malloc (size);
 173   if (size != GNUNET_CONTAINER_meta_data_serialize (m, val, size,
 174                                                     GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
 175     {
 176       GNUNET_free (val);
 177       ABORT (m);
 178     }
 179   GNUNET_CONTAINER_meta_data_destroy (m);
 180   m = GNUNET_CONTAINER_meta_data_deserialize (val, size);
 181   GNUNET_free (val);
 182   if (m == NULL)
 183     ABORT (m);
 184   GNUNET_CONTAINER_meta_data_destroy (m);
 185   return 0;
 186 }
 187
 188
 189 static int
 190 testThumbnail ()
 191 {
 192   struct GNUNET_CONTAINER_MetaData *m;
 193   struct GNUNET_CONTAINER_MetaData *d;
 194   EXTRACTOR_ExtractorList *ex;
 195   unsigned char *thumb;
 196   size_t size;
 197   char *date;
 198
 199   ex = EXTRACTOR_loadConfigLibraries (NULL, "libextractor_thumbnail");
 200   if (ex == NULL)
 201     {
 202       fprintf (stderr,
 203                "Test incomplete, have no thumbnail extractor available.\n");
 204       return 0;                 /* can not test, no thumbnailer */
 205     }
 206   ex = EXTRACTOR_loadConfigLibraries (ex, "libextractor_mime");
 207   m = GNUNET_CONTAINER_meta_data_create ();
 208   if (3 != GNUNET_CONTAINER_meta_data_extract_from_file (m,
 209                                                          "test_container_meta_data_image.jpg",
 210                                                          ex))
 211     {
 212       GNUNET_break (0);
 213       EXTRACTOR_removeAll (ex);
 214       GNUNET_CONTAINER_meta_data_destroy (m);
 215       return 1;
 216     }
 217   EXTRACTOR_removeAll (ex);
 218   d = GNUNET_CONTAINER_meta_data_duplicate (m);
 219   GNUNET_CONTAINER_meta_data_destroy (m);
 220   size = GNUNET_CONTAINER_meta_data_get_thumbnail (d, &thumb);
 221   if (size == 0)
 222     {
 223       GNUNET_break (0);
 224       GNUNET_CONTAINER_meta_data_destroy (d);
 225       return 1;
 226     }
 227   GNUNET_free (thumb);
 228   GNUNET_CONTAINER_meta_data_add_publication_date (d);
 229   date = GNUNET_CONTAINER_meta_data_get_by_type (d,
 230                                                  EXTRACTOR_PUBLICATION_DATE);
 231   if (date == NULL)
 232     {
 233       GNUNET_break (0);
 234       GNUNET_CONTAINER_meta_data_destroy (d);
 235       return 1;
 236     }
 237   GNUNET_free (date);
 238   GNUNET_CONTAINER_meta_data_destroy (d);
 239   return 0;
 240 }
 241
 242
 243 int
 244 main (int argc, char *argv[])
 245 {
 246   int failureCount = 0;
 247   int i;
 248
 249   GNUNET_log_setup ("test-container-meta-data", "WARNING", NULL);
 250   for (i = 0; i < 255; i++)
 251     failureCount += testMeta (i);
 252   for (i = 1; i < 255; i++)
 253     failureCount += testMetaMore (i);
 254   failureCount += testMetaLink ();
 255   failureCount += testThumbnail ();
 256
 257   if (failureCount != 0)
 258     return 1;
 259   return 0;
 260 }
 261
 262 /* end of metatest.c */