expand GNUNET_OS_ProjectData API to also enable de-duplcation of logic for --help

[oweals/gnunet.git] / src / util / test_bio.c

diff --git a/src/util/test_bio.c b/src/util/test_bio.c
index d2eb4ae21cd38d6245b0048df5180eebde1ecedd..c88b784263437c457dff2388c70664b5fca84631 100644 (file)
--- a/src/util/test_bio.c
+++ b/src/util/test_bio.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.

-     (C) 2009 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2009 GNUnet e.V.

 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published

-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your

      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but


@@ -14,8 +14,8 @@
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the

-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
+     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+     Boston, MA 02110-1301, USA.

 */
 
 /**
 */
 
 /**


@@ -28,131 +28,390 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #define TESTSTRING "testString"
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #define TESTSTRING "testString"

-#define TESTNUMBER64 100000L
+#define TESTNUMBER64 ((int64_t)100000L)

 
 

-int
-main (int argc, char *argv[])
+static int
+test_normal_rw ()

 {
 {

-
-  char *readResultString;
-  int64_t testNumber = (int64_t) TESTNUMBER64;
-  int64_t testNum;

   char *msg;
   char *msg;

-  static char file[102400];
-  static char meta[1024 * 1024 * 10];
-  int i, j;
-  for (i = 0; i < 102400; i++)
-    {
-      file[i] = 'a';
-    }
-  for (j = 0; j < 1024 * 1024 * 10; j++)
-    {
-      meta[j] = 'b';
-    }
+  int64_t testNum;
+  char *readResultString;

   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
   char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");

-  char *fileName2 = GNUNET_DISK_mktemp ("gnunet_zwei_bio");
-  char *fileName3 = GNUNET_DISK_mktemp ("gnunet_drei_bio");
-  char *fileName4 = GNUNET_DISK_mktemp ("gnunet_vier_bio");
-
-  struct GNUNET_BIO_ReadHandle *fileR, *fileR2, *fileR3, *fileR4;
-  struct GNUNET_BIO_WriteHandle *fileW, *fileW2, *fileW3, *fileW4;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;

   struct GNUNET_CONTAINER_MetaData *metaDataW;
   struct GNUNET_CONTAINER_MetaData *metaDataR;
   struct GNUNET_CONTAINER_MetaData *metaDataW;
   struct GNUNET_CONTAINER_MetaData *metaDataR;

-  struct GNUNET_BIO_ReadHandle *fileRNO;
-  struct GNUNET_BIO_WriteHandle *fileWNO;
-  struct GNUNET_CONTAINER_MetaData *metaData;
-  struct GNUNET_CONTAINER_MetaData *metaDataNO;

 
 

-  metaData = GNUNET_CONTAINER_meta_data_create ();
-  metaDataNO = GNUNET_CONTAINER_meta_data_create ();
-  metaDataR = GNUNET_CONTAINER_meta_data_create ();

   metaDataW = GNUNET_CONTAINER_meta_data_create ();
   metaDataW = GNUNET_CONTAINER_meta_data_create ();

+  metaDataR = NULL;

   GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
   GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);

-  GNUNET_CONTAINER_meta_data_add_publication_date (metaData);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_meta_data_insert (metaData,
-                                                    EXTRACTOR_COMMENT, meta));

 
 

-///////////write

   fileW = GNUNET_BIO_write_open (fileName);
   GNUNET_assert (NULL != fileW);
   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
   fileW = GNUNET_BIO_write_open (fileName);
   GNUNET_assert (NULL != fileW);
   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));

-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, testNumber));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, TESTNUMBER64));

   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
   GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));

-  fileW2 = GNUNET_BIO_write_open (fileName2);
-  GNUNET_assert (NULL != fileW2);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW2, NULL));
-  fileWNO = GNUNET_BIO_write_open (file);
-  GNUNET_assert (NULL != fileWNO);
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_write_string (fileWNO, TESTSTRING));
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_write_meta_data (fileWNO, metaDataW));
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileWNO));
-  fileW3 = GNUNET_BIO_write_open (fileName3);
-  GNUNET_assert (NULL != fileW3);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW3, metaData));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW3));
-  fileW4 = GNUNET_BIO_write_open (fileName4);
-  GNUNET_assert (NULL != fileW4);
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW4, ""));
-  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW4));
-
-////////////read
-  fileRNO = GNUNET_BIO_read_open (file);
-  GNUNET_assert (NULL != fileRNO);
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_string (fileRNO, "Read string error",
-                                         &readResultString, 200));
-  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileRNO, &testNum));
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_meta_data (fileRNO, "Read meta error",
-                                            &metaDataNO));
+

   fileR = GNUNET_BIO_read_open (fileName);
   GNUNET_assert (NULL != fileR);
   fileR = GNUNET_BIO_read_open (fileName);
   GNUNET_assert (NULL != fileR);

+  readResultString = NULL;

   GNUNET_assert (GNUNET_OK ==
                  GNUNET_BIO_read_string (fileR, "Read string error",
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_BIO_read_string (fileR, "Read string error",

-                                           &readResultString, 200));
+                                         &readResultString, 200));
+  GNUNET_assert (NULL != readResultString);
+  GNUNET_assert (0 == strcmp (TESTSTRING, readResultString));
+  GNUNET_free (readResultString);

   GNUNET_assert (GNUNET_OK ==
                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
                                             &metaDataR));
   GNUNET_assert (GNUNET_YES ==
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_BIO_read_meta_data (fileR, "Read meta error",
                                             &metaDataR));
   GNUNET_assert (GNUNET_YES ==

-                 GNUNET_CONTAINER_meta_data_test_equal (metaDataR,
-                                                        metaDataW));
+                 GNUNET_CONTAINER_meta_data_test_equal (metaDataR, metaDataW));

   GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
   GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));

-  fileR2 = GNUNET_BIO_read_open (fileName2);
-  GNUNET_assert (NULL != fileR2);
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_string (fileR2, "Read string error",
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_CONTAINER_meta_data_destroy (metaDataW);
+  GNUNET_CONTAINER_meta_data_destroy (metaDataR);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
+}
+
+static int
+test_nullstring_rw ()
+{
+  char *msg;
+  char *readResultString = (char *) "not null";
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_BIO_read_string (fileR, "Read string error",

                                          &readResultString, 200));
                                          &readResultString, 200));

-  fileR3 = GNUNET_BIO_read_open (fileName3);
-  GNUNET_assert (NULL != fileR3);
-  GNUNET_assert (GNUNET_SYSERR ==
-                 GNUNET_BIO_read_meta_data (fileR3, "Read meta error",
-                                            &metaDataR));
-  fileR4 = GNUNET_BIO_read_open (fileName4);
-  GNUNET_assert (NULL != fileR4);
+  GNUNET_assert (NULL == readResultString);
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+
+  return 0;
+}
+
+static int
+test_emptystring_rw ()
+{
+  char *msg;
+  char *readResultString;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  readResultString = NULL;

   GNUNET_assert (GNUNET_OK ==
   GNUNET_assert (GNUNET_OK ==

-                 GNUNET_BIO_read_string (fileR4, "Read string error",
+                 GNUNET_BIO_read_string (fileR, "Read string error",

                                          &readResultString, 200));
                                          &readResultString, 200));

-  GNUNET_assert (GNUNET_SYSERR  ==
-                   GNUNET_BIO_read_string (fileR4, "Read string error",
-                                               &readResultString, 0));
+  GNUNET_free (readResultString);
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
+}
+
+static int
+test_bigstring_rw ()
+{
+  char *msg;
+  char *readResultString;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  readResultString = NULL;
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_string (fileR, "Read string error",
+                                         &readResultString, 1));
+  GNUNET_assert (NULL == readResultString);
+  msg = NULL;
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_free (msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
+}
+
+static int
+test_bigmeta_rw ()
+{
+  char *msg;
+  static char meta[1024 * 1024 * 10];
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  struct GNUNET_CONTAINER_MetaData *metaDataR;
+
+  memset (meta, 'b', sizeof (meta));
+  meta[sizeof (meta) - 1] = '\0';
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, sizeof (meta)));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write (fileW, meta, sizeof (meta)));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  metaDataR = NULL;
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+                                            &metaDataR));
+  msg = NULL;

   GNUNET_BIO_read_close (fileR, &msg);
   GNUNET_BIO_read_close (fileR, &msg);

-  GNUNET_BIO_read_close (fileR2, &msg);
-  GNUNET_BIO_read_close (fileR3, &msg);
-  GNUNET_BIO_read_close (fileR4, &msg);
+  GNUNET_free (msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_assert (NULL == metaDataR);
+  GNUNET_free (fileName);
+  return 0;
+}
+
+static int
+test_directory_r ()
+{
+#if LINUX
+  char *msg;
+  char readResult[200];
+  struct GNUNET_BIO_ReadHandle *fileR;
+
+  fileR = GNUNET_BIO_read_open ("/dev");
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read (fileR, "Read error", readResult,
+                                  sizeof (readResult)));
+  msg = NULL;
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_free (msg);
+#endif
+  return 0;
+}
+
+static int
+test_nullfile_rw ()
+{
+  static char fileNameNO[102401];
+  struct GNUNET_BIO_WriteHandle *fileWNO;
+  struct GNUNET_BIO_ReadHandle *fileRNO;
+
+  memset (fileNameNO, 'a', sizeof (fileNameNO));
+  fileNameNO[sizeof (fileNameNO) - 1] = '\0';
+
+  GNUNET_log_skip (1, GNUNET_NO);
+  fileWNO = GNUNET_BIO_write_open (fileNameNO);
+  GNUNET_log_skip (0, GNUNET_YES);
+  GNUNET_assert (NULL == fileWNO);
+
+  GNUNET_log_skip (1, GNUNET_NO);
+  fileRNO = GNUNET_BIO_read_open (fileNameNO);
+  GNUNET_log_skip (0, GNUNET_YES);
+  GNUNET_assert (NULL == fileRNO);
+  return 0;
+}
+
+
+static int
+test_fullfile_rw ()
+{
+#ifdef LINUX
+  /* /dev/full only seems to exist on Linux */
+  char *msg;
+  int64_t testNum;
+  char *readResultString;
+  char readResult[200];
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  struct GNUNET_CONTAINER_MetaData *metaDataW;
+  struct GNUNET_CONTAINER_MetaData *metaDataR;
+
+  metaDataW = GNUNET_CONTAINER_meta_data_create ();
+  GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
+
+  fileW = GNUNET_BIO_write_open ("/dev/full");
+  GNUNET_assert (NULL != fileW);
+  (void) GNUNET_BIO_write (fileW, TESTSTRING, strlen (TESTSTRING));
+  (void) GNUNET_BIO_write_string (fileW, TESTSTRING);
+  (void) GNUNET_BIO_write_meta_data (fileW, metaDataW);
+  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));

   GNUNET_CONTAINER_meta_data_destroy (metaDataW);
   GNUNET_CONTAINER_meta_data_destroy (metaDataW);

