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 2, 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 100000L
  32
  33 static int
  34 test_normal_rw(void){
  35         char *msg;
  36         int64_t testNum;
  37         char *readResultString;
  38         char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
  39         struct GNUNET_BIO_WriteHandle *fileW;
  40         struct GNUNET_BIO_ReadHandle *fileR;
  41     struct GNUNET_CONTAINER_MetaData *metaDataW;
  42     struct GNUNET_CONTAINER_MetaData *metaDataR;
  43     metaDataW = GNUNET_CONTAINER_meta_data_create ();
  44     metaDataR = GNUNET_CONTAINER_meta_data_create ();
  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, (int64_t)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     GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200));
  57     GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR));
  58     GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_meta_data_test_equal (metaDataR, metaDataW));
  59     GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
  60     GNUNET_BIO_read_close (fileR, &msg);
  61     GNUNET_CONTAINER_meta_data_destroy (metaDataW);
  62     GNUNET_CONTAINER_meta_data_destroy (metaDataR);
  63     GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
  64     GNUNET_free (fileName);
  65     return 0;
  66 }
  67
  68 static int
  69 test_nullstring_rw(){
  70         char *msg;
  71         char *readResultString = (char*) "not null";
  72         struct GNUNET_BIO_WriteHandle *fileW;
  73         struct GNUNET_BIO_ReadHandle *fileR;
  74         char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
  75
  76         fileW = GNUNET_BIO_write_open (fileName);
  77         GNUNET_assert (NULL != fileW);
  78     GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
  79     GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
  80
  81     fileR = GNUNET_BIO_read_open (fileName);
  82     GNUNET_assert (NULL != fileR);
  83     GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200));
  84     GNUNET_assert (NULL == readResultString);
  85     GNUNET_BIO_read_close (fileR, &msg);
  86     GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
  87     GNUNET_free (fileName);
  88
  89     return 0;
  90 }
  91
  92 static int
  93 test_emptystring_rw(void){
  94         char *msg;
  95         char *readResultString;
  96         struct GNUNET_BIO_WriteHandle *fileW;
  97         struct GNUNET_BIO_ReadHandle *fileR;
  98         char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
  99
 100         fileW = GNUNET_BIO_write_open (fileName);
 101         GNUNET_assert (NULL != fileW);
 102         GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
 103         GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 104
 105     fileR = GNUNET_BIO_read_open (fileName);
 106     GNUNET_assert (NULL != fileR);
 107     GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200));
 108     GNUNET_BIO_read_close (fileR, &msg);
 109     GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 110     GNUNET_free (fileName);
 111     return 0;
 112 }
 113
 114 static int
 115 test_bigstring_rw(void){
 116         char *msg;
 117         char *readResultString;
 118         struct GNUNET_BIO_WriteHandle *fileW;
 119         struct GNUNET_BIO_ReadHandle *fileR;
 120         char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 121
 122         fileW = GNUNET_BIO_write_open (fileName);
 123         GNUNET_assert (NULL != fileW);
 124         GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
 125         GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 126
 127     fileR = GNUNET_BIO_read_open (fileName);
 128     GNUNET_assert (NULL != fileR);
 129     GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 1));
 130     GNUNET_BIO_read_close (fileR, &msg);
 131     GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 132     GNUNET_free (fileName);
 133     return 0;
 134 }
 135
 136 static int
 137 test_bigmeta_rw(){
 138         char *msg;
 139         static char meta[1024 * 1024 * 10];
 140         memset(meta,'b',sizeof(meta));
 141         meta[sizeof(meta)-1]='\0';
 142         struct GNUNET_BIO_WriteHandle *fileW;
 143         struct GNUNET_BIO_ReadHandle *fileR;
 144         char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 145         struct GNUNET_CONTAINER_MetaData *metaDataW;
 146         struct GNUNET_CONTAINER_MetaData *metaDataR;
 147         metaDataW = GNUNET_CONTAINER_meta_data_create ();
 148     metaDataR = GNUNET_CONTAINER_meta_data_create ();
 149     GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
 150     GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (metaDataW, EXTRACTOR_COMMENT, meta));
 151
 152     fileW = GNUNET_BIO_write_open (fileName);
 153     GNUNET_assert (NULL != fileW);
 154     GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
 155     GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 156
 157     fileR = GNUNET_BIO_read_open (fileName);
 158     GNUNET_assert (NULL != fileR);
 159     GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR));
 160     GNUNET_BIO_read_close (fileR, &msg);
 161     GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 162     GNUNET_free (fileName);
 163     return 0;
 164 }
 165
 166 static int
 167 test_nullfile_rw(void){
 168         char *msg;
 169         int64_t testNum;
 170         char *readResultString;
 171         static char fileNameNO[102401];
 172         char readResult[200];
 173         memset(fileNameNO,'a',sizeof(fileNameNO));
 174         fileNameNO[sizeof(fileNameNO)-1] = '\0';
 175         const char *fileName = "/dev/full";
 176     const char *fileNameR = "/dev/null";
 177         struct GNUNET_BIO_WriteHandle *fileW,*fileWNO;
 178         struct GNUNET_BIO_ReadHandle *fileR,*fileRNO;
 179         struct GNUNET_CONTAINER_MetaData *metaDataW;
 180         struct GNUNET_CONTAINER_MetaData *metaDataR;
 181         metaDataW = GNUNET_CONTAINER_meta_data_create ();
 182         metaDataR = GNUNET_CONTAINER_meta_data_create ();
 183         GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
 184
 185         fileWNO = GNUNET_BIO_write_open(fileNameNO);
 186         GNUNET_assert (NULL == fileWNO);
 187
 188         fileRNO = GNUNET_BIO_read_open (fileNameNO);
 189         GNUNET_assert (NULL == fileRNO);
 190
 191         fileW = GNUNET_BIO_write_open (fileName);
 192         GNUNET_assert (NULL != fileW);
 193         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write (fileW, TESTSTRING, 65537));
 194         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_string (fileW, TESTSTRING));
 195         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_meta_data (fileW, metaDataW));
 196         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 197         fileW = GNUNET_BIO_write_open (fileName);
 198         GNUNET_assert (NULL != fileW);
 199         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
 200
 201         fileR = GNUNET_BIO_read_open (fileNameR);
 202         GNUNET_assert (NULL != fileR);
 203         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read (fileR, "Read error", readResult, 65537));
 204         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200));
 205         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
 206     GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR));
 207     GNUNET_BIO_read_close (fileR, &msg);
 208     return 0;
 209 }
 210
 211 static int
 212 test_fakestring_rw(void){
 213         char *msg;
 214         int32_t tmpInt = 2;
 215         char *readResult;
 216         struct GNUNET_BIO_WriteHandle *fileW;
 217         struct GNUNET_BIO_ReadHandle *fileR;
 218         char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 219
 220         fileW = GNUNET_BIO_write_open (fileName);
 221         GNUNET_assert (NULL != fileW);
 222         GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
 223         GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 224
 225         fileR = GNUNET_BIO_read_open (fileName);
 226         GNUNET_assert (NULL != fileR);
 227         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string(fileR, "Read string error", &readResult, 200));
 228         GNUNET_BIO_read_close (fileR, &msg);
 229         GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 230     GNUNET_free (fileName);
 231         return 0;
 232 }
 233
 234 static int
 235 test_fakemeta_rw(void){
 236         char *msg;
 237         int32_t tmpInt = 2;
 238         struct GNUNET_BIO_WriteHandle *fileW;
 239         struct GNUNET_BIO_ReadHandle *fileR;
 240         char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 241         struct GNUNET_CONTAINER_MetaData *metaDataR;
 242         metaDataR = GNUNET_CONTAINER_meta_data_create ();
 243
 244         fileW = GNUNET_BIO_write_open (fileName);
 245         GNUNET_assert (NULL != fileW);
 246         GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW,tmpInt));
 247         GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 248
 249         fileR = GNUNET_BIO_read_open (fileName);
 250         GNUNET_assert (NULL != fileR);
 251         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR));
 252         GNUNET_BIO_read_close (fileR, &msg);
 253         GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 254     GNUNET_free (fileName);
 255         return 0;
 256 }
 257
 258 static int
 259 test_fakebigmeta_rw(void){
 260         char *msg;
 261         int32_t tmpInt = 1024*1024*10;
 262         struct GNUNET_BIO_WriteHandle *fileW;
 263         struct GNUNET_BIO_ReadHandle *fileR;
 264         char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
 265         struct GNUNET_CONTAINER_MetaData *metaDataR;
 266         metaDataR = GNUNET_CONTAINER_meta_data_create ();
 267
 268         fileW = GNUNET_BIO_write_open (fileName);
 269         GNUNET_assert (NULL != fileW);
 270         GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
 271         GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
 272
 273         fileR = GNUNET_BIO_read_open (fileName);
 274         GNUNET_assert (NULL != fileR);
 275         GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR));
 276         GNUNET_BIO_read_close (fileR, &msg);
 277         GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
 278     GNUNET_free (fileName);
 279     return 0;
 280 }
 281
 282 static int
 283 check_string_rw(void){
 284         GNUNET_assert (0 == test_nullstring_rw());
 285         GNUNET_assert (0 == test_emptystring_rw());
 286         GNUNET_assert (0 == test_bigstring_rw());
 287         GNUNET_assert (0 == test_fakestring_rw());
 288         return 0;
 289 }
 290
 291 static int
 292 check_metadata_rw(void){
 293         GNUNET_assert (0 == test_fakebigmeta_rw());
 294         GNUNET_assert (0 == test_fakemeta_rw());
 295         GNUNET_assert (0 == test_bigmeta_rw());
 296         return 0;
 297 }
 298
 299 static int
 300 check_file_rw(void){
 301     GNUNET_assert (0 == test_normal_rw());
 302         GNUNET_assert (0 == test_nullfile_rw());
 303         return 0;
 304 }
 305
 306 int
 307 main (int argc, char *argv[]){
 308     GNUNET_assert (0 == check_file_rw());
 309     GNUNET_assert (0 == check_metadata_rw());
 310     GNUNET_assert (0 == check_string_rw());
 311     return 0;
 312 }                               /* end of main */