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