diff options
author | Ji Lu <jilu@140774ce-b5e7-0310-ab8b-a85725594a96> | 2009-11-08 00:08:58 +0000 |
---|---|---|
committer | Ji Lu <jilu@140774ce-b5e7-0310-ab8b-a85725594a96> | 2009-11-08 00:08:58 +0000 |
commit | 1c77704470683ebcb42b8dd0b7290018fb6340bf (patch) | |
tree | c1ac39a0e62feaa8fe0d42ba2a24d3ffa9106f37 /src/util/test_bio.c | |
parent | 410796aa0383385cbb0d12d17d56d69ee15d0497 (diff) | |
download | gnunet-1c77704470683ebcb42b8dd0b7290018fb6340bf.tar.gz gnunet-1c77704470683ebcb42b8dd0b7290018fb6340bf.zip |
fixed test_bio.c
Diffstat (limited to 'src/util/test_bio.c')
-rw-r--r-- | src/util/test_bio.c | 404 |
1 files changed, 278 insertions, 126 deletions
diff --git a/src/util/test_bio.c b/src/util/test_bio.c index e18b0d307..883424207 100644 --- a/src/util/test_bio.c +++ b/src/util/test_bio.c | |||
@@ -30,131 +30,283 @@ | |||
30 | #define TESTSTRING "testString" | 30 | #define TESTSTRING "testString" |
31 | #define TESTNUMBER64 100000L | 31 | #define TESTNUMBER64 100000L |
32 | 32 | ||
33 | int | 33 | static int |
34 | main (int argc, char *argv[]) | 34 | test_normal_rw(void){ |
35 | { | 35 | char *msg; |
36 | #if 0 | 36 | int64_t testNum; |
37 | char *readResultString; | 37 | char *readResultString; |
38 | int64_t testNumber = (int64_t) TESTNUMBER64; | 38 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); |
39 | int64_t testNum; | 39 | struct GNUNET_BIO_WriteHandle *fileW; |
40 | char *msg; | 40 | struct GNUNET_BIO_ReadHandle *fileR; |
41 | static char file[102400]; | 41 | struct GNUNET_CONTAINER_MetaData *metaDataW; |
42 | static char meta[1024 * 1024 * 10]; | 42 | struct GNUNET_CONTAINER_MetaData *metaDataR; |
43 | int i, j; | 43 | metaDataW = GNUNET_CONTAINER_meta_data_create (); |
44 | for (i = 0; i < 102400; i++) | 44 | metaDataR = GNUNET_CONTAINER_meta_data_create (); |
45 | { | 45 | GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); |
46 | file[i] = 'a'; | 46 | |
47 | } | 47 | fileW = GNUNET_BIO_write_open (fileName); |
48 | for (j = 0; j < 1024 * 1024 * 10; j++) | 48 | GNUNET_assert (NULL != fileW); |
49 | { | 49 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); |
50 | meta[j] = 'b'; | 50 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW)); |
51 | } | 51 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, (int64_t)TESTNUMBER64)); |
52 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | 52 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); |
53 | char *fileName2 = GNUNET_DISK_mktemp ("gnunet_zwei_bio"); | 53 | |
54 | char *fileName3 = GNUNET_DISK_mktemp ("gnunet_drei_bio"); | 54 | fileR = GNUNET_BIO_read_open (fileName); |
55 | char *fileName4 = GNUNET_DISK_mktemp ("gnunet_vier_bio"); | 55 | GNUNET_assert (NULL != fileR); |
56 | 56 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); | |
57 | struct GNUNET_BIO_ReadHandle *fileR, *fileR2, *fileR3, *fileR4; | 57 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR)); |
58 | struct GNUNET_BIO_WriteHandle *fileW, *fileW2, *fileW3, *fileW4; | 58 | GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_meta_data_test_equal (metaDataR, metaDataW)); |
59 | struct GNUNET_CONTAINER_MetaData *metaDataW; | 59 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum)); |
60 | struct GNUNET_CONTAINER_MetaData *metaDataR; | 60 | GNUNET_BIO_read_close (fileR, &msg); |
61 | struct GNUNET_BIO_ReadHandle *fileRNO; | 61 | GNUNET_CONTAINER_meta_data_destroy (metaDataW); |
62 | struct GNUNET_BIO_WriteHandle *fileWNO; | 62 | GNUNET_CONTAINER_meta_data_destroy (metaDataR); |
63 | struct GNUNET_CONTAINER_MetaData *metaData; | 63 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); |
64 | struct GNUNET_CONTAINER_MetaData *metaDataNO; | 64 | GNUNET_free (fileName); |
65 | 65 | return 0; | |
66 | metaData = GNUNET_CONTAINER_meta_data_create (); | 66 | } |
67 | metaDataNO = GNUNET_CONTAINER_meta_data_create (); | 67 | |
68 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | 68 | static int |
69 | metaDataW = GNUNET_CONTAINER_meta_data_create (); | 69 | test_nullstring_rw(){ |
70 | GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); | 70 | char *msg; |
71 | GNUNET_CONTAINER_meta_data_add_publication_date (metaData); | 71 | char *readResultString = (char*) "not null"; |
72 | GNUNET_assert (GNUNET_OK == | 72 | struct GNUNET_BIO_WriteHandle *fileW; |
73 | GNUNET_CONTAINER_meta_data_insert (metaData, | 73 | struct GNUNET_BIO_ReadHandle *fileR; |
74 | EXTRACTOR_COMMENT, meta)); | 74 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); |
75 | 75 | ||
76 | ///////////write | 76 | fileW = GNUNET_BIO_write_open (fileName); |
77 | fileW = GNUNET_BIO_write_open (fileName); | 77 | GNUNET_assert (NULL != fileW); |
78 | GNUNET_assert (NULL != fileW); | 78 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL)); |
79 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); | 79 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); |
80 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW)); | 80 | |
81 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, testNumber)); | 81 | fileR = GNUNET_BIO_read_open (fileName); |
82 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | 82 | GNUNET_assert (NULL != fileR); |
83 | fileW2 = GNUNET_BIO_write_open (fileName2); | 83 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); |
84 | GNUNET_assert (NULL != fileW2); | 84 | GNUNET_assert (NULL == readResultString); |
85 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW2, NULL)); | 85 | GNUNET_BIO_read_close (fileR, &msg); |
86 | fileWNO = GNUNET_BIO_write_open (file); | 86 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); |
87 | GNUNET_assert (NULL != fileWNO); | 87 | GNUNET_free (fileName); |
88 | GNUNET_assert (GNUNET_SYSERR == | 88 | |
89 | GNUNET_BIO_write_string (fileWNO, TESTSTRING)); | 89 | return 0; |
90 | GNUNET_assert (GNUNET_SYSERR == | 90 | } |
91 | GNUNET_BIO_write_meta_data (fileWNO, metaDataW)); | 91 | |
92 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileWNO)); | 92 | static int |
93 | fileW3 = GNUNET_BIO_write_open (fileName3); | 93 | test_emptystring_rw(void){ |
94 | GNUNET_assert (NULL != fileW3); | 94 | char *msg; |
95 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW3, metaData)); | 95 | char *readResultString; |
96 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW3)); | 96 | struct GNUNET_BIO_WriteHandle *fileW; |
97 | fileW4 = GNUNET_BIO_write_open (fileName4); | 97 | struct GNUNET_BIO_ReadHandle *fileR; |
98 | GNUNET_assert (NULL != fileW4); | 98 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); |
99 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW4, "")); | 99 | |
100 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW4)); | 100 | fileW = GNUNET_BIO_write_open (fileName); |
101 | 101 | GNUNET_assert (NULL != fileW); | |
102 | ////////////read | 102 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, "")); |
103 | fileRNO = GNUNET_BIO_read_open (file); | 103 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); |
104 | GNUNET_assert (NULL != fileRNO); | 104 | |
105 | GNUNET_assert (GNUNET_SYSERR == | 105 | fileR = GNUNET_BIO_read_open (fileName); |
106 | GNUNET_BIO_read_string (fileRNO, "Read string error", | 106 | GNUNET_assert (NULL != fileR); |
107 | &readResultString, 200)); | 107 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); |
108 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileRNO, &testNum)); | 108 | GNUNET_BIO_read_close (fileR, &msg); |
109 | GNUNET_assert (GNUNET_SYSERR == | 109 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); |
110 | GNUNET_BIO_read_meta_data (fileRNO, "Read meta error", | 110 | GNUNET_free (fileName); |
111 | &metaDataNO)); | 111 | return 0; |
112 | fileR = GNUNET_BIO_read_open (fileName); | 112 | } |
113 | GNUNET_assert (NULL != fileR); | 113 | |
114 | GNUNET_assert (GNUNET_OK == | 114 | static int |
115 | GNUNET_BIO_read_string (fileR, "Read string error", | 115 | test_bigstring_rw(void){ |
116 | &readResultString, 200)); | 116 | char *msg; |
117 | GNUNET_assert (GNUNET_OK == | 117 | char *readResultString; |
118 | GNUNET_BIO_read_meta_data (fileR, "Read meta error", | 118 | struct GNUNET_BIO_WriteHandle *fileW; |
119 | &metaDataR)); | 119 | struct GNUNET_BIO_ReadHandle *fileR; |
120 | GNUNET_assert (GNUNET_YES == | 120 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); |
121 | GNUNET_CONTAINER_meta_data_test_equal (metaDataR, | 121 | |
122 | metaDataW)); | 122 | fileW = GNUNET_BIO_write_open (fileName); |
123 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum)); | 123 | GNUNET_assert (NULL != fileW); |
124 | fileR2 = GNUNET_BIO_read_open (fileName2); | 124 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); |
125 | GNUNET_assert (NULL != fileR2); | 125 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); |
126 | readResultString = (char*) "not null"; | 126 | |
127 | GNUNET_assert (GNUNET_SYSERR == | 127 | fileR = GNUNET_BIO_read_open (fileName); |
128 | GNUNET_BIO_read_string (fileR2, "Read string error", | 128 | GNUNET_assert (NULL != fileR); |
129 | &readResultString, 200)); | 129 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 1)); |
130 | GNUNET_assert (NULL == readResultString); | 130 | GNUNET_BIO_read_close (fileR, &msg); |
131 | fileR3 = GNUNET_BIO_read_open (fileName3); | 131 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); |
132 | GNUNET_assert (NULL != fileR3); | 132 | GNUNET_free (fileName); |
133 | GNUNET_assert (GNUNET_SYSERR == | 133 | return 0; |
134 | GNUNET_BIO_read_meta_data (fileR3, "Read meta error", | 134 | } |
135 | &metaDataR)); | 135 | |
136 | fileR4 = GNUNET_BIO_read_open (fileName4); | 136 | static int |
137 | GNUNET_assert (NULL != fileR4); | 137 | test_bigmeta_rw(){ |
138 | GNUNET_assert (GNUNET_OK == | 138 | char *msg; |
139 | GNUNET_BIO_read_string (fileR4, "Read string error", | 139 | static char meta[1024 * 1024 * 10]; |
140 | &readResultString, 200)); | 140 | memset(meta,'b',sizeof(meta)); |
141 | GNUNET_assert (GNUNET_SYSERR == | 141 | meta[sizeof(meta)-1]='\0'; |
142 | GNUNET_BIO_read_string (fileR4, "Read string error", | 142 | struct GNUNET_BIO_WriteHandle *fileW; |
143 | &readResultString, 0)); | 143 | struct GNUNET_BIO_ReadHandle *fileR; |
144 | GNUNET_BIO_read_close (fileR, &msg); | 144 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); |
145 | GNUNET_BIO_read_close (fileR2, &msg); | 145 | struct GNUNET_CONTAINER_MetaData *metaDataW; |
146 | GNUNET_BIO_read_close (fileR3, &msg); | 146 | struct GNUNET_CONTAINER_MetaData *metaDataR; |
147 | GNUNET_BIO_read_close (fileR4, &msg); | 147 | metaDataW = GNUNET_CONTAINER_meta_data_create (); |
148 | GNUNET_CONTAINER_meta_data_destroy (metaDataW); | 148 | metaDataR = GNUNET_CONTAINER_meta_data_create (); |
149 | GNUNET_CONTAINER_meta_data_destroy (metaDataNO); | 149 | GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); |
150 | GNUNET_CONTAINER_meta_data_destroy (metaDataR); | 150 | GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (metaDataW, EXTRACTOR_COMMENT, meta)); |
151 | GNUNET_CONTAINER_meta_data_destroy (metaData); | 151 | |
152 | GNUNET_free (fileName); | 152 | fileW = GNUNET_BIO_write_open (fileName); |
153 | GNUNET_free (fileName2); | 153 | GNUNET_assert (NULL != fileW); |
154 | GNUNET_free (fileName3); | 154 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW)); |
155 | GNUNET_free (fileName4); | 155 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); |
156 | #endif | 156 | |
157 | 157 | fileR = GNUNET_BIO_read_open (fileName); | |
158 | return 0; | 158 | GNUNET_assert (NULL != fileR); |
159 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR)); | ||
160 | GNUNET_BIO_read_close (fileR, &msg); | ||
161 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
162 | GNUNET_free (fileName); | ||
163 | return 0; | ||
164 | } | ||
165 | |||
166 | static int | ||
167 | test_nullfile_rw(void){ | ||
168 | char *msg; | ||
169 | int64_t testNum; | ||
170 | char *readResultString; | ||
171 | static char fileNameNO[102401]; | ||
172 | char readResult[200]; | ||
173 | memset(fileNameNO,'a',sizeof(fileNameNO)); | ||
174 | fileNameNO[sizeof(fileNameNO)-1] = '\0'; | ||
175 | const char *fileName = "/dev/full"; | ||
176 | const char *fileNameR = "/dev/null"; | ||
177 | struct GNUNET_BIO_WriteHandle *fileW,*fileWNO; | ||
178 | struct GNUNET_BIO_ReadHandle *fileR,*fileRNO; | ||
179 | struct GNUNET_CONTAINER_MetaData *metaDataW; | ||
180 | struct GNUNET_CONTAINER_MetaData *metaDataR; | ||
181 | metaDataW = GNUNET_CONTAINER_meta_data_create (); | ||
182 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | ||
183 | GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); | ||
159 | 184 | ||
185 | fileWNO = GNUNET_BIO_write_open(fileNameNO); | ||
186 | GNUNET_assert (NULL == fileWNO); | ||
187 | |||
188 | fileRNO = GNUNET_BIO_read_open (fileNameNO); | ||
189 | GNUNET_assert (NULL == fileRNO); | ||
190 | |||
191 | fileW = GNUNET_BIO_write_open (fileName); | ||
192 | GNUNET_assert (NULL != fileW); | ||
193 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write (fileW, TESTSTRING, 65537)); | ||
194 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_string (fileW, TESTSTRING)); | ||
195 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_meta_data (fileW, metaDataW)); | ||
196 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW)); | ||
197 | fileW = GNUNET_BIO_write_open (fileName); | ||
198 | GNUNET_assert (NULL != fileW); | ||
199 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW)); | ||
200 | |||
201 | fileR = GNUNET_BIO_read_open (fileNameR); | ||
202 | GNUNET_assert (NULL != fileR); | ||
203 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read (fileR, "Read error", readResult, 65537)); | ||
204 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); | ||
205 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum)); | ||
206 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR)); | ||
207 | GNUNET_BIO_read_close (fileR, &msg); | ||
208 | return 0; | ||
209 | } | ||
210 | |||
211 | static int | ||
212 | test_fakestring_rw(void){ | ||
213 | char *msg; | ||
214 | int32_t tmpInt = 2; | ||
215 | char *readResult; | ||
216 | struct GNUNET_BIO_WriteHandle *fileW; | ||
217 | struct GNUNET_BIO_ReadHandle *fileR; | ||
218 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | ||
219 | |||
220 | fileW = GNUNET_BIO_write_open (fileName); | ||
221 | GNUNET_assert (NULL != fileW); | ||
222 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt)); | ||
223 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | ||
224 | |||
225 | fileR = GNUNET_BIO_read_open (fileName); | ||
226 | GNUNET_assert (NULL != fileR); | ||
227 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string(fileR, "Read string error", &readResult, 200)); | ||
228 | GNUNET_BIO_read_close (fileR, &msg); | ||
229 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
230 | GNUNET_free (fileName); | ||
231 | return 0; | ||
232 | } | ||
233 | |||
234 | static int | ||
235 | test_fakemeta_rw(void){ | ||
236 | char *msg; | ||
237 | int32_t tmpInt = 2; | ||
238 | struct GNUNET_BIO_WriteHandle *fileW; | ||
239 | struct GNUNET_BIO_ReadHandle *fileR; | ||
240 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | ||
241 | struct GNUNET_CONTAINER_MetaData *metaDataR; | ||
242 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | ||
243 | |||
244 | fileW = GNUNET_BIO_write_open (fileName); | ||
245 | GNUNET_assert (NULL != fileW); | ||
246 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW,tmpInt)); | ||
247 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | ||
248 | |||
249 | fileR = GNUNET_BIO_read_open (fileName); | ||
250 | GNUNET_assert (NULL != fileR); | ||
251 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR)); | ||
252 | GNUNET_BIO_read_close (fileR, &msg); | ||
253 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
254 | GNUNET_free (fileName); | ||
255 | return 0; | ||
256 | } | ||
257 | |||
258 | static int | ||
259 | test_fakebigmeta_rw(void){ | ||
260 | char *msg; | ||
261 | int32_t tmpInt = 1024*1024*10; | ||
262 | struct GNUNET_BIO_WriteHandle *fileW; | ||
263 | struct GNUNET_BIO_ReadHandle *fileR; | ||
264 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | ||
265 | struct GNUNET_CONTAINER_MetaData *metaDataR; | ||
266 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | ||
267 | |||
268 | fileW = GNUNET_BIO_write_open (fileName); | ||
269 | GNUNET_assert (NULL != fileW); | ||
270 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt)); | ||
271 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | ||
272 | |||
273 | fileR = GNUNET_BIO_read_open (fileName); | ||
274 | GNUNET_assert (NULL != fileR); | ||
275 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR)); | ||
276 | GNUNET_BIO_read_close (fileR, &msg); | ||
277 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
278 | GNUNET_free (fileName); | ||
279 | return 0; | ||
280 | } | ||
281 | |||
282 | static int | ||
283 | check_string_rw(void){ | ||
284 | GNUNET_assert (0 == test_nullstring_rw()); | ||
285 | GNUNET_assert (0 == test_emptystring_rw()); | ||
286 | GNUNET_assert (0 == test_bigstring_rw()); | ||
287 | GNUNET_assert (0 == test_fakestring_rw()); | ||
288 | return 0; | ||
289 | } | ||
290 | |||
291 | static int | ||
292 | check_metadata_rw(void){ | ||
293 | GNUNET_assert (0 == test_fakebigmeta_rw()); | ||
294 | GNUNET_assert (0 == test_fakemeta_rw()); | ||
295 | GNUNET_assert (0 == test_bigmeta_rw()); | ||
296 | return 0; | ||
297 | } | ||
298 | |||
299 | static int | ||
300 | check_file_rw(void){ | ||
301 | GNUNET_assert (0 == test_normal_rw()); | ||
302 | GNUNET_assert (0 == test_nullfile_rw()); | ||
303 | return 0; | ||
304 | } | ||
305 | |||
306 | int | ||
307 | main (int argc, char *argv[]){ | ||
308 | GNUNET_assert (0 == check_file_rw()); | ||
309 | GNUNET_assert (0 == check_metadata_rw()); | ||
310 | GNUNET_assert (0 == check_string_rw()); | ||
311 | return 0; | ||
160 | } /* end of main */ | 312 | } /* end of main */ |