diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/util/test_bio.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/util/test_bio.c')
-rw-r--r-- | src/util/test_bio.c | 432 |
1 files changed, 216 insertions, 216 deletions
diff --git a/src/util/test_bio.c b/src/util/test_bio.c index c8887e246..180cada76 100644 --- a/src/util/test_bio.c +++ b/src/util/test_bio.c | |||
@@ -28,215 +28,215 @@ | |||
28 | #include "platform.h" | 28 | #include "platform.h" |
29 | #include "gnunet_util_lib.h" | 29 | #include "gnunet_util_lib.h" |
30 | #define TESTSTRING "testString" | 30 | #define TESTSTRING "testString" |
31 | #define TESTNUMBER64 ((int64_t)100000L) | 31 | #define TESTNUMBER64 ((int64_t) 100000L) |
32 | 32 | ||
33 | static int | 33 | static int |
34 | test_normal_rw() | 34 | test_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 | ||
79 | static int | 79 | static int |
80 | test_nullstring_rw() | 80 | test_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 | ||
106 | static int | 106 | static int |
107 | test_emptystring_rw() | 107 | test_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 | ||
133 | static int | 133 | static int |
134 | test_bigstring_rw() | 134 | test_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 | ||
162 | static int | 162 | static int |
163 | test_bigmeta_rw() | 163 | test_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 | ||
195 | static int | 195 | static int |
196 | test_directory_r() | 196 | test_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 | ||
215 | static int | 215 | static int |
216 | test_nullfile_rw() | 216 | test_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 | ||
238 | static int | 238 | static int |
239 | test_fullfile_rw() | 239 | test_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 | ||
290 | static int | 290 | static int |
291 | test_fakestring_rw() | 291 | test_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 | ||
318 | static int | 318 | static int |
319 | test_fakemeta_rw() | 319 | test_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 | ||
348 | static int | 348 | static int |
349 | test_fakebigmeta_rw() | 349 | test_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 | ||
378 | static int | 378 | static int |
379 | check_string_rw() | 379 | check_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 | ||
388 | static int | 388 | static int |
389 | check_metadata_rw() | 389 | check_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 | ||
397 | static int | 397 | static int |
398 | check_file_rw() | 398 | check_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 | ||
407 | int | 407 | int |
408 | main(int argc, char *argv[]) | 408 | main (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 | ||