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