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 ()
  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 ()
 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 ()
 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_directory_r(){
 190         char *msg;
 191         char readResult[200];
 192     const char *fileName = "/dev";
 193     struct GNUNET_BIO_ReadHandle *fileR;
 194     fileR = GNUNET_BIO_read_open (fileName);
 195         GNUNET_assert (NULL != fileR);
 196         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read (fileR, "Read error", readResult, 65537));
 197         GNUNET_BIO_read_close (fileR, &msg);
 198         return 0;
 199 }
 200
 201 static int
 202 test_nullfile_rw ()
 203 {
 204   char *msg;
 205   int64_t testNum;
 206   char *readResultString;
 207   static char fileNameNO[102401];
 208   char readResult[200];
 209   memset (fileNameNO, 'a', sizeof (fileNameNO));
 210   fileNameNO[sizeof (fileNameNO) - 1] = '\0';
 211   const char *fileName = "/dev/full";
 212   const char *fileNameR = "/dev/null";
 213   struct GNUNET_BIO_WriteHandle *fileW, *fileWNO;
 214   struct GNUNET_BIO_ReadHandle *fileR, *fileRNO;
 215   struct GNUNET_CONTAINER_MetaData *metaDataW;
 216   struct GNUNET_CONTAINER_MetaData *metaDataR;
 217   metaDataW = GNUNET_CONTAINER_meta_data_create ();
 218   metaDataR = GNUNET_CONTAINER_meta_data_create ();
 219   GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
 220
 221   fileWNO = GNUNET_BIO_write_open (fileNameNO);
 222   GNUNET_assert (NULL == fileWNO);
 223
 224   fileRNO = GNUNET_BIO_read_open (fileNameNO);
 225   GNUNET_assert (NULL == fileRNO);
 226
 227   fileW = GNUNET_BIO_write_open (fileName);
 228   GNUNET_assert (NULL != fileW);
 229   GNUNET_assert (GNUNET_SYSERR ==
 230                  GNUNET_BIO_write (fileW, TESTSTRING, 65537));
 231   GNUNET_assert (GNUNET_SYSERR ==
 232                  GNUNET_BIO_write_string (fileW, TESTSTRING));
 233   GNUNET_assert (GNUNET_SYSERR ==
 234                  GNUNET_BIO_write_meta_data (fileW, metaDataW));
 235   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 236   fileW = GNUNET_BIO_write_open (fileName);
 237   GNUNET_assert (NULL != fileW);
 238   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 239
 240   fileR = GNUNET_BIO_read_open (fileNameR);
 241   GNUNET_assert (NULL != fileR);
 242   GNUNET_assert (GNUNET_SYSERR ==
 243                  GNUNET_BIO_read (fileR, "Read error", readResult, 65537));
 244   GNUNET_assert (GNUNET_SYSERR ==
 245                  GNUNET_BIO_read_string (fileR, "Read string error",
 246                                          &readResultString, 200));
 247   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
 248   GNUNET_assert (GNUNET_SYSERR ==
 249                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 250                                             &metaDataR));
 251   GNUNET_BIO_read_close (fileR, &msg);
 252   return 0;
 253 }
 254
 255 static int
 256 test_fakestring_rw ()
 257 {
 258   char *msg;
 259   int32_t tmpInt = 2;
 260   char *readResult;
 261   struct GNUNET_BIO_WriteHandle *fileW;
 262   struct GNUNET_BIO_ReadHandle *fileR;
 263   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 264
 265   fileW = GNUNET_BIO_write_open (fileName);
 266   GNUNET_assert (NULL != fileW);
 267   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 268   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 269
 270   fileR = GNUNET_BIO_read_open (fileName);
 271   GNUNET_assert (NULL != fileR);
 272   GNUNET_assert (GNUNET_SYSERR ==
 273                  GNUNET_BIO_read_string (fileR, "Read string error",
 274                                          &readResult, 200));
 275   GNUNET_BIO_read_close (fileR, &msg);
 276   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 277   GNUNET_free (fileName);
 278   return 0;
 279 }
 280
 281 static int
 282 test_fakemeta_rw ()
 283 {
 284   char *msg;
 285   int32_t tmpInt = 2;
 286   struct GNUNET_BIO_WriteHandle *fileW;
 287   struct GNUNET_BIO_ReadHandle *fileR;
 288   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 289   struct GNUNET_CONTAINER_MetaData *metaDataR;
 290   metaDataR = GNUNET_CONTAINER_meta_data_create ();
 291
 292   fileW = GNUNET_BIO_write_open (fileName);
 293   GNUNET_assert (NULL != fileW);
 294   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 295   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 296
 297   fileR = GNUNET_BIO_read_open (fileName);
 298   GNUNET_assert (NULL != fileR);
 299   GNUNET_assert (GNUNET_SYSERR ==
 300                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 301                                             &metaDataR));
 302   GNUNET_BIO_read_close (fileR, &msg);
 303   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 304   GNUNET_free (fileName);
 305   return 0;
 306 }
 307
 308 static int
 309 test_fakebigmeta_rw ()
 310 {
 311   char *msg;
 312   int32_t tmpInt = 1024 * 1024 * 10;
 313   struct GNUNET_BIO_WriteHandle *fileW;
 314   struct GNUNET_BIO_ReadHandle *fileR;
 315   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 316   struct GNUNET_CONTAINER_MetaData *metaDataR;
 317   metaDataR = GNUNET_CONTAINER_meta_data_create ();
 318
 319   fileW = GNUNET_BIO_write_open (fileName);
 320   GNUNET_assert (NULL != fileW);
 321   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 322   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 323
 324   fileR = GNUNET_BIO_read_open (fileName);
 325   GNUNET_assert (NULL != fileR);
 326   GNUNET_assert (GNUNET_SYSERR ==
 327                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 328                                             &metaDataR));
 329   GNUNET_BIO_read_close (fileR, &msg);
 330   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 331   GNUNET_free (fileName);
 332   return 0;
 333 }
 334
 335 static int
 336 check_string_rw ()
 337 {
 338   GNUNET_assert (0 == test_nullstring_rw ());
 339   GNUNET_assert (0 == test_emptystring_rw ());
 340   GNUNET_assert (0 == test_bigstring_rw ());
 341   GNUNET_assert (0 == test_fakestring_rw ());
 342   return 0;
 343 }
 344
 345 static int
 346 check_metadata_rw ()
 347 {
 348   GNUNET_assert (0 == test_fakebigmeta_rw ());
 349   GNUNET_assert (0 == test_fakemeta_rw ());
 350   GNUNET_assert (0 == test_bigmeta_rw ());
 351   return 0;
 352 }
 353
 354 static int
 355 check_file_rw ()
 356 {
 357   GNUNET_assert (0 == test_normal_rw ());
 358   GNUNET_assert (0 == test_nullfile_rw ());
 359   GNUNET_assert (0 == test_directory_r());
 360   return 0;
 361 }
 362
 363 int
 364 main (int argc, char *argv[]){
 365     GNUNET_assert (0 == check_file_rw());
 366     GNUNET_assert (0 == check_metadata_rw());
 367     GNUNET_assert (0 == check_string_rw());
 368     return 0;
 369 }                               /* end of main */