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      SPDX-License-Identifier: AGPL3.0-or-later
  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, 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
  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
 108 static int
 109 test_emptystring_rw ()
 110 {
 111   char *msg;
 112   char *readResultString;
 113   struct GNUNET_BIO_WriteHandle *fileW;
 114   struct GNUNET_BIO_ReadHandle *fileR;
 115   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 116
 117   fileW = GNUNET_BIO_write_open (fileName);
 118   GNUNET_assert (NULL != fileW);
 119   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
 120   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 121
 122   fileR = GNUNET_BIO_read_open (fileName);
 123   GNUNET_assert (NULL != fileR);
 124   readResultString = NULL;
 125   GNUNET_assert (GNUNET_OK ==
 126                  GNUNET_BIO_read_string (fileR, "Read string error",
 127                                          &readResultString, 200));
 128   GNUNET_free (readResultString);
 129   GNUNET_BIO_read_close (fileR, &msg);
 130   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 131   GNUNET_free (fileName);
 132   return 0;
 133 }
 134
 135
 136 static int
 137 test_bigstring_rw ()
 138 {
 139   char *msg;
 140   char *readResultString;
 141   struct GNUNET_BIO_WriteHandle *fileW;
 142   struct GNUNET_BIO_ReadHandle *fileR;
 143   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 144
 145   fileW = GNUNET_BIO_write_open (fileName);
 146   GNUNET_assert (NULL != fileW);
 147   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
 148   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 149
 150   fileR = GNUNET_BIO_read_open (fileName);
 151   GNUNET_assert (NULL != fileR);
 152   readResultString = NULL;
 153   GNUNET_assert (GNUNET_SYSERR ==
 154                  GNUNET_BIO_read_string (fileR, "Read string error",
 155                                          &readResultString, 1));
 156   GNUNET_assert (NULL == readResultString);
 157   msg = NULL;
 158   GNUNET_BIO_read_close (fileR, &msg);
 159   GNUNET_free (msg);
 160   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 161   GNUNET_free (fileName);
 162   return 0;
 163 }
 164
 165
 166 static int
 167 test_bigmeta_rw ()
 168 {
 169   char *msg;
 170   static char meta[1024 * 1024 * 10];
 171   struct GNUNET_BIO_WriteHandle *fileW;
 172   struct GNUNET_BIO_ReadHandle *fileR;
 173   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 174   struct GNUNET_CONTAINER_MetaData *metaDataR;
 175
 176   memset (meta, 'b', sizeof(meta));
 177   meta[sizeof(meta) - 1] = '\0';
 178   fileW = GNUNET_BIO_write_open (fileName);
 179   GNUNET_assert (NULL != fileW);
 180   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, sizeof(meta)));
 181   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write (fileW, meta, sizeof(meta)));
 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_assert (GNUNET_SYSERR ==
 188                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 189                                             &metaDataR));
 190   msg = NULL;
 191   GNUNET_BIO_read_close (fileR, &msg);
 192   GNUNET_free (msg);
 193   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 194   GNUNET_assert (NULL == metaDataR);
 195   GNUNET_free (fileName);
 196   return 0;
 197 }
 198
 199
 200 static int
 201 test_directory_r ()
 202 {
 203 #ifdef __linux__
 204   char *msg;
 205   char readResult[200];
 206   struct GNUNET_BIO_ReadHandle *fileR;
 207
 208   fileR = GNUNET_BIO_read_open ("/dev");
 209   GNUNET_assert (NULL != fileR);
 210   GNUNET_assert (GNUNET_SYSERR ==
 211                  GNUNET_BIO_read (fileR, "Read error", readResult,
 212                                   sizeof(readResult)));
 213   msg = NULL;
 214   GNUNET_BIO_read_close (fileR, &msg);
 215   GNUNET_free (msg);
 216 #endif
 217   return 0;
 218 }
 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   (void) GNUNET_BIO_write (fileW, TESTSTRING, strlen (TESTSTRING));
 264   (void) GNUNET_BIO_write_string (fileW, TESTSTRING);
 265   (void) 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,
 277                                   sizeof(readResult)));
 278   readResultString = NULL;
 279   GNUNET_assert (GNUNET_SYSERR ==
 280                  GNUNET_BIO_read_string (fileR, "Read string error",
 281                                          &readResultString, 200));
 282   GNUNET_assert (NULL == readResultString);
 283   GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
 284   metaDataR = NULL;
 285   GNUNET_assert (GNUNET_SYSERR ==
 286                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 287                                             &metaDataR));
 288   msg = NULL;
 289   GNUNET_BIO_read_close (fileR, &msg);
 290   GNUNET_free (msg);
 291   GNUNET_assert (NULL == metaDataR);
 292 #endif
 293   return 0;
 294 }
 295
 296
 297 static int
 298 test_fakestring_rw ()
 299 {
 300   char *msg;
 301   int32_t tmpInt = 2;
 302   char *readResult;
 303   struct GNUNET_BIO_WriteHandle *fileW;
 304   struct GNUNET_BIO_ReadHandle *fileR;
 305   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 306
 307   fileW = GNUNET_BIO_write_open (fileName);
 308   GNUNET_assert (NULL != fileW);
 309   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 310   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 311
 312   fileR = GNUNET_BIO_read_open (fileName);
 313   GNUNET_assert (NULL != fileR);
 314   GNUNET_assert (GNUNET_SYSERR ==
 315                  GNUNET_BIO_read_string (fileR, "Read string error",
 316                                          &readResult, 200));
 317   msg = NULL;
 318   GNUNET_BIO_read_close (fileR, &msg);
 319   GNUNET_free (msg);
 320   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 321   GNUNET_free (fileName);
 322   return 0;
 323 }
 324
 325
 326 static int
 327 test_fakemeta_rw ()
 328 {
 329   char *msg;
 330   int32_t tmpInt = 2;
 331   struct GNUNET_BIO_WriteHandle *fileW;
 332   struct GNUNET_BIO_ReadHandle *fileR;
 333   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 334   struct GNUNET_CONTAINER_MetaData *metaDataR;
 335
 336   fileW = GNUNET_BIO_write_open (fileName);
 337   GNUNET_assert (NULL != fileW);
 338   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 339   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 340
 341   fileR = GNUNET_BIO_read_open (fileName);
 342   GNUNET_assert (NULL != fileR);
 343   metaDataR = NULL;
 344   GNUNET_assert (GNUNET_SYSERR ==
 345                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 346                                             &metaDataR));
 347   GNUNET_assert (NULL == metaDataR);
 348   msg = NULL;
 349   GNUNET_BIO_read_close (fileR, &msg);
 350   GNUNET_free (msg);
 351   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 352   GNUNET_free (fileName);
 353   return 0;
 354 }
 355
 356
 357 static int
 358 test_fakebigmeta_rw ()
 359 {
 360   char *msg;
 361   int32_t tmpInt = 1024 * 1024 * 10;
 362   struct GNUNET_BIO_WriteHandle *fileW;
 363   struct GNUNET_BIO_ReadHandle *fileR;
 364   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 365   struct GNUNET_CONTAINER_MetaData *metaDataR;
 366
 367   fileW = GNUNET_BIO_write_open (fileName);
 368   GNUNET_assert (NULL != fileW);
 369   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
 370   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 371
 372   fileR = GNUNET_BIO_read_open (fileName);
 373   GNUNET_assert (NULL != fileR);
 374   metaDataR = NULL;
 375   GNUNET_assert (GNUNET_SYSERR ==
 376                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
 377                                             &metaDataR));
 378   msg = NULL;
 379   GNUNET_BIO_read_close (fileR, &msg);
 380   GNUNET_free (msg);
 381   GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 382   GNUNET_assert (NULL == metaDataR);
 383   GNUNET_free (fileName);
 384   return 0;
 385 }
 386
 387
 388 static int
 389 check_string_rw ()
 390 {
 391   GNUNET_assert (0 == test_nullstring_rw ());
 392   GNUNET_assert (0 == test_emptystring_rw ());
 393   GNUNET_assert (0 == test_bigstring_rw ());
 394   GNUNET_assert (0 == test_fakestring_rw ());
 395   return 0;
 396 }
 397
 398
 399 static int
 400 check_metadata_rw ()
 401 {
 402   GNUNET_assert (0 == test_fakebigmeta_rw ());
 403   GNUNET_assert (0 == test_fakemeta_rw ());
 404   GNUNET_assert (0 == test_bigmeta_rw ());
 405   return 0;
 406 }
 407
 408
 409 static int
 410 check_file_rw ()
 411 {
 412   GNUNET_assert (0 == test_normal_rw ());
 413   GNUNET_assert (0 == test_nullfile_rw ());
 414   GNUNET_assert (0 == test_fullfile_rw ());
 415   GNUNET_assert (0 == test_directory_r ());
 416   return 0;
 417 }
 418
 419
 420 int
 421 main (int argc, char *argv[])
 422 {
 423   GNUNET_log_setup ("test-bio", "WARNING", NULL);
 424   GNUNET_assert (0 == check_file_rw ());
 425   GNUNET_assert (0 == check_metadata_rw ());
 426   GNUNET_assert (0 == check_string_rw ());
 427   return 0;
 428 }
 429
 430
 431 /* end of test_bio.c */