src/util/test_bio.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2009 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 /**
  20  * @file util/test_bio.c
  21  * @brief testcase for the buffered IO module
  22  * @author Ji Lu
  23  */
  24
  25
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #define TESTSTRING "testString"
  29 #define TESTNUMBER64 ((int64_t)100000L)
  30
  31 static int
  32 test_normal_rw ()
  33 {
  34   char *msg;
  35   int64_t testNum;
  36   char *readResultString;
  37   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
  38   struct GNUNET_BIO_WriteHandle *fileW;
  39   struct GNUNET_BIO_ReadHandle *fileR;
  40   struct GNUNET_CONTAINER_MetaData *metaDataW;
  41   struct GNUNET_CONTAINER_MetaData *metaDataR;
  42
  43   metaDataW = GNUNET_CONTAINER_meta_data_create ();
  44   metaDataR = NULL;
  45   GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
  46
  47   fileW = GNUNET_BIO_write_open (fileName);
  48   GNUNET_assert (NULL != fileW);
  49   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
  50   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
  51   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, TESTNUMBER64));
  52   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
  53
  54   fileR = GNUNET_BIO_read_open (fileName);
  55   GNUNET_assert (NULL != fileR);
  56   readResultString = NULL;
  57   GNUNET_assert (GNUNET_OK ==
  58                  GNUNET_BIO_read_string (fileR, "Read string error",
  59                                          &readResultString, 200));
  60   GNUNET_assert (NULL != readResultString);
  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, metaDataW));
  68   GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
  69   GNUNET_BIO_read_close (fileR, &msg);
  70   GNUNET_CONTAINER_meta_data_destroy (metaDataW);
  71   GNUNET_CONTAINER_meta_data_destroy (metaDataR);
  72   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
  73   GNUNET_free (fileName);
  74   return 0;
  75 }
  76
  77 static int
  78 test_nullstring_rw ()
  79 {
  80   char *msg;
  81   char *readResultString = (char *) "not null";
  82   struct GNUNET_BIO_WriteHandle *fileW;
  83   struct GNUNET_BIO_ReadHandle *fileR;
  84   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
  85
  86   fileW = GNUNET_BIO_write_open (fileName);
  87   GNUNET_assert (NULL != fileW);
  88   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
  89   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
  90
  91   fileR = GNUNET_BIO_read_open (fileName);
  92   GNUNET_assert (NULL != fileR);
  93   GNUNET_assert (GNUNET_OK ==
  94                  GNUNET_BIO_read_string (fileR, "Read string error",
  95                                          &readResultString, 200));
  96   GNUNET_assert (NULL == readResultString);
  97   GNUNET_BIO_read_close (fileR, &msg);
  98   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
  99   GNUNET_free (fileName);
 100
 101   return 0;
 102 }
 103
 104 static int
 105 test_emptystring_rw ()
 106 {
 107   char *msg;
 108   char *readResultString;
 109   struct GNUNET_BIO_WriteHandle *fileW;
 110   struct GNUNET_BIO_ReadHandle *fileR;
 111   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 112
 113   fileW = GNUNET_BIO_write_open (fileName);
 114   GNUNET_assert (NULL != fileW);
 115   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
 116   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 117
 118   fileR = GNUNET_BIO_read_open (fileName);
 119   GNUNET_assert (NULL != fileR);
 120   readResultString = NULL;
 121   GNUNET_assert (GNUNET_OK ==
 122                  GNUNET_BIO_read_string (fileR, "Read string error",
 123                                          &readResultString, 200));
 124   GNUNET_free (readResultString);
 125   GNUNET_BIO_read_close (fileR, &msg);
 126   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 127   GNUNET_free (fileName);
 128   return 0;
 129 }
 130
 131 static int
 132 test_bigstring_rw ()
 133 {
 134   char *msg;
 135   char *readResultString;
 136   struct GNUNET_BIO_WriteHandle *fileW;
 137   struct GNUNET_BIO_ReadHandle *fileR;
 138   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 139
 140   fileW = GNUNET_BIO_write_open (fileName);
 141   GNUNET_assert (NULL != fileW);
 142   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
 143   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 144
 145   fileR = GNUNET_BIO_read_open (fileName);
 146   GNUNET_assert (NULL != fileR);
 147   readResultString = NULL;
 148   GNUNET_assert (GNUNET_SYSERR ==
 149                  GNUNET_BIO_read_string (fileR, "Read string error",
 150                                          &readResultString, 1));
 151   GNUNET_assert (NULL == readResultString);
 152   msg = NULL;
 153   GNUNET_BIO_read_close (fileR, &msg);
 154   GNUNET_free (msg);
 155   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 156   GNUNET_free (fileName);
 157   return 0;
 158 }
 159
 160 static int
 161 test_bigmeta_rw ()
 162 {
 163   char *msg;
 164   static char meta[1024 * 1024 * 10];
 165   struct GNUNET_BIO_WriteHandle *fileW;
 166   struct GNUNET_BIO_ReadHandle *fileR;
 167   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 168   struct GNUNET_CONTAINER_MetaData *metaDataR;
 169
 170   memset (meta, 'b', sizeof (meta));
 171   meta[sizeof (meta) - 1] = '\0';
 172   fileW = GNUNET_BIO_write_open (fileName);
 173   GNUNET_assert (NULL != fileW);
 174   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, sizeof (meta)));
 175   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write (fileW, meta, sizeof (meta)));
 176   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 177
 178   fileR = GNUNET_BIO_read_open (fileName);
 179   GNUNET_assert (NULL != fileR);
 180   metaDataR = NULL;
 181   GNUNET_assert (GNUNET_SYSERR ==
 182                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 183                                             &metaDataR));
 184   msg = NULL;
 185   GNUNET_BIO_read_close (fileR, &msg);
 186   GNUNET_free (msg);
 187   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 188   GNUNET_assert (NULL == metaDataR);
 189   GNUNET_free (fileName);
 190   return 0;
 191 }
 192
 193 static int
 194 test_directory_r ()
 195 {
 196 #if LINUX
 197   char *msg;
 198   char readResult[200];
 199   struct GNUNET_BIO_ReadHandle *fileR;
 200
 201   fileR = GNUNET_BIO_read_open ("/dev");
 202   GNUNET_assert (NULL != fileR);
 203   GNUNET_assert (GNUNET_SYSERR ==
 204                  GNUNET_BIO_read (fileR, "Read error", readResult,
 205                                   sizeof (readResult)));
 206   msg = NULL;
 207   GNUNET_BIO_read_close (fileR, &msg);
 208   GNUNET_free (msg);
 209 #endif
 210   return 0;
 211 }
 212
 213 static int
 214 test_nullfile_rw ()
 215 {
 216   static char fileNameNO[102401];
 217   struct GNUNET_BIO_WriteHandle *fileWNO;
 218   struct GNUNET_BIO_ReadHandle *fileRNO;
 219
 220   memset (fileNameNO, 'a', sizeof (fileNameNO));
 221   fileNameNO[sizeof (fileNameNO) - 1] = '\0';
 222
 223   GNUNET_log_skip (1, GNUNET_NO);
 224   fileWNO = GNUNET_BIO_write_open (fileNameNO);
 225   GNUNET_log_skip (0, GNUNET_YES);
 226   GNUNET_assert (NULL == fileWNO);
 227
 228   GNUNET_log_skip (1, GNUNET_NO);
 229   fileRNO = GNUNET_BIO_read_open (fileNameNO);
 230   GNUNET_log_skip (0, GNUNET_YES);
 231   GNUNET_assert (NULL == fileRNO);
 232   return 0;
 233 }
 234
 235
 236 static int
 237 test_fullfile_rw ()
 238 {
 239 #ifdef LINUX
 240   /* /dev/full only seems to exist on Linux */
 241   char *msg;
 242   int64_t testNum;
 243   char *readResultString;
 244   char readResult[200];
 245   struct GNUNET_BIO_WriteHandle *fileW;
 246   struct GNUNET_BIO_ReadHandle *fileR;
 247   struct GNUNET_CONTAINER_MetaData *metaDataW;
 248   struct GNUNET_CONTAINER_MetaData *metaDataR;
 249
 250   metaDataW = GNUNET_CONTAINER_meta_data_create ();
 251   GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
 252
 253   fileW = GNUNET_BIO_write_open ("/dev/full");
 254   GNUNET_assert (NULL != fileW);
 255   (void) GNUNET_BIO_write (fileW, TESTSTRING, strlen (TESTSTRING));
 256   (void) GNUNET_BIO_write_string (fileW, TESTSTRING);
 257   (void) GNUNET_BIO_write_meta_data (fileW, metaDataW);
 258   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 259   GNUNET_CONTAINER_meta_data_destroy (metaDataW);
 260
 261   fileW = GNUNET_BIO_write_open ("/dev/full");
 262   GNUNET_assert (NULL != fileW);
 263   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 264
 265   fileR = GNUNET_BIO_read_open ("/dev/null");
 266   GNUNET_assert (NULL != fileR);
 267   GNUNET_assert (GNUNET_SYSERR ==
 268                  GNUNET_BIO_read (fileR, "Read error", readResult,
 269                                   sizeof (readResult)));
 270   readResultString = NULL;
 271   GNUNET_assert (GNUNET_SYSERR ==
 272                  GNUNET_BIO_read_string (fileR, "Read string error",
 273                                          &readResultString, 200));
 274   GNUNET_assert (NULL == readResultString);
 275   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
 276   metaDataR = NULL;
 277   GNUNET_assert (GNUNET_SYSERR ==
 278                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 279                                             &metaDataR));
 280   msg = NULL;
 281   GNUNET_BIO_read_close (fileR, &msg);
 282   GNUNET_free (msg);
 283   GNUNET_assert (NULL == metaDataR);
 284 #endif
 285   return 0;
 286 }
 287
 288 static int
 289 test_fakestring_rw ()
 290 {
 291   char *msg;
 292   int32_t tmpInt = 2;
 293   char *readResult;
 294   struct GNUNET_BIO_WriteHandle *fileW;
 295   struct GNUNET_BIO_ReadHandle *fileR;
 296   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 297
 298   fileW = GNUNET_BIO_write_open (fileName);
 299   GNUNET_assert (NULL != fileW);
 300   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 301   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 302
 303   fileR = GNUNET_BIO_read_open (fileName);
 304   GNUNET_assert (NULL != fileR);
 305   GNUNET_assert (GNUNET_SYSERR ==
 306                  GNUNET_BIO_read_string (fileR, "Read string error",
 307                                          &readResult, 200));
 308   msg = NULL;
 309   GNUNET_BIO_read_close (fileR, &msg);
 310   GNUNET_free (msg);
 311   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 312   GNUNET_free (fileName);
 313   return 0;
 314 }
 315
 316 static int
 317 test_fakemeta_rw ()
 318 {
 319   char *msg;
 320   int32_t tmpInt = 2;
 321   struct GNUNET_BIO_WriteHandle *fileW;
 322   struct GNUNET_BIO_ReadHandle *fileR;
 323   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 324   struct GNUNET_CONTAINER_MetaData *metaDataR;
 325
 326   fileW = GNUNET_BIO_write_open (fileName);
 327   GNUNET_assert (NULL != fileW);
 328   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 329   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 330
 331   fileR = GNUNET_BIO_read_open (fileName);
 332   GNUNET_assert (NULL != fileR);
 333   metaDataR = NULL;
 334   GNUNET_assert (GNUNET_SYSERR ==
 335                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 336                                             &metaDataR));
 337   GNUNET_assert (NULL == metaDataR);
 338   msg = NULL;
 339   GNUNET_BIO_read_close (fileR, &msg);
 340   GNUNET_free (msg);
 341   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 342   GNUNET_free (fileName);
 343   return 0;
 344 }
 345
 346 static int
 347 test_fakebigmeta_rw ()
 348 {
 349   char *msg;
 350   int32_t tmpInt = 1024 * 1024 * 10;
 351   struct GNUNET_BIO_WriteHandle *fileW;
 352   struct GNUNET_BIO_ReadHandle *fileR;
 353   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 354   struct GNUNET_CONTAINER_MetaData *metaDataR;
 355
 356   fileW = GNUNET_BIO_write_open (fileName);
 357   GNUNET_assert (NULL != fileW);
 358   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 359   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 360
 361   fileR = GNUNET_BIO_read_open (fileName);
 362   GNUNET_assert (NULL != fileR);
 363   metaDataR = NULL;
 364   GNUNET_assert (GNUNET_SYSERR ==
 365                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 366                                             &metaDataR));
 367   msg = NULL;
 368   GNUNET_BIO_read_close (fileR, &msg);
 369   GNUNET_free (msg);
 370   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 371   GNUNET_assert (NULL == metaDataR);
 372   GNUNET_free (fileName);
 373   return 0;
 374 }
 375
 376 static int
 377 check_string_rw ()
 378 {
 379   GNUNET_assert (0 == test_nullstring_rw ());
 380   GNUNET_assert (0 == test_emptystring_rw ());
 381   GNUNET_assert (0 == test_bigstring_rw ());
 382   GNUNET_assert (0 == test_fakestring_rw ());
 383   return 0;
 384 }
 385
 386 static int
 387 check_metadata_rw ()
 388 {
 389   GNUNET_assert (0 == test_fakebigmeta_rw ());
 390   GNUNET_assert (0 == test_fakemeta_rw ());
 391   GNUNET_assert (0 == test_bigmeta_rw ());
 392   return 0;
 393 }
 394
 395 static int
 396 check_file_rw ()
 397 {
 398   GNUNET_assert (0 == test_normal_rw ());
 399   GNUNET_assert (0 == test_nullfile_rw ());
 400   GNUNET_assert (0 == test_fullfile_rw ());
 401   GNUNET_assert (0 == test_directory_r ());
 402   return 0;
 403 }
 404
 405 int
 406 main (int argc, char *argv[])
 407 {
 408   GNUNET_log_setup ("test-bio", "WARNING", NULL);
 409   GNUNET_assert (0 == check_file_rw ());
 410   GNUNET_assert (0 == check_metadata_rw ());
 411   GNUNET_assert (0 == check_string_rw ());
 412   return 0;
 413 }
 414
 415 /* end of test_bio.c */