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