aboutsummaryrefslogtreecommitdiff
path: root/src/util/test_bio.c
diff options
context:
space:
mode:
authorJi Lu <jilu@140774ce-b5e7-0310-ab8b-a85725594a96>2009-11-08 00:08:58 +0000
committerJi Lu <jilu@140774ce-b5e7-0310-ab8b-a85725594a96>2009-11-08 00:08:58 +0000
commit1c77704470683ebcb42b8dd0b7290018fb6340bf (patch)
treec1ac39a0e62feaa8fe0d42ba2a24d3ffa9106f37 /src/util/test_bio.c
parent410796aa0383385cbb0d12d17d56d69ee15d0497 (diff)
downloadgnunet-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.c404
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
33int 33static int
34main (int argc, char *argv[]) 34test_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 (); 68static int
69 metaDataW = GNUNET_CONTAINER_meta_data_create (); 69test_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)); 92static int
93 fileW3 = GNUNET_BIO_write_open (fileName3); 93test_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 == 114static int
115 GNUNET_BIO_read_string (fileR, "Read string error", 115test_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); 136static int
137 GNUNET_assert (NULL != fileR4); 137test_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
166static int
167test_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
211static int
212test_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
234static int
235test_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
258static int
259test_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
282static int
283check_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
291static int
292check_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
299static int
300check_file_rw(void){
301 GNUNET_assert (0 == test_normal_rw());
302 GNUNET_assert (0 == test_nullfile_rw());
303 return 0;
304}
305
306int
307main (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 */