aboutsummaryrefslogtreecommitdiff
path: root/src/util/test_bio.c
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2009-11-08 21:31:27 +0000
committerChristian Grothoff <christian@grothoff.org>2009-11-08 21:31:27 +0000
commit024450ec8ac7d00b5c7c830d34ee1843b6c3a753 (patch)
treef5f8e91f837474ef4bca22f91672a3b14a606787 /src/util/test_bio.c
parentbb82fb7f4ea781b843f032c6869f98e6fa6fa107 (diff)
downloadgnunet-024450ec8ac7d00b5c7c830d34ee1843b6c3a753.tar.gz
gnunet-024450ec8ac7d00b5c7c830d34ee1843b6c3a753.zip
indenting
Diffstat (limited to 'src/util/test_bio.c')
-rw-r--r--src/util/test_bio.c528
1 files changed, 286 insertions, 242 deletions
diff --git a/src/util/test_bio.c b/src/util/test_bio.c
index 883424207..06dcfacc8 100644
--- a/src/util/test_bio.c
+++ b/src/util/test_bio.c
@@ -31,282 +31,326 @@
31#define TESTNUMBER64 100000L 31#define TESTNUMBER64 100000L
32 32
33static int 33static int
34test_normal_rw(void){ 34test_normal_rw (void)
35 char *msg; 35{
36 int64_t testNum; 36 char *msg;
37 char *readResultString; 37 int64_t testNum;
38 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 38 char *readResultString;
39 struct GNUNET_BIO_WriteHandle *fileW; 39 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
40 struct GNUNET_BIO_ReadHandle *fileR; 40 struct GNUNET_BIO_WriteHandle *fileW;
41 struct GNUNET_CONTAINER_MetaData *metaDataW; 41 struct GNUNET_BIO_ReadHandle *fileR;
42 struct GNUNET_CONTAINER_MetaData *metaDataR; 42 struct GNUNET_CONTAINER_MetaData *metaDataW;
43 metaDataW = GNUNET_CONTAINER_meta_data_create (); 43 struct GNUNET_CONTAINER_MetaData *metaDataR;
44 metaDataR = GNUNET_CONTAINER_meta_data_create (); 44 metaDataW = GNUNET_CONTAINER_meta_data_create ();
45 GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); 45 metaDataR = GNUNET_CONTAINER_meta_data_create ();
46 46 GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
47 fileW = GNUNET_BIO_write_open (fileName); 47
48 GNUNET_assert (NULL != fileW); 48 fileW = GNUNET_BIO_write_open (fileName);
49 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); 49 GNUNET_assert (NULL != fileW);
50 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW)); 50 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
51 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, (int64_t)TESTNUMBER64)); 51 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
52 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 52 GNUNET_assert (GNUNET_OK ==
53 53 GNUNET_BIO_write_int64 (fileW, (int64_t) TESTNUMBER64));
54 fileR = GNUNET_BIO_read_open (fileName); 54 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
55 GNUNET_assert (NULL != fileR); 55
56 GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); 56 fileR = GNUNET_BIO_read_open (fileName);
57 GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR)); 57 GNUNET_assert (NULL != fileR);
58 GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_meta_data_test_equal (metaDataR, metaDataW)); 58 GNUNET_assert (GNUNET_OK ==
59 GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum)); 59 GNUNET_BIO_read_string (fileR, "Read string error",
60 GNUNET_BIO_read_close (fileR, &msg); 60 &readResultString, 200));
61 GNUNET_CONTAINER_meta_data_destroy (metaDataW); 61 GNUNET_assert (GNUNET_OK ==
62 GNUNET_CONTAINER_meta_data_destroy (metaDataR); 62 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
63 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 63 &metaDataR));
64 GNUNET_free (fileName); 64 GNUNET_assert (GNUNET_YES ==
65 return 0; 65 GNUNET_CONTAINER_meta_data_test_equal (metaDataR,
66 metaDataW));
67 GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
68 GNUNET_BIO_read_close (fileR, &msg);
69 GNUNET_CONTAINER_meta_data_destroy (metaDataW);
70 GNUNET_CONTAINER_meta_data_destroy (metaDataR);
71 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
72 GNUNET_free (fileName);
73 return 0;
66} 74}
67 75
68static int 76static int
69test_nullstring_rw(){ 77test_nullstring_rw ()
70 char *msg; 78{
71 char *readResultString = (char*) "not null"; 79 char *msg;
72 struct GNUNET_BIO_WriteHandle *fileW; 80 char *readResultString = (char *) "not null";
73 struct GNUNET_BIO_ReadHandle *fileR; 81 struct GNUNET_BIO_WriteHandle *fileW;
74 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 82 struct GNUNET_BIO_ReadHandle *fileR;
75 83 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
76 fileW = GNUNET_BIO_write_open (fileName); 84
77 GNUNET_assert (NULL != fileW); 85 fileW = GNUNET_BIO_write_open (fileName);
78 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL)); 86 GNUNET_assert (NULL != fileW);
79 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 87 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
80 88 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
81 fileR = GNUNET_BIO_read_open (fileName); 89
82 GNUNET_assert (NULL != fileR); 90 fileR = GNUNET_BIO_read_open (fileName);
83 GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); 91 GNUNET_assert (NULL != fileR);
84 GNUNET_assert (NULL == readResultString); 92 GNUNET_assert (GNUNET_OK ==
85 GNUNET_BIO_read_close (fileR, &msg); 93 GNUNET_BIO_read_string (fileR, "Read string error",
86 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 94 &readResultString, 200));
87 GNUNET_free (fileName); 95 GNUNET_assert (NULL == readResultString);
88 96 GNUNET_BIO_read_close (fileR, &msg);
89 return 0; 97 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
98 GNUNET_free (fileName);
99
100 return 0;
90} 101}
91 102
92static int 103static int
93test_emptystring_rw(void){ 104test_emptystring_rw (void)
94 char *msg; 105{
95 char *readResultString; 106 char *msg;
96 struct GNUNET_BIO_WriteHandle *fileW; 107 char *readResultString;
97 struct GNUNET_BIO_ReadHandle *fileR; 108 struct GNUNET_BIO_WriteHandle *fileW;
98 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 109 struct GNUNET_BIO_ReadHandle *fileR;
99 110 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
100 fileW = GNUNET_BIO_write_open (fileName); 111
101 GNUNET_assert (NULL != fileW); 112 fileW = GNUNET_BIO_write_open (fileName);
102 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, "")); 113 GNUNET_assert (NULL != fileW);
103 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 114 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, ""));
104 115 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
105 fileR = GNUNET_BIO_read_open (fileName); 116
106 GNUNET_assert (NULL != fileR); 117 fileR = GNUNET_BIO_read_open (fileName);
107 GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); 118 GNUNET_assert (NULL != fileR);
108 GNUNET_BIO_read_close (fileR, &msg); 119 GNUNET_assert (GNUNET_OK ==
109 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 120 GNUNET_BIO_read_string (fileR, "Read string error",
110 GNUNET_free (fileName); 121 &readResultString, 200));
111 return 0; 122 GNUNET_BIO_read_close (fileR, &msg);
123 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
124 GNUNET_free (fileName);
125 return 0;
112} 126}
113 127
114static int 128static int
115test_bigstring_rw(void){ 129test_bigstring_rw (void)
116 char *msg; 130{
117 char *readResultString; 131 char *msg;
118 struct GNUNET_BIO_WriteHandle *fileW; 132 char *readResultString;
119 struct GNUNET_BIO_ReadHandle *fileR; 133 struct GNUNET_BIO_WriteHandle *fileW;
120 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 134 struct GNUNET_BIO_ReadHandle *fileR;
121 135 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
122 fileW = GNUNET_BIO_write_open (fileName); 136
123 GNUNET_assert (NULL != fileW); 137 fileW = GNUNET_BIO_write_open (fileName);
124 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); 138 GNUNET_assert (NULL != fileW);
125 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 139 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
126 140 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
127 fileR = GNUNET_BIO_read_open (fileName); 141
128 GNUNET_assert (NULL != fileR); 142 fileR = GNUNET_BIO_read_open (fileName);
129 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 1)); 143 GNUNET_assert (NULL != fileR);
130 GNUNET_BIO_read_close (fileR, &msg); 144 GNUNET_assert (GNUNET_SYSERR ==
131 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 145 GNUNET_BIO_read_string (fileR, "Read string error",
132 GNUNET_free (fileName); 146 &readResultString, 1));
133 return 0; 147 GNUNET_BIO_read_close (fileR, &msg);
148 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
149 GNUNET_free (fileName);
150 return 0;
134} 151}
135 152
136static int 153static int
137test_bigmeta_rw(){ 154test_bigmeta_rw ()
138 char *msg; 155{
139 static char meta[1024 * 1024 * 10]; 156 char *msg;
140 memset(meta,'b',sizeof(meta)); 157 static char meta[1024 * 1024 * 10];
141 meta[sizeof(meta)-1]='\0'; 158 memset (meta, 'b', sizeof (meta));
142 struct GNUNET_BIO_WriteHandle *fileW; 159 meta[sizeof (meta) - 1] = '\0';
143 struct GNUNET_BIO_ReadHandle *fileR; 160 struct GNUNET_BIO_WriteHandle *fileW;
144 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 161 struct GNUNET_BIO_ReadHandle *fileR;
145 struct GNUNET_CONTAINER_MetaData *metaDataW; 162 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
146 struct GNUNET_CONTAINER_MetaData *metaDataR; 163 struct GNUNET_CONTAINER_MetaData *metaDataW;
147 metaDataW = GNUNET_CONTAINER_meta_data_create (); 164 struct GNUNET_CONTAINER_MetaData *metaDataR;
148 metaDataR = GNUNET_CONTAINER_meta_data_create (); 165 metaDataW = GNUNET_CONTAINER_meta_data_create ();
149 GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); 166 metaDataR = GNUNET_CONTAINER_meta_data_create ();
150 GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (metaDataW, EXTRACTOR_COMMENT, meta)); 167 GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
151 168 GNUNET_assert (GNUNET_OK ==
152 fileW = GNUNET_BIO_write_open (fileName); 169 GNUNET_CONTAINER_meta_data_insert (metaDataW,
153 GNUNET_assert (NULL != fileW); 170 EXTRACTOR_COMMENT, meta));
154 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW)); 171
155 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 172 fileW = GNUNET_BIO_write_open (fileName);
156 173 GNUNET_assert (NULL != fileW);
157 fileR = GNUNET_BIO_read_open (fileName); 174 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
158 GNUNET_assert (NULL != fileR); 175 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
159 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR)); 176
160 GNUNET_BIO_read_close (fileR, &msg); 177 fileR = GNUNET_BIO_read_open (fileName);
161 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 178 GNUNET_assert (NULL != fileR);
162 GNUNET_free (fileName); 179 GNUNET_assert (GNUNET_SYSERR ==
163 return 0; 180 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
181 &metaDataR));
182 GNUNET_BIO_read_close (fileR, &msg);
183 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
184 GNUNET_free (fileName);
185 return 0;
164} 186}
165 187
166static int 188static int
167test_nullfile_rw(void){ 189test_nullfile_rw (void)
168 char *msg; 190{
169 int64_t testNum; 191 char *msg;
170 char *readResultString; 192 int64_t testNum;
171 static char fileNameNO[102401]; 193 char *readResultString;
172 char readResult[200]; 194 static char fileNameNO[102401];
173 memset(fileNameNO,'a',sizeof(fileNameNO)); 195 char readResult[200];
174 fileNameNO[sizeof(fileNameNO)-1] = '\0'; 196 memset (fileNameNO, 'a', sizeof (fileNameNO));
175 const char *fileName = "/dev/full"; 197 fileNameNO[sizeof (fileNameNO) - 1] = '\0';
176 const char *fileNameR = "/dev/null"; 198 const char *fileName = "/dev/full";
177 struct GNUNET_BIO_WriteHandle *fileW,*fileWNO; 199 const char *fileNameR = "/dev/null";
178 struct GNUNET_BIO_ReadHandle *fileR,*fileRNO; 200 struct GNUNET_BIO_WriteHandle *fileW, *fileWNO;
179 struct GNUNET_CONTAINER_MetaData *metaDataW; 201 struct GNUNET_BIO_ReadHandle *fileR, *fileRNO;
180 struct GNUNET_CONTAINER_MetaData *metaDataR; 202 struct GNUNET_CONTAINER_MetaData *metaDataW;
181 metaDataW = GNUNET_CONTAINER_meta_data_create (); 203 struct GNUNET_CONTAINER_MetaData *metaDataR;
182 metaDataR = GNUNET_CONTAINER_meta_data_create (); 204 metaDataW = GNUNET_CONTAINER_meta_data_create ();
183 GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); 205 metaDataR = GNUNET_CONTAINER_meta_data_create ();
184 206 GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
185 fileWNO = GNUNET_BIO_write_open(fileNameNO); 207
186 GNUNET_assert (NULL == fileWNO); 208 fileWNO = GNUNET_BIO_write_open (fileNameNO);
187 209 GNUNET_assert (NULL == fileWNO);
188 fileRNO = GNUNET_BIO_read_open (fileNameNO); 210
189 GNUNET_assert (NULL == fileRNO); 211 fileRNO = GNUNET_BIO_read_open (fileNameNO);
190 212 GNUNET_assert (NULL == fileRNO);
191 fileW = GNUNET_BIO_write_open (fileName); 213
192 GNUNET_assert (NULL != fileW); 214 fileW = GNUNET_BIO_write_open (fileName);
193 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write (fileW, TESTSTRING, 65537)); 215 GNUNET_assert (NULL != fileW);
194 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_string (fileW, TESTSTRING)); 216 GNUNET_assert (GNUNET_SYSERR ==
195 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_meta_data (fileW, metaDataW)); 217 GNUNET_BIO_write (fileW, TESTSTRING, 65537));
196 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW)); 218 GNUNET_assert (GNUNET_SYSERR ==
197 fileW = GNUNET_BIO_write_open (fileName); 219 GNUNET_BIO_write_string (fileW, TESTSTRING));
198 GNUNET_assert (NULL != fileW); 220 GNUNET_assert (GNUNET_SYSERR ==
199 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW)); 221 GNUNET_BIO_write_meta_data (fileW, metaDataW));
200 222 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
201 fileR = GNUNET_BIO_read_open (fileNameR); 223 fileW = GNUNET_BIO_write_open (fileName);
202 GNUNET_assert (NULL != fileR); 224 GNUNET_assert (NULL != fileW);
203 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read (fileR, "Read error", readResult, 65537)); 225 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW));
204 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); 226
205 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum)); 227 fileR = GNUNET_BIO_read_open (fileNameR);
206 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR)); 228 GNUNET_assert (NULL != fileR);
207 GNUNET_BIO_read_close (fileR, &msg); 229 GNUNET_assert (GNUNET_SYSERR ==
208 return 0; 230 GNUNET_BIO_read (fileR, "Read error", readResult, 65537));
231 GNUNET_assert (GNUNET_SYSERR ==
232 GNUNET_BIO_read_string (fileR, "Read string error",
233 &readResultString, 200));
234 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum));
235 GNUNET_assert (GNUNET_SYSERR ==
236 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
237 &metaDataR));
238 GNUNET_BIO_read_close (fileR, &msg);
239 return 0;
209} 240}
210 241
211static int 242static int
212test_fakestring_rw(void){ 243test_fakestring_rw (void)
213 char *msg; 244{
214 int32_t tmpInt = 2; 245 char *msg;
215 char *readResult; 246 int32_t tmpInt = 2;
216 struct GNUNET_BIO_WriteHandle *fileW; 247 char *readResult;
217 struct GNUNET_BIO_ReadHandle *fileR; 248 struct GNUNET_BIO_WriteHandle *fileW;
218 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 249 struct GNUNET_BIO_ReadHandle *fileR;
219 250 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
220 fileW = GNUNET_BIO_write_open (fileName); 251
221 GNUNET_assert (NULL != fileW); 252 fileW = GNUNET_BIO_write_open (fileName);
222 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt)); 253 GNUNET_assert (NULL != fileW);
223 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 254 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
224 255 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
225 fileR = GNUNET_BIO_read_open (fileName); 256
226 GNUNET_assert (NULL != fileR); 257 fileR = GNUNET_BIO_read_open (fileName);
227 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string(fileR, "Read string error", &readResult, 200)); 258 GNUNET_assert (NULL != fileR);
228 GNUNET_BIO_read_close (fileR, &msg); 259 GNUNET_assert (GNUNET_SYSERR ==
229 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 260 GNUNET_BIO_read_string (fileR, "Read string error",
230 GNUNET_free (fileName); 261 &readResult, 200));
231 return 0; 262 GNUNET_BIO_read_close (fileR, &msg);
263 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
264 GNUNET_free (fileName);
265 return 0;
232} 266}
233 267
234static int 268static int
235test_fakemeta_rw(void){ 269test_fakemeta_rw (void)
236 char *msg; 270{
237 int32_t tmpInt = 2; 271 char *msg;
238 struct GNUNET_BIO_WriteHandle *fileW; 272 int32_t tmpInt = 2;
239 struct GNUNET_BIO_ReadHandle *fileR; 273 struct GNUNET_BIO_WriteHandle *fileW;
240 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 274 struct GNUNET_BIO_ReadHandle *fileR;
241 struct GNUNET_CONTAINER_MetaData *metaDataR; 275 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
242 metaDataR = GNUNET_CONTAINER_meta_data_create (); 276 struct GNUNET_CONTAINER_MetaData *metaDataR;
243 277 metaDataR = GNUNET_CONTAINER_meta_data_create ();
244 fileW = GNUNET_BIO_write_open (fileName); 278
245 GNUNET_assert (NULL != fileW); 279 fileW = GNUNET_BIO_write_open (fileName);
246 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW,tmpInt)); 280 GNUNET_assert (NULL != fileW);
247 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 281 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
248 282 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
249 fileR = GNUNET_BIO_read_open (fileName); 283
250 GNUNET_assert (NULL != fileR); 284 fileR = GNUNET_BIO_read_open (fileName);
251 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR)); 285 GNUNET_assert (NULL != fileR);
252 GNUNET_BIO_read_close (fileR, &msg); 286 GNUNET_assert (GNUNET_SYSERR ==
253 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 287 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
254 GNUNET_free (fileName); 288 &metaDataR));
255 return 0; 289 GNUNET_BIO_read_close (fileR, &msg);
290 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
291 GNUNET_free (fileName);
292 return 0;
256} 293}
257 294
258static int 295static int
259test_fakebigmeta_rw(void){ 296test_fakebigmeta_rw (void)
260 char *msg; 297{
261 int32_t tmpInt = 1024*1024*10; 298 char *msg;
262 struct GNUNET_BIO_WriteHandle *fileW; 299 int32_t tmpInt = 1024 * 1024 * 10;
263 struct GNUNET_BIO_ReadHandle *fileR; 300 struct GNUNET_BIO_WriteHandle *fileW;
264 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 301 struct GNUNET_BIO_ReadHandle *fileR;
265 struct GNUNET_CONTAINER_MetaData *metaDataR; 302 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
266 metaDataR = GNUNET_CONTAINER_meta_data_create (); 303 struct GNUNET_CONTAINER_MetaData *metaDataR;
267 304 metaDataR = GNUNET_CONTAINER_meta_data_create ();
268 fileW = GNUNET_BIO_write_open (fileName); 305
269 GNUNET_assert (NULL != fileW); 306 fileW = GNUNET_BIO_write_open (fileName);
270 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt)); 307 GNUNET_assert (NULL != fileW);
271 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 308 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
272 309 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
273 fileR = GNUNET_BIO_read_open (fileName); 310
274 GNUNET_assert (NULL != fileR); 311 fileR = GNUNET_BIO_read_open (fileName);
275 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR)); 312 GNUNET_assert (NULL != fileR);
276 GNUNET_BIO_read_close (fileR, &msg); 313 GNUNET_assert (GNUNET_SYSERR ==
277 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 314 GNUNET_BIO_read_meta_data (fileR, "Read meta error",
278 GNUNET_free (fileName); 315 &metaDataR));
279 return 0; 316 GNUNET_BIO_read_close (fileR, &msg);
317 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
318 GNUNET_free (fileName);
319 return 0;
280} 320}
281 321
282static int 322static int
283check_string_rw(void){ 323check_string_rw (void)
284 GNUNET_assert (0 == test_nullstring_rw()); 324{
285 GNUNET_assert (0 == test_emptystring_rw()); 325 GNUNET_assert (0 == test_nullstring_rw ());
286 GNUNET_assert (0 == test_bigstring_rw()); 326 GNUNET_assert (0 == test_emptystring_rw ());
287 GNUNET_assert (0 == test_fakestring_rw()); 327 GNUNET_assert (0 == test_bigstring_rw ());
288 return 0; 328 GNUNET_assert (0 == test_fakestring_rw ());
329 return 0;
289} 330}
290 331
291static int 332static int
292check_metadata_rw(void){ 333check_metadata_rw (void)
293 GNUNET_assert (0 == test_fakebigmeta_rw()); 334{
294 GNUNET_assert (0 == test_fakemeta_rw()); 335 GNUNET_assert (0 == test_fakebigmeta_rw ());
295 GNUNET_assert (0 == test_bigmeta_rw()); 336 GNUNET_assert (0 == test_fakemeta_rw ());
296 return 0; 337 GNUNET_assert (0 == test_bigmeta_rw ());
338 return 0;
297} 339}
298 340
299static int 341static int
300check_file_rw(void){ 342check_file_rw (void)
301 GNUNET_assert (0 == test_normal_rw()); 343{
302 GNUNET_assert (0 == test_nullfile_rw()); 344 GNUNET_assert (0 == test_normal_rw ());
303 return 0; 345 GNUNET_assert (0 == test_nullfile_rw ());
346 return 0;
304} 347}
305 348
306int 349int
307main (int argc, char *argv[]){ 350main (int argc, char *argv[])
308 GNUNET_assert (0 == check_file_rw()); 351{
309 GNUNET_assert (0 == check_metadata_rw()); 352 GNUNET_assert (0 == check_file_rw ());
310 GNUNET_assert (0 == check_string_rw()); 353 GNUNET_assert (0 == check_metadata_rw ());
311 return 0; 354 GNUNET_assert (0 == check_string_rw ());
355 return 0;
312} /* end of main */ 356} /* end of main */
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-25 17:22:29 +0000