summaryrefslogtreecommitdiff
path: root/src/util/test_bio.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/util/test_bio.c')
-rw-r--r--src/util/test_bio.c436
1 files changed, 218 insertions, 218 deletions
diff --git a/src/util/test_bio.c b/src/util/test_bio.c
index 719f622ba..c8887e246 100644
--- a/src/util/test_bio.c
+++ b/src/util/test_bio.c
@@ -11,12 +11,12 @@
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 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/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19*/ 19 */
20 20
21/** 21/**
22 * @file util/test_bio.c 22 * @file util/test_bio.c
@@ -31,212 +31,212 @@
31#define TESTNUMBER64 ((int64_t)100000L) 31#define TESTNUMBER64 ((int64_t)100000L)
32 32
33static int 33static int
34test_normal_rw () 34test_normal_rw()
35{ 35{
36 char *msg; 36 char *msg;
37 int64_t testNum; 37 int64_t testNum;
38 char *readResultString; 38 char *readResultString;
39 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 39 char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
40 struct GNUNET_BIO_WriteHandle *fileW; 40 struct GNUNET_BIO_WriteHandle *fileW;
41 struct GNUNET_BIO_ReadHandle *fileR; 41 struct GNUNET_BIO_ReadHandle *fileR;
42 struct GNUNET_CONTAINER_MetaData *metaDataW; 42 struct GNUNET_CONTAINER_MetaData *metaDataW;
43 struct GNUNET_CONTAINER_MetaData *metaDataR; 43 struct GNUNET_CONTAINER_MetaData *metaDataR;
44 44
45 metaDataW = GNUNET_CONTAINER_meta_data_create (); 45 metaDataW = GNUNET_CONTAINER_meta_data_create();
46 metaDataR = NULL; 46 metaDataR = NULL;
47 GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); 47 GNUNET_CONTAINER_meta_data_add_publication_date(metaDataW);
48 48
49 fileW = GNUNET_BIO_write_open (fileName); 49 fileW = GNUNET_BIO_write_open(fileName);
50 GNUNET_assert (NULL != fileW); 50 GNUNET_assert(NULL != fileW);
51 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); 51 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW, TESTSTRING));
52 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW)); 52 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_meta_data(fileW, metaDataW));
53 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, TESTNUMBER64)); 53 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int64(fileW, TESTNUMBER64));
54 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 54 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
55 55
56 fileR = GNUNET_BIO_read_open (fileName); 56 fileR = GNUNET_BIO_read_open(fileName);
57 GNUNET_assert (NULL != fileR); 57 GNUNET_assert(NULL != fileR);
58 readResultString = NULL; 58 readResultString = NULL;
59 GNUNET_assert (GNUNET_OK == 59 GNUNET_assert(GNUNET_OK ==
60 GNUNET_BIO_read_string (fileR, "Read string error", 60 GNUNET_BIO_read_string(fileR, "Read string error",
61 &readResultString, 200)); 61 &readResultString, 200));
62 GNUNET_assert (NULL != readResultString); 62 GNUNET_assert(NULL != readResultString);
63 GNUNET_assert (0 == strcmp (TESTSTRING, readResultString)); 63 GNUNET_assert(0 == strcmp(TESTSTRING, readResultString));
64 GNUNET_free (readResultString); 64 GNUNET_free(readResultString);
65 GNUNET_assert (GNUNET_OK == 65 GNUNET_assert(GNUNET_OK ==
66 GNUNET_BIO_read_meta_data (fileR, "Read meta error", 66 GNUNET_BIO_read_meta_data(fileR, "Read meta error",
67 &metaDataR)); 67 &metaDataR));
68 GNUNET_assert (GNUNET_YES == 68 GNUNET_assert(GNUNET_YES ==
69 GNUNET_CONTAINER_meta_data_test_equal (metaDataR, metaDataW)); 69 GNUNET_CONTAINER_meta_data_test_equal(metaDataR, metaDataW));
70 GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum)); 70 GNUNET_assert(GNUNET_OK == GNUNET_BIO_read_int64(fileR, &testNum));
71 GNUNET_BIO_read_close (fileR, &msg); 71 GNUNET_BIO_read_close(fileR, &msg);
72 GNUNET_CONTAINER_meta_data_destroy (metaDataW); 72 GNUNET_CONTAINER_meta_data_destroy(metaDataW);
73 GNUNET_CONTAINER_meta_data_destroy (metaDataR); 73 GNUNET_CONTAINER_meta_data_destroy(metaDataR);
74 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 74 GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
75 GNUNET_free (fileName); 75 GNUNET_free(fileName);
76 return 0; 76 return 0;
77} 77}
78 78
79static int 79static int
80test_nullstring_rw () 80test_nullstring_rw()
81{ 81{
82 char *msg; 82 char *msg;
83 char *readResultString = (char *) "not null"; 83 char *readResultString = (char *)"not null";
84 struct GNUNET_BIO_WriteHandle *fileW; 84 struct GNUNET_BIO_WriteHandle *fileW;
85 struct GNUNET_BIO_ReadHandle *fileR; 85 struct GNUNET_BIO_ReadHandle *fileR;
86 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 86 char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
87 87
88 fileW = GNUNET_BIO_write_open (fileName); 88 fileW = GNUNET_BIO_write_open(fileName);
89 GNUNET_assert (NULL != fileW); 89 GNUNET_assert(NULL != fileW);
90 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL)); 90 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW, NULL));
91 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 91 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
92 92
93 fileR = GNUNET_BIO_read_open (fileName); 93 fileR = GNUNET_BIO_read_open(fileName);
94 GNUNET_assert (NULL != fileR); 94 GNUNET_assert(NULL != fileR);
95 GNUNET_assert (GNUNET_OK == 95 GNUNET_assert(GNUNET_OK ==
96 GNUNET_BIO_read_string (fileR, "Read string error", 96 GNUNET_BIO_read_string(fileR, "Read string error",
97 &readResultString, 200)); 97 &readResultString, 200));
98 GNUNET_assert (NULL == readResultString); 98 GNUNET_assert(NULL == readResultString);
99 GNUNET_BIO_read_close (fileR, &msg); 99 GNUNET_BIO_read_close(fileR, &msg);
100 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 100 GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
101 GNUNET_free (fileName); 101 GNUNET_free(fileName);
102 102
103 return 0; 103 return 0;
104} 104}
105 105
106static int 106static int
107test_emptystring_rw () 107test_emptystring_rw()
108{ 108{
109 char *msg; 109 char *msg;
110 char *readResultString; 110 char *readResultString;
111 struct GNUNET_BIO_WriteHandle *fileW; 111 struct GNUNET_BIO_WriteHandle *fileW;
112 struct GNUNET_BIO_ReadHandle *fileR; 112 struct GNUNET_BIO_ReadHandle *fileR;
113 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 113 char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
114 114
115 fileW = GNUNET_BIO_write_open (fileName); 115 fileW = GNUNET_BIO_write_open(fileName);
116 GNUNET_assert (NULL != fileW); 116 GNUNET_assert(NULL != fileW);
117 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, "")); 117 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW, ""));
118 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 118 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
119 119
120 fileR = GNUNET_BIO_read_open (fileName); 120 fileR = GNUNET_BIO_read_open(fileName);
121 GNUNET_assert (NULL != fileR); 121 GNUNET_assert(NULL != fileR);
122 readResultString = NULL; 122 readResultString = NULL;
123 GNUNET_assert (GNUNET_OK == 123 GNUNET_assert(GNUNET_OK ==
124 GNUNET_BIO_read_string (fileR, "Read string error", 124 GNUNET_BIO_read_string(fileR, "Read string error",
125 &readResultString, 200)); 125 &readResultString, 200));
126 GNUNET_free (readResultString); 126 GNUNET_free(readResultString);
127 GNUNET_BIO_read_close (fileR, &msg); 127 GNUNET_BIO_read_close(fileR, &msg);
128 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 128 GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
129 GNUNET_free (fileName); 129 GNUNET_free(fileName);
130 return 0; 130 return 0;
131} 131}
132 132
133static int 133static int
134test_bigstring_rw () 134test_bigstring_rw()
135{ 135{
136 char *msg; 136 char *msg;
137 char *readResultString; 137 char *readResultString;
138 struct GNUNET_BIO_WriteHandle *fileW; 138 struct GNUNET_BIO_WriteHandle *fileW;
139 struct GNUNET_BIO_ReadHandle *fileR; 139 struct GNUNET_BIO_ReadHandle *fileR;
140 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 140 char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
141 141
142 fileW = GNUNET_BIO_write_open (fileName); 142 fileW = GNUNET_BIO_write_open(fileName);
143 GNUNET_assert (NULL != fileW); 143 GNUNET_assert(NULL != fileW);
144 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); 144 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_string(fileW, TESTSTRING));
145 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 145 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
146 146
147 fileR = GNUNET_BIO_read_open (fileName); 147 fileR = GNUNET_BIO_read_open(fileName);
148 GNUNET_assert (NULL != fileR); 148 GNUNET_assert(NULL != fileR);
149 readResultString = NULL; 149 readResultString = NULL;
150 GNUNET_assert (GNUNET_SYSERR == 150 GNUNET_assert(GNUNET_SYSERR ==
151 GNUNET_BIO_read_string (fileR, "Read string error", 151 GNUNET_BIO_read_string(fileR, "Read string error",
152 &readResultString, 1)); 152 &readResultString, 1));
153 GNUNET_assert (NULL == readResultString); 153 GNUNET_assert(NULL == readResultString);
154 msg = NULL; 154 msg = NULL;
155 GNUNET_BIO_read_close (fileR, &msg); 155 GNUNET_BIO_read_close(fileR, &msg);
156 GNUNET_free (msg); 156 GNUNET_free(msg);
157 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 157 GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
158 GNUNET_free (fileName); 158 GNUNET_free(fileName);
159 return 0; 159 return 0;
160} 160}
161 161
162static int 162static int
163test_bigmeta_rw () 163test_bigmeta_rw()
164{ 164{
165 char *msg; 165 char *msg;
166 static char meta[1024 * 1024 * 10]; 166 static char meta[1024 * 1024 * 10];
167 struct GNUNET_BIO_WriteHandle *fileW; 167 struct GNUNET_BIO_WriteHandle *fileW;
168 struct GNUNET_BIO_ReadHandle *fileR; 168 struct GNUNET_BIO_ReadHandle *fileR;
169 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 169 char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
170 struct GNUNET_CONTAINER_MetaData *metaDataR; 170 struct GNUNET_CONTAINER_MetaData *metaDataR;
171 171
172 memset (meta, 'b', sizeof (meta)); 172 memset(meta, 'b', sizeof(meta));
173 meta[sizeof (meta) - 1] = '\0'; 173 meta[sizeof(meta) - 1] = '\0';
174 fileW = GNUNET_BIO_write_open (fileName); 174 fileW = GNUNET_BIO_write_open(fileName);
175 GNUNET_assert (NULL != fileW); 175 GNUNET_assert(NULL != fileW);
176 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, sizeof (meta))); 176 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int32(fileW, sizeof(meta)));
177 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write (fileW, meta, sizeof (meta))); 177 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write(fileW, meta, sizeof(meta)));
178 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 178 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
179 179
180 fileR = GNUNET_BIO_read_open (fileName); 180 fileR = GNUNET_BIO_read_open(fileName);
181 GNUNET_assert (NULL != fileR); 181 GNUNET_assert(NULL != fileR);
182 metaDataR = NULL; 182 metaDataR = NULL;
183 GNUNET_assert (GNUNET_SYSERR == 183 GNUNET_assert(GNUNET_SYSERR ==
184 GNUNET_BIO_read_meta_data (fileR, "Read meta error", 184 GNUNET_BIO_read_meta_data(fileR, "Read meta error",
185 &metaDataR)); 185 &metaDataR));
186 msg = NULL; 186 msg = NULL;
187 GNUNET_BIO_read_close (fileR, &msg); 187 GNUNET_BIO_read_close(fileR, &msg);
188 GNUNET_free (msg); 188 GNUNET_free(msg);
189 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 189 GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
190 GNUNET_assert (NULL == metaDataR); 190 GNUNET_assert(NULL == metaDataR);
191 GNUNET_free (fileName); 191 GNUNET_free(fileName);
192 return 0; 192 return 0;
193} 193}
194 194
195static int 195static int
196test_directory_r () 196test_directory_r()
197{ 197{
198#if LINUX 198#if LINUX
199 char *msg; 199 char *msg;
200 char readResult[200]; 200 char readResult[200];
201 struct GNUNET_BIO_ReadHandle *fileR; 201 struct GNUNET_BIO_ReadHandle *fileR;
202 202
203 fileR = GNUNET_BIO_read_open ("/dev"); 203 fileR = GNUNET_BIO_read_open("/dev");
204 GNUNET_assert (NULL != fileR); 204 GNUNET_assert(NULL != fileR);
205 GNUNET_assert (GNUNET_SYSERR == 205 GNUNET_assert(GNUNET_SYSERR ==
206 GNUNET_BIO_read (fileR, "Read error", readResult, 206 GNUNET_BIO_read(fileR, "Read error", readResult,
207 sizeof (readResult))); 207 sizeof(readResult)));
208 msg = NULL; 208 msg = NULL;
209 GNUNET_BIO_read_close (fileR, &msg); 209 GNUNET_BIO_read_close(fileR, &msg);
210 GNUNET_free (msg); 210 GNUNET_free(msg);
211#endif 211#endif
212 return 0; 212 return 0;
213} 213}
214 214
215static int 215static int
216test_nullfile_rw () 216test_nullfile_rw()
217{ 217{
218 static char fileNameNO[102401]; 218 static char fileNameNO[102401];
219 struct GNUNET_BIO_WriteHandle *fileWNO; 219 struct GNUNET_BIO_WriteHandle *fileWNO;
220 struct GNUNET_BIO_ReadHandle *fileRNO; 220 struct GNUNET_BIO_ReadHandle *fileRNO;
221 221
222 memset (fileNameNO, 'a', sizeof (fileNameNO)); 222 memset(fileNameNO, 'a', sizeof(fileNameNO));
223 fileNameNO[sizeof (fileNameNO) - 1] = '\0'; 223 fileNameNO[sizeof(fileNameNO) - 1] = '\0';
224 224
225 GNUNET_log_skip (1, GNUNET_NO); 225 GNUNET_log_skip(1, GNUNET_NO);
226 fileWNO = GNUNET_BIO_write_open (fileNameNO); 226 fileWNO = GNUNET_BIO_write_open(fileNameNO);
227 GNUNET_log_skip (0, GNUNET_YES); 227 GNUNET_log_skip(0, GNUNET_YES);
228 GNUNET_assert (NULL == fileWNO); 228 GNUNET_assert(NULL == fileWNO);
229 229
230 GNUNET_log_skip (1, GNUNET_NO); 230 GNUNET_log_skip(1, GNUNET_NO);
231 fileRNO = GNUNET_BIO_read_open (fileNameNO); 231 fileRNO = GNUNET_BIO_read_open(fileNameNO);
232 GNUNET_log_skip (0, GNUNET_YES); 232 GNUNET_log_skip(0, GNUNET_YES);
233 GNUNET_assert (NULL == fileRNO); 233 GNUNET_assert(NULL == fileRNO);
234 return 0; 234 return 0;
235} 235}
236 236
237 237
238static int 238static int
239test_fullfile_rw () 239test_fullfile_rw()
240{ 240{
241#ifdef LINUX 241#ifdef LINUX
242 /* /dev/full only seems to exist on Linux */ 242 /* /dev/full only seems to exist on Linux */
@@ -249,168 +249,168 @@ test_fullfile_rw ()
249 struct GNUNET_CONTAINER_MetaData *metaDataW; 249 struct GNUNET_CONTAINER_MetaData *metaDataW;
250 struct GNUNET_CONTAINER_MetaData *metaDataR; 250 struct GNUNET_CONTAINER_MetaData *metaDataR;
251 251
252 metaDataW = GNUNET_CONTAINER_meta_data_create (); 252 metaDataW = GNUNET_CONTAINER_meta_data_create();
253 GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); 253 GNUNET_CONTAINER_meta_data_add_publication_date(metaDataW);
254 254
255 fileW = GNUNET_BIO_write_open ("/dev/full"); 255 fileW = GNUNET_BIO_write_open("/dev/full");
256 GNUNET_assert (NULL != fileW); 256 GNUNET_assert(NULL != fileW);
257 (void) GNUNET_BIO_write (fileW, TESTSTRING, strlen (TESTSTRING)); 257 (void)GNUNET_BIO_write(fileW, TESTSTRING, strlen(TESTSTRING));
258 (void) GNUNET_BIO_write_string (fileW, TESTSTRING); 258 (void)GNUNET_BIO_write_string(fileW, TESTSTRING);
259 (void) GNUNET_BIO_write_meta_data (fileW, metaDataW); 259 (void)GNUNET_BIO_write_meta_data(fileW, metaDataW);
260 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW)); 260 GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_write_close(fileW));
261 GNUNET_CONTAINER_meta_data_destroy (metaDataW); 261 GNUNET_CONTAINER_meta_data_destroy(metaDataW);
262 262
263 fileW = GNUNET_BIO_write_open ("/dev/full"); 263 fileW = GNUNET_BIO_write_open("/dev/full");
264 GNUNET_assert (NULL != fileW); 264 GNUNET_assert(NULL != fileW);
265 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW)); 265 GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_write_close(fileW));
266 266
267 fileR = GNUNET_BIO_read_open ("/dev/null"); 267 fileR = GNUNET_BIO_read_open("/dev/null");
268 GNUNET_assert (NULL != fileR); 268 GNUNET_assert(NULL != fileR);
269 GNUNET_assert (GNUNET_SYSERR == 269 GNUNET_assert(GNUNET_SYSERR ==
270 GNUNET_BIO_read (fileR, "Read error", readResult, 270 GNUNET_BIO_read(fileR, "Read error", readResult,
271 sizeof (readResult))); 271 sizeof(readResult)));
272 readResultString = NULL; 272 readResultString = NULL;
273 GNUNET_assert (GNUNET_SYSERR == 273 GNUNET_assert(GNUNET_SYSERR ==
274 GNUNET_BIO_read_string (fileR, "Read string error", 274 GNUNET_BIO_read_string(fileR, "Read string error",
275 &readResultString, 200)); 275 &readResultString, 200));
276 GNUNET_assert (NULL == readResultString); 276 GNUNET_assert(NULL == readResultString);
277 GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum)); 277 GNUNET_assert(GNUNET_SYSERR == GNUNET_BIO_read_int64(fileR, &testNum));
278 metaDataR = NULL; 278 metaDataR = NULL;
279 GNUNET_assert (GNUNET_SYSERR == 279 GNUNET_assert(GNUNET_SYSERR ==
280 GNUNET_BIO_read_meta_data (fileR, "Read meta error", 280 GNUNET_BIO_read_meta_data(fileR, "Read meta error",
281 &metaDataR)); 281 &metaDataR));
282 msg = NULL; 282 msg = NULL;
283 GNUNET_BIO_read_close (fileR, &msg); 283 GNUNET_BIO_read_close(fileR, &msg);
284 GNUNET_free (msg); 284 GNUNET_free(msg);
285 GNUNET_assert (NULL == metaDataR); 285 GNUNET_assert(NULL == metaDataR);
286#endif 286#endif
287 return 0; 287 return 0;
288} 288}
289 289
290static int 290static int
291test_fakestring_rw () 291test_fakestring_rw()
292{ 292{
293 char *msg; 293 char *msg;
294 int32_t tmpInt = 2; 294 int32_t tmpInt = 2;
295 char *readResult; 295 char *readResult;
296 struct GNUNET_BIO_WriteHandle *fileW; 296 struct GNUNET_BIO_WriteHandle *fileW;
297 struct GNUNET_BIO_ReadHandle *fileR; 297 struct GNUNET_BIO_ReadHandle *fileR;
298 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 298 char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
299 299
300 fileW = GNUNET_BIO_write_open (fileName); 300 fileW = GNUNET_BIO_write_open(fileName);
301 GNUNET_assert (NULL != fileW); 301 GNUNET_assert(NULL != fileW);
302 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt)); 302 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
303 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 303 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
304 304
305 fileR = GNUNET_BIO_read_open (fileName); 305 fileR = GNUNET_BIO_read_open(fileName);
306 GNUNET_assert (NULL != fileR); 306 GNUNET_assert(NULL != fileR);
307 GNUNET_assert (GNUNET_SYSERR == 307 GNUNET_assert(GNUNET_SYSERR ==
308 GNUNET_BIO_read_string (fileR, "Read string error", 308 GNUNET_BIO_read_string(fileR, "Read string error",
309 &readResult, 200)); 309 &readResult, 200));
310 msg = NULL; 310 msg = NULL;
311 GNUNET_BIO_read_close (fileR, &msg); 311 GNUNET_BIO_read_close(fileR, &msg);
312 GNUNET_free (msg); 312 GNUNET_free(msg);
313 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 313 GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
314 GNUNET_free (fileName); 314 GNUNET_free(fileName);
315 return 0; 315 return 0;
316} 316}
317 317
318static int 318static int
319test_fakemeta_rw () 319test_fakemeta_rw()
320{ 320{
321 char *msg; 321 char *msg;
322 int32_t tmpInt = 2; 322 int32_t tmpInt = 2;
323 struct GNUNET_BIO_WriteHandle *fileW; 323 struct GNUNET_BIO_WriteHandle *fileW;
324 struct GNUNET_BIO_ReadHandle *fileR; 324 struct GNUNET_BIO_ReadHandle *fileR;
325 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 325 char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
326 struct GNUNET_CONTAINER_MetaData *metaDataR; 326 struct GNUNET_CONTAINER_MetaData *metaDataR;
327 327
328 fileW = GNUNET_BIO_write_open (fileName); 328 fileW = GNUNET_BIO_write_open(fileName);
329 GNUNET_assert (NULL != fileW); 329 GNUNET_assert(NULL != fileW);
330 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt)); 330 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
331 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 331 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
332 332
333 fileR = GNUNET_BIO_read_open (fileName); 333 fileR = GNUNET_BIO_read_open(fileName);
334 GNUNET_assert (NULL != fileR); 334 GNUNET_assert(NULL != fileR);
335 metaDataR = NULL; 335 metaDataR = NULL;
336 GNUNET_assert (GNUNET_SYSERR == 336 GNUNET_assert(GNUNET_SYSERR ==
337 GNUNET_BIO_read_meta_data (fileR, "Read meta error", 337 GNUNET_BIO_read_meta_data(fileR, "Read meta error",
338 &metaDataR)); 338 &metaDataR));
339 GNUNET_assert (NULL == metaDataR); 339 GNUNET_assert(NULL == metaDataR);
340 msg = NULL; 340 msg = NULL;
341 GNUNET_BIO_read_close (fileR, &msg); 341 GNUNET_BIO_read_close(fileR, &msg);
342 GNUNET_free (msg); 342 GNUNET_free(msg);
343 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 343 GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
344 GNUNET_free (fileName); 344 GNUNET_free(fileName);
345 return 0; 345 return 0;
346} 346}
347 347
348static int 348static int
349test_fakebigmeta_rw () 349test_fakebigmeta_rw()
350{ 350{
351 char *msg; 351 char *msg;
352 int32_t tmpInt = 1024 * 1024 * 10; 352 int32_t tmpInt = 1024 * 1024 * 10;
353 struct GNUNET_BIO_WriteHandle *fileW; 353 struct GNUNET_BIO_WriteHandle *fileW;
354 struct GNUNET_BIO_ReadHandle *fileR; 354 struct GNUNET_BIO_ReadHandle *fileR;
355 char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); 355 char *fileName = GNUNET_DISK_mktemp("gnunet_bio");
356 struct GNUNET_CONTAINER_MetaData *metaDataR; 356 struct GNUNET_CONTAINER_MetaData *metaDataR;
357 357
358 fileW = GNUNET_BIO_write_open (fileName); 358 fileW = GNUNET_BIO_write_open(fileName);
359 GNUNET_assert (NULL != fileW); 359 GNUNET_assert(NULL != fileW);
360 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt)); 360 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt));
361 GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); 361 GNUNET_assert(GNUNET_OK == GNUNET_BIO_write_close(fileW));
362 362
363 fileR = GNUNET_BIO_read_open (fileName); 363 fileR = GNUNET_BIO_read_open(fileName);
364 GNUNET_assert (NULL != fileR); 364 GNUNET_assert(NULL != fileR);
365 metaDataR = NULL; 365 metaDataR = NULL;
366 GNUNET_assert (GNUNET_SYSERR == 366 GNUNET_assert(GNUNET_SYSERR ==
367 GNUNET_BIO_read_meta_data (fileR, "Read meta error", 367 GNUNET_BIO_read_meta_data(fileR, "Read meta error",
368 &metaDataR)); 368 &metaDataR));
369 msg = NULL; 369 msg = NULL;
370 GNUNET_BIO_read_close (fileR, &msg); 370 GNUNET_BIO_read_close(fileR, &msg);
371 GNUNET_free (msg); 371 GNUNET_free(msg);
372 GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); 372 GNUNET_assert(GNUNET_OK == GNUNET_DISK_directory_remove(fileName));
373 GNUNET_assert (NULL == metaDataR); 373 GNUNET_assert(NULL == metaDataR);
374 GNUNET_free (fileName); 374 GNUNET_free(fileName);
375 return 0; 375 return 0;
376} 376}
377 377
378static int 378static int
379check_string_rw () 379check_string_rw()
380{ 380{
381 GNUNET_assert (0 == test_nullstring_rw ()); 381 GNUNET_assert(0 == test_nullstring_rw());
382 GNUNET_assert (0 == test_emptystring_rw ()); 382 GNUNET_assert(0 == test_emptystring_rw());
383 GNUNET_assert (0 == test_bigstring_rw ()); 383 GNUNET_assert(0 == test_bigstring_rw());
384 GNUNET_assert (0 == test_fakestring_rw ()); 384 GNUNET_assert(0 == test_fakestring_rw());
385 return 0; 385 return 0;
386} 386}
387 387
388static int 388static int
389check_metadata_rw () 389check_metadata_rw()
390{ 390{
391 GNUNET_assert (0 == test_fakebigmeta_rw ()); 391 GNUNET_assert(0 == test_fakebigmeta_rw());
392 GNUNET_assert (0 == test_fakemeta_rw ()); 392 GNUNET_assert(0 == test_fakemeta_rw());
393 GNUNET_assert (0 == test_bigmeta_rw ()); 393 GNUNET_assert(0 == test_bigmeta_rw());
394 return 0; 394 return 0;
395} 395}
396 396
397static int 397static int
398check_file_rw () 398check_file_rw()
399{ 399{
400 GNUNET_assert (0 == test_normal_rw ()); 400 GNUNET_assert(0 == test_normal_rw());
401 GNUNET_assert (0 == test_nullfile_rw ()); 401 GNUNET_assert(0 == test_nullfile_rw());
402 GNUNET_assert (0 == test_fullfile_rw ()); 402 GNUNET_assert(0 == test_fullfile_rw());
403 GNUNET_assert (0 == test_directory_r ()); 403 GNUNET_assert(0 == test_directory_r());
404 return 0; 404 return 0;
405} 405}
406 406
407int 407int
408main (int argc, char *argv[]) 408main(int argc, char *argv[])
409{ 409{
410 GNUNET_log_setup ("test-bio", "WARNING", NULL); 410 GNUNET_log_setup("test-bio", "WARNING", NULL);
411 GNUNET_assert (0 == check_file_rw ()); 411 GNUNET_assert(0 == check_file_rw());
412 GNUNET_assert (0 == check_metadata_rw ()); 412 GNUNET_assert(0 == check_metadata_rw());
413 GNUNET_assert (0 == check_string_rw ()); 413 GNUNET_assert(0 == check_string_rw());
414 return 0; 414 return 0;
415} 415}
416 416
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-20 00:58:16 +0000