-  GNUNET_CONTAINER_meta_data_destroy (metaDataNO);
-  GNUNET_CONTAINER_meta_data_destroy (metaDataR);
-  GNUNET_CONTAINER_meta_data_destroy (metaData);
+
+  fileW = GNUNET_BIO_write_open ("/dev/full");
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
+
+  fileR = GNUNET_BIO_read_open ("/dev/null");
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read (fileR, "Read error", readResult,
+                                  sizeof (readResult)));
+  readResultString = NULL;
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_string (fileR, "Read string error",
+                                         &readResultString, 200));
+  GNUNET_assert (NULL == readResultString);
+  GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
+  metaDataR = NULL;
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+                                            &metaDataR));
+  msg = NULL;
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_free (msg);
+  GNUNET_assert (NULL == metaDataR);
+#endif
+  return 0;
+}
+
+static int
+test_fakestring_rw ()
+{
+  char *msg;
+  int32_t tmpInt = 2;
+  char *readResult;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_string (fileR, "Read string error",
+                                         &readResult, 200));
+  msg = NULL;
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_free (msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
+}
+
+static int
+test_fakemeta_rw ()
+{
+  char *msg;
+  int32_t tmpInt = 2;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  struct GNUNET_CONTAINER_MetaData *metaDataR;
+
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  metaDataR = NULL;
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+                                            &metaDataR));
+  GNUNET_assert (NULL == metaDataR);
+  msg = NULL;
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_free (msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_free (fileName);
+  return 0;
+}
+
+static int
+test_fakebigmeta_rw ()
+{
+  char *msg;
+  int32_t tmpInt = 1024 * 1024 * 10;
+  struct GNUNET_BIO_WriteHandle *fileW;
+  struct GNUNET_BIO_ReadHandle *fileR;
+  char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
+  struct GNUNET_CONTAINER_MetaData *metaDataR;
+
+  fileW = GNUNET_BIO_write_open (fileName);
+  GNUNET_assert (NULL != fileW);
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
+  GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
+
+  fileR = GNUNET_BIO_read_open (fileName);
+  GNUNET_assert (NULL != fileR);
+  metaDataR = NULL;
+  GNUNET_assert (GNUNET_SYSERR ==
+                 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
+                                            &metaDataR));
+  msg = NULL;
+  GNUNET_BIO_read_close (fileR, &msg);
+  GNUNET_free (msg);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
+  GNUNET_assert (NULL == metaDataR);

   GNUNET_free (fileName);
   GNUNET_free (fileName);

