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