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 ((int64_t)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 = NULL;
  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, 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   readResultString = NULL;
  59   GNUNET_assert (GNUNET_OK ==
  60                  GNUNET_BIO_read_string (fileR, "Read string error",
  61                                          &readResultString, 200));
  62   GNUNET_assert (0 == strcmp (TESTSTRING, readResultString));
  63   GNUNET_free (readResultString);
  64   GNUNET_assert (GNUNET_OK ==
  65                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
  66                                             &metaDataR));
  67   GNUNET_assert (GNUNET_YES ==
  68                  GNUNET_CONTAINER_meta_data_test_equal (metaDataR,
  69                                                         metaDataW));
  70   GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
  71   GNUNET_BIO_read_close (fileR, &msg);
  72   GNUNET_CONTAINER_meta_data_destroy (metaDataW);
  73   GNUNET_CONTAINER_meta_data_destroy (metaDataR);
  74   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
  75   GNUNET_free (fileName);
  76   return 0;
  77 }
  78
  79 static int
  80 test_nullstring_rw ()
  81 {
  82   char *msg;
  83   char *readResultString = (char *) "not null";
  84   struct GNUNET_BIO_WriteHandle *fileW;
  85   struct GNUNET_BIO_ReadHandle *fileR;
  86   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
  87
  88   fileW = GNUNET_BIO_write_open (fileName);
  89   GNUNET_assert (NULL != fileW);
  90   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
  91   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
  92
  93   fileR = GNUNET_BIO_read_open (fileName);
  94   GNUNET_assert (NULL != fileR);
  95   GNUNET_assert (GNUNET_OK ==
  96                  GNUNET_BIO_read_string (fileR, "Read string error",
  97                                          &readResultString, 200));
  98   GNUNET_assert (NULL == readResultString);
  99   GNUNET_BIO_read_close (fileR, &msg);
 100   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 101   GNUNET_free (fileName);
 102
 103   return 0;
 104 }
 105
 106 static int
 107 test_emptystring_rw ()
 108 {
 109   char *msg;
 110   char *readResultString;
 111   struct GNUNET_BIO_WriteHandle *fileW;
 112   struct GNUNET_BIO_ReadHandle *fileR;
 113   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 114
 115   fileW = GNUNET_BIO_write_open (fileName);
 116   GNUNET_assert (NULL != fileW);
 117   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
 118   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 119
 120   fileR = GNUNET_BIO_read_open (fileName);
 121   GNUNET_assert (NULL != fileR);
 122   readResultString = NULL;
 123   GNUNET_assert (GNUNET_OK ==
 124                  GNUNET_BIO_read_string (fileR, "Read string error",
 125                                          &readResultString, 200));
 126   GNUNET_free (readResultString);
 127   GNUNET_BIO_read_close (fileR, &msg);
 128   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 129   GNUNET_free (fileName);
 130   return 0;
 131 }
 132
 133 static int
 134 test_bigstring_rw ()
 135 {
 136   char *msg;
 137   char *readResultString;
 138   struct GNUNET_BIO_WriteHandle *fileW;
 139   struct GNUNET_BIO_ReadHandle *fileR;
 140   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 141
 142   fileW = GNUNET_BIO_write_open (fileName);
 143   GNUNET_assert (NULL != fileW);
 144   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
 145   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 146
 147   fileR = GNUNET_BIO_read_open (fileName);
 148   GNUNET_assert (NULL != fileR);
 149   readResultString = NULL;
 150   GNUNET_assert (GNUNET_SYSERR ==
 151                  GNUNET_BIO_read_string (fileR, "Read string error",
 152                                          &readResultString, 1));
 153   GNUNET_assert (NULL == readResultString);
 154   msg = NULL;
 155   GNUNET_BIO_read_close (fileR, &msg);
 156   GNUNET_free (msg);
 157   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 158   GNUNET_free (fileName);
 159   return 0;
 160 }
 161
 162 static int
 163 test_bigmeta_rw ()
 164 {
 165   char *msg;
 166   static char meta[1024 * 1024 * 10];
 167   memset (meta, 'b', sizeof (meta));
 168   meta[sizeof (meta) - 1] = '\0';
 169   struct GNUNET_BIO_WriteHandle *fileW;
 170   struct GNUNET_BIO_ReadHandle *fileR;
 171   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 172   struct GNUNET_CONTAINER_MetaData *metaDataW;
 173   struct GNUNET_CONTAINER_MetaData *metaDataR;
 174   metaDataW = GNUNET_CONTAINER_meta_data_create ();
 175   GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
 176   GNUNET_assert (GNUNET_OK ==
 177                  GNUNET_CONTAINER_meta_data_insert (metaDataW,
 178                                                     EXTRACTOR_COMMENT, meta));
 179
 180   fileW = GNUNET_BIO_write_open (fileName);
 181   GNUNET_assert (NULL != fileW);
 182   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
 183   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 184
 185   fileR = GNUNET_BIO_read_open (fileName);
 186   GNUNET_assert (NULL != fileR);
 187   metaDataR = NULL;
 188   GNUNET_assert (GNUNET_SYSERR ==
 189                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 190                                             &metaDataR));
 191   msg = NULL;
 192   GNUNET_BIO_read_close (fileR, &msg);
 193   GNUNET_free (msg);
 194   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 195   GNUNET_assert (NULL == metaDataR);
 196   GNUNET_CONTAINER_meta_data_destroy (metaDataW);
 197   GNUNET_free (fileName);
 198   return 0;
 199 }
 200
 201 static int
 202 test_directory_r(){
 203   char *msg;
 204   char readResult[200];
 205   struct GNUNET_BIO_ReadHandle *fileR;
 206
 207   fileR = GNUNET_BIO_read_open ("/dev");
 208   GNUNET_assert (NULL != fileR);
 209   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read (fileR, "Read error", readResult, 65537));
 210   msg = NULL;
 211   GNUNET_BIO_read_close (fileR, &msg);
 212   GNUNET_free (msg);
 213   return 0;
 214 }
 215
 216 static int
 217 test_nullfile_rw ()
 218 {
 219   char *msg;
 220   int64_t testNum;
 221   char *readResultString;
 222   static char fileNameNO[102401];
 223   char readResult[200];
 224   memset (fileNameNO, 'a', sizeof (fileNameNO));
 225   fileNameNO[sizeof (fileNameNO) - 1] = '\0';
 226   struct GNUNET_BIO_WriteHandle *fileW, *fileWNO;
 227   struct GNUNET_BIO_ReadHandle *fileR, *fileRNO;
 228   struct GNUNET_CONTAINER_MetaData *metaDataW;
 229   struct GNUNET_CONTAINER_MetaData *metaDataR;
 230   metaDataW = GNUNET_CONTAINER_meta_data_create ();
 231   metaDataR = GNUNET_CONTAINER_meta_data_create ();
 232   GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
 233
 234   fileWNO = GNUNET_BIO_write_open (fileNameNO);
 235   GNUNET_assert (NULL == fileWNO);
 236
 237   fileRNO = GNUNET_BIO_read_open (fileNameNO);
 238   GNUNET_assert (NULL == fileRNO);
 239
 240   fileW = GNUNET_BIO_write_open ("/dev/full");
 241   GNUNET_assert (NULL != fileW);
 242   GNUNET_assert (GNUNET_SYSERR ==
 243                  GNUNET_BIO_write (fileW, fileNameNO, sizeof(fileNameNO)));
 244   GNUNET_assert (GNUNET_SYSERR ==
 245                  GNUNET_BIO_write_string (fileW, TESTSTRING));
 246   GNUNET_assert (GNUNET_SYSERR ==
 247                  GNUNET_BIO_write_meta_data (fileW, metaDataW));
 248   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 249
 250   fileW = GNUNET_BIO_write_open ("/dev/full");
 251   GNUNET_assert (NULL != fileW);
 252   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 253
 254   fileR = GNUNET_BIO_read_open ("/dev/null");
 255   GNUNET_assert (NULL != fileR);
 256   GNUNET_assert (GNUNET_SYSERR ==
 257                  GNUNET_BIO_read (fileR, "Read error", readResult, 65537));
 258   readResultString = NULL;
 259   GNUNET_assert (GNUNET_SYSERR ==
 260                  GNUNET_BIO_read_string (fileR, "Read string error",
 261                                          &readResultString, 200));
 262   GNUNET_assert (NULL == readResultString);
 263   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
 264   GNUNET_assert (GNUNET_SYSERR ==
 265                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 266                                             &metaDataR));
 267   msg = NULL;
 268   GNUNET_BIO_read_close (fileR, &msg);
 269   GNUNET_free (msg);
 270   GNUNET_CONTAINER_meta_data_destroy (metaDataR);
 271   GNUNET_CONTAINER_meta_data_destroy (metaDataW);
 272   return 0;
 273 }
 274
 275 static int
 276 test_fakestring_rw ()
 277 {
 278   char *msg;
 279   int32_t tmpInt = 2;
 280   char *readResult;
 281   struct GNUNET_BIO_WriteHandle *fileW;
 282   struct GNUNET_BIO_ReadHandle *fileR;
 283   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 284
 285   fileW = GNUNET_BIO_write_open (fileName);
 286   GNUNET_assert (NULL != fileW);
 287   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 288   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 289
 290   fileR = GNUNET_BIO_read_open (fileName);
 291   GNUNET_assert (NULL != fileR);
 292   GNUNET_assert (GNUNET_SYSERR ==
 293                  GNUNET_BIO_read_string (fileR, "Read string error",
 294                                          &readResult, 200));
 295   msg = NULL;
 296   GNUNET_BIO_read_close (fileR, &msg);
 297   GNUNET_free (msg);
 298   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 299   GNUNET_free (fileName);
 300   return 0;
 301 }
 302
 303 static int
 304 test_fakemeta_rw ()
 305 {
 306   char *msg;
 307   int32_t tmpInt = 2;
 308   struct GNUNET_BIO_WriteHandle *fileW;
 309   struct GNUNET_BIO_ReadHandle *fileR;
 310   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 311   struct GNUNET_CONTAINER_MetaData *metaDataR;
 312
 313   fileW = GNUNET_BIO_write_open (fileName);
 314   GNUNET_assert (NULL != fileW);
 315   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 316   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 317
 318   fileR = GNUNET_BIO_read_open (fileName);
 319   GNUNET_assert (NULL != fileR);
 320   metaDataR = NULL;
 321   GNUNET_assert (GNUNET_SYSERR ==
 322                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 323                                             &metaDataR));
 324   GNUNET_assert (NULL == metaDataR);
 325   msg = NULL;
 326   GNUNET_BIO_read_close (fileR, &msg);
 327   GNUNET_free (msg);
 328   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 329   GNUNET_free (fileName);
 330   return 0;
 331 }
 332
 333 static int
 334 test_fakebigmeta_rw ()
 335 {
 336   char *msg;
 337   int32_t tmpInt = 1024 * 1024 * 10;
 338   struct GNUNET_BIO_WriteHandle *fileW;
 339   struct GNUNET_BIO_ReadHandle *fileR;
 340   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 341   struct GNUNET_CONTAINER_MetaData *metaDataR;
 342
 343   fileW = GNUNET_BIO_write_open (fileName);
 344   GNUNET_assert (NULL != fileW);
 345   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 346   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 347
 348   fileR = GNUNET_BIO_read_open (fileName);
 349   GNUNET_assert (NULL != fileR);
 350   metaDataR = NULL;
 351   GNUNET_assert (GNUNET_SYSERR ==
 352                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 353                                             &metaDataR));
 354   msg = NULL;
 355   GNUNET_BIO_read_close (fileR, &msg);
 356   GNUNET_free (msg);
 357   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 358   GNUNET_assert (NULL == metaDataR);
 359   GNUNET_free (fileName);
 360   return 0;
 361 }
 362
 363 static int
 364 check_string_rw ()
 365 {
 366   GNUNET_assert (0 == test_nullstring_rw ());
 367   GNUNET_assert (0 == test_emptystring_rw ());
 368   GNUNET_assert (0 == test_bigstring_rw ());
 369   GNUNET_assert (0 == test_fakestring_rw ());
 370   return 0;
 371 }
 372
 373 static int
 374 check_metadata_rw ()
 375 {
 376   GNUNET_assert (0 == test_fakebigmeta_rw ());
 377   GNUNET_assert (0 == test_fakemeta_rw ());
 378   GNUNET_assert (0 == test_bigmeta_rw ());
 379   return 0;
 380 }
 381
 382 static int
 383 check_file_rw ()
 384 {
 385   GNUNET_assert (0 == test_normal_rw ());
 386   GNUNET_assert (0 == test_nullfile_rw ());
 387   GNUNET_assert (0 == test_directory_r());
 388   return 0;
 389 }
 390
 391 int
 392 main (int argc, char *argv[]){
 393     GNUNET_assert (0 == check_file_rw());
 394     GNUNET_assert (0 == check_metadata_rw());
 395     GNUNET_assert (0 == check_string_rw());
 396     return 0;
 397 }                               /* end of main */