src/util/test_bio.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 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_bio.c
  23  * @brief testcase for the buffered IO module
  24  * @author Ji Lu
  25  */
  26
  27
  28 #include "platform.h"
  29 #include "gnunet_util_lib.h"
  30 #define TESTSTRING "testString"
  31 #define TESTNUMBER64 100000L
  32
  33 static int
  34 test_normal_rw (void)
  35 {
  36   char *msg;
  37   int64_t testNum;
  38   char *readResultString;
  39   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
  40   struct GNUNET_BIO_WriteHandle *fileW;
  41   struct GNUNET_BIO_ReadHandle *fileR;
  42   struct GNUNET_CONTAINER_MetaData *metaDataW;
  43   struct GNUNET_CONTAINER_MetaData *metaDataR;
  44   metaDataW = GNUNET_CONTAINER_meta_data_create ();
  45   metaDataR = GNUNET_CONTAINER_meta_data_create ();
  46   GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
  47
  48   fileW = GNUNET_BIO_write_open (fileName);
  49   GNUNET_assert (NULL != fileW);
  50   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
  51   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
  52   GNUNET_assert (GNUNET_OK ==
  53                  GNUNET_BIO_write_int64 (fileW, (int64_t) TESTNUMBER64));
  54   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
  55
  56   fileR = GNUNET_BIO_read_open (fileName);
  57   GNUNET_assert (NULL != fileR);
  58   GNUNET_assert (GNUNET_OK ==
  59                  GNUNET_BIO_read_string (fileR, "Read string error",
  60                                          &readResultString, 200));
  61   GNUNET_assert (GNUNET_OK ==
  62                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
  63                                             &metaDataR));
  64   GNUNET_assert (GNUNET_YES ==
  65                  GNUNET_CONTAINER_meta_data_test_equal (metaDataR,
  66                                                         metaDataW));
  67   GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
  68   GNUNET_BIO_read_close (fileR, &msg);
  69   GNUNET_CONTAINER_meta_data_destroy (metaDataW);
  70   GNUNET_CONTAINER_meta_data_destroy (metaDataR);
  71   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
  72   GNUNET_free (fileName);
  73   return 0;
  74 }
  75
  76 static int
  77 test_nullstring_rw ()
  78 {
  79   char *msg;
  80   char *readResultString = (char *) "not null";
  81   struct GNUNET_BIO_WriteHandle *fileW;
  82   struct GNUNET_BIO_ReadHandle *fileR;
  83   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
  84
  85   fileW = GNUNET_BIO_write_open (fileName);
  86   GNUNET_assert (NULL != fileW);
  87   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
  88   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
  89
  90   fileR = GNUNET_BIO_read_open (fileName);
  91   GNUNET_assert (NULL != fileR);
  92   GNUNET_assert (GNUNET_OK ==
  93                  GNUNET_BIO_read_string (fileR, "Read string error",
  94                                          &readResultString, 200));
  95   GNUNET_assert (NULL == readResultString);
  96   GNUNET_BIO_read_close (fileR, &msg);
  97   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
  98   GNUNET_free (fileName);
  99
 100   return 0;
 101 }
 102
 103 static int
 104 test_emptystring_rw (void)
 105 {
 106   char *msg;
 107   char *readResultString;
 108   struct GNUNET_BIO_WriteHandle *fileW;
 109   struct GNUNET_BIO_ReadHandle *fileR;
 110   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 111
 112   fileW = GNUNET_BIO_write_open (fileName);
 113   GNUNET_assert (NULL != fileW);
 114   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
 115   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 116
 117   fileR = GNUNET_BIO_read_open (fileName);
 118   GNUNET_assert (NULL != fileR);
 119   GNUNET_assert (GNUNET_OK ==
 120                  GNUNET_BIO_read_string (fileR, "Read string error",
 121                                          &readResultString, 200));
 122   GNUNET_BIO_read_close (fileR, &msg);
 123   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 124   GNUNET_free (fileName);
 125   return 0;
 126 }
 127
 128 static int
 129 test_bigstring_rw (void)
 130 {
 131   char *msg;
 132   char *readResultString;
 133   struct GNUNET_BIO_WriteHandle *fileW;
 134   struct GNUNET_BIO_ReadHandle *fileR;
 135   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 136
 137   fileW = GNUNET_BIO_write_open (fileName);
 138   GNUNET_assert (NULL != fileW);
 139   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
 140   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 141
 142   fileR = GNUNET_BIO_read_open (fileName);
 143   GNUNET_assert (NULL != fileR);
 144   GNUNET_assert (GNUNET_SYSERR ==
 145                  GNUNET_BIO_read_string (fileR, "Read string error",
 146                                          &readResultString, 1));
 147   GNUNET_BIO_read_close (fileR, &msg);
 148   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 149   GNUNET_free (fileName);
 150   return 0;
 151 }
 152
 153 static int
 154 test_bigmeta_rw ()
 155 {
 156   char *msg;
 157   static char meta[1024 * 1024 * 10];
 158   memset (meta, 'b', sizeof (meta));
 159   meta[sizeof (meta) - 1] = '\0';
 160   struct GNUNET_BIO_WriteHandle *fileW;
 161   struct GNUNET_BIO_ReadHandle *fileR;
 162   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 163   struct GNUNET_CONTAINER_MetaData *metaDataW;
 164   struct GNUNET_CONTAINER_MetaData *metaDataR;
 165   metaDataW = GNUNET_CONTAINER_meta_data_create ();
 166   metaDataR = GNUNET_CONTAINER_meta_data_create ();
 167   GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
 168   GNUNET_assert (GNUNET_OK ==
 169                  GNUNET_CONTAINER_meta_data_insert (metaDataW,
 170                                                     EXTRACTOR_COMMENT, meta));
 171
 172   fileW = GNUNET_BIO_write_open (fileName);
 173   GNUNET_assert (NULL != fileW);
 174   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
 175   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 176
 177   fileR = GNUNET_BIO_read_open (fileName);
 178   GNUNET_assert (NULL != fileR);
 179   GNUNET_assert (GNUNET_SYSERR ==
 180                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 181                                             &metaDataR));
 182   GNUNET_BIO_read_close (fileR, &msg);
 183   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 184   GNUNET_free (fileName);
 185   return 0;
 186 }
 187
 188 static int
 189 test_nullfile_rw (void)
 190 {
 191   char *msg;
 192   int64_t testNum;
 193   char *readResultString;
 194   static char fileNameNO[102401];
 195   char readResult[200];
 196   memset (fileNameNO, 'a', sizeof (fileNameNO));
 197   fileNameNO[sizeof (fileNameNO) - 1] = '\0';
 198   const char *fileName = "/dev/full";
 199   const char *fileNameR = "/dev/null";
 200   struct GNUNET_BIO_WriteHandle *fileW, *fileWNO;
 201   struct GNUNET_BIO_ReadHandle *fileR, *fileRNO;
 202   struct GNUNET_CONTAINER_MetaData *metaDataW;
 203   struct GNUNET_CONTAINER_MetaData *metaDataR;
 204   metaDataW = GNUNET_CONTAINER_meta_data_create ();
 205   metaDataR = GNUNET_CONTAINER_meta_data_create ();
 206   GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
 207
 208   fileWNO = GNUNET_BIO_write_open (fileNameNO);
 209   GNUNET_assert (NULL == fileWNO);
 210
 211   fileRNO = GNUNET_BIO_read_open (fileNameNO);
 212   GNUNET_assert (NULL == fileRNO);
 213
 214   fileW = GNUNET_BIO_write_open (fileName);
 215   GNUNET_assert (NULL != fileW);
 216   GNUNET_assert (GNUNET_SYSERR ==
 217                  GNUNET_BIO_write (fileW, TESTSTRING, 65537));
 218   GNUNET_assert (GNUNET_SYSERR ==
 219                  GNUNET_BIO_write_string (fileW, TESTSTRING));
 220   GNUNET_assert (GNUNET_SYSERR ==
 221                  GNUNET_BIO_write_meta_data (fileW, metaDataW));
 222   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 223   fileW = GNUNET_BIO_write_open (fileName);
 224   GNUNET_assert (NULL != fileW);
 225   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 226
 227   fileR = GNUNET_BIO_read_open (fileNameR);
 228   GNUNET_assert (NULL != fileR);
 229   GNUNET_assert (GNUNET_SYSERR ==
 230                  GNUNET_BIO_read (fileR, "Read error", readResult, 65537));
 231   GNUNET_assert (GNUNET_SYSERR ==
 232                  GNUNET_BIO_read_string (fileR, "Read string error",
 233                                          &readResultString, 200));
 234   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
 235   GNUNET_assert (GNUNET_SYSERR ==
 236                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 237                                             &metaDataR));
 238   GNUNET_BIO_read_close (fileR, &msg);
 239   return 0;
 240 }
 241
 242 static int
 243 test_fakestring_rw (void)
 244 {
 245   char *msg;
 246   int32_t tmpInt = 2;
 247   char *readResult;
 248   struct GNUNET_BIO_WriteHandle *fileW;
 249   struct GNUNET_BIO_ReadHandle *fileR;
 250   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 251
 252   fileW = GNUNET_BIO_write_open (fileName);
 253   GNUNET_assert (NULL != fileW);
 254   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 255   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 256
 257   fileR = GNUNET_BIO_read_open (fileName);
 258   GNUNET_assert (NULL != fileR);
 259   GNUNET_assert (GNUNET_SYSERR ==
 260                  GNUNET_BIO_read_string (fileR, "Read string error",
 261                                          &readResult, 200));
 262   GNUNET_BIO_read_close (fileR, &msg);
 263   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 264   GNUNET_free (fileName);
 265   return 0;
 266 }
 267
 268 static int
 269 test_fakemeta_rw (void)
 270 {
 271   char *msg;
 272   int32_t tmpInt = 2;
 273   struct GNUNET_BIO_WriteHandle *fileW;
 274   struct GNUNET_BIO_ReadHandle *fileR;
 275   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 276   struct GNUNET_CONTAINER_MetaData *metaDataR;
 277   metaDataR = GNUNET_CONTAINER_meta_data_create ();
 278
 279   fileW = GNUNET_BIO_write_open (fileName);
 280   GNUNET_assert (NULL != fileW);
 281   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 282   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 283
 284   fileR = GNUNET_BIO_read_open (fileName);
 285   GNUNET_assert (NULL != fileR);
 286   GNUNET_assert (GNUNET_SYSERR ==
 287                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 288                                             &metaDataR));
 289   GNUNET_BIO_read_close (fileR, &msg);
 290   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 291   GNUNET_free (fileName);
 292   return 0;
 293 }
 294
 295 static int
 296 test_fakebigmeta_rw (void)
 297 {
 298   char *msg;
 299   int32_t tmpInt = 1024 * 1024 * 10;
 300   struct GNUNET_BIO_WriteHandle *fileW;
 301   struct GNUNET_BIO_ReadHandle *fileR;
 302   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 303   struct GNUNET_CONTAINER_MetaData *metaDataR;
 304   metaDataR = GNUNET_CONTAINER_meta_data_create ();
 305
 306   fileW = GNUNET_BIO_write_open (fileName);
 307   GNUNET_assert (NULL != fileW);
 308   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 309   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 310
 311   fileR = GNUNET_BIO_read_open (fileName);
 312   GNUNET_assert (NULL != fileR);
 313   GNUNET_assert (GNUNET_SYSERR ==
 314                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 315                                             &metaDataR));
 316   GNUNET_BIO_read_close (fileR, &msg);
 317   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 318   GNUNET_free (fileName);
 319   return 0;
 320 }
 321
 322 static int
 323 check_string_rw (void)
 324 {
 325   GNUNET_assert (0 == test_nullstring_rw ());
 326   GNUNET_assert (0 == test_emptystring_rw ());
 327   GNUNET_assert (0 == test_bigstring_rw ());
 328   GNUNET_assert (0 == test_fakestring_rw ());
 329   return 0;
 330 }
 331
 332 static int
 333 check_metadata_rw (void)
 334 {
 335   GNUNET_assert (0 == test_fakebigmeta_rw ());
 336   GNUNET_assert (0 == test_fakemeta_rw ());
 337   GNUNET_assert (0 == test_bigmeta_rw ());
 338   return 0;
 339 }
 340
 341 static int
 342 check_file_rw (void)
 343 {
 344   GNUNET_assert (0 == test_normal_rw ());
 345   GNUNET_assert (0 == test_nullfile_rw ());
 346   return 0;
 347 }
 348
 349 int
 350 main (int argc, char *argv[])
 351 {
 352   GNUNET_assert (0 == check_file_rw ());
 353   GNUNET_assert (0 == check_metadata_rw ());
 354   GNUNET_assert (0 == check_string_rw ());
 355   return 0;
 356 }                               /* end of main */