-  GNUNET_free (fileName2);
-  GNUNET_free (fileName3);
-  GNUNET_free (fileName4);
+  return 0;
+}
+
+static int
+check_string_rw ()
+{
+  GNUNET_assert (0 == test_nullstring_rw ());
+  GNUNET_assert (0 == test_emptystring_rw ());
+  GNUNET_assert (0 == test_bigstring_rw ());
+  GNUNET_assert (0 == test_fakestring_rw ());
+  return 0;
+}
+
+static int
+check_metadata_rw ()
+{
+  GNUNET_assert (0 == test_fakebigmeta_rw ());
+  GNUNET_assert (0 == test_fakemeta_rw ());
+  GNUNET_assert (0 == test_bigmeta_rw ());
+  return 0;
+}

 
 

+static int
+check_file_rw ()
+{
+  GNUNET_assert (0 == test_normal_rw ());
+  GNUNET_assert (0 == test_nullfile_rw ());
+  GNUNET_assert (0 == test_fullfile_rw ());
+  GNUNET_assert (0 == test_directory_r ());
+  return 0;
+}

 
 

+int
+main (int argc, char *argv[])
+{
+  GNUNET_log_setup ("test-bio", "WARNING", NULL);
+  GNUNET_assert (0 == check_file_rw ());
+  GNUNET_assert (0 == check_metadata_rw ());
+  GNUNET_assert (0 == check_string_rw ());

   return 0;
   return 0;

+}

 
 

-}                               /* end of main */
+/* end of test_bio.c */