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/fs/test_fs_namespace.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/fs/test_fs_namespace.c')
-rw-r--r-- | src/fs/test_fs_namespace.c | 330 |
1 files changed, 165 insertions, 165 deletions
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c index 3abbd5063..cdcb4d8fd 100644 --- a/src/fs/test_fs_namespace.c +++ b/src/fs/test_fs_namespace.c | |||
@@ -41,7 +41,7 @@ static struct GNUNET_FS_SearchContext *sks_search; | |||
41 | 41 | ||
42 | static struct GNUNET_FS_SearchContext *ksk_search; | 42 | static struct GNUNET_FS_SearchContext *ksk_search; |
43 | 43 | ||
44 | static struct GNUNET_SCHEDULER_Task * kill_task; | 44 | static struct GNUNET_SCHEDULER_Task *kill_task; |
45 | 45 | ||
46 | static int update_started; | 46 | static int update_started; |
47 | 47 | ||
@@ -49,123 +49,123 @@ static int err; | |||
49 | 49 | ||
50 | 50 | ||
51 | static void | 51 | static void |
52 | abort_ksk_search_task(void *cls) | 52 | abort_ksk_search_task (void *cls) |
53 | { | 53 | { |
54 | if (ksk_search != NULL) | 54 | if (ksk_search != NULL) |
55 | { | ||
56 | GNUNET_FS_search_stop (ksk_search); | ||
57 | ksk_search = NULL; | ||
58 | if (sks_search == NULL) | ||
55 | { | 59 | { |
56 | GNUNET_FS_search_stop(ksk_search); | 60 | GNUNET_FS_stop (fs); |
57 | ksk_search = NULL; | 61 | if (NULL != kill_task) |
58 | if (sks_search == NULL) | 62 | GNUNET_SCHEDULER_cancel (kill_task); |
59 | { | ||
60 | GNUNET_FS_stop(fs); | ||
61 | if (NULL != kill_task) | ||
62 | GNUNET_SCHEDULER_cancel(kill_task); | ||
63 | } | ||
64 | } | 63 | } |
64 | } | ||
65 | } | 65 | } |
66 | 66 | ||
67 | 67 | ||
68 | static void | 68 | static void |
69 | abort_sks_search_task(void *cls) | 69 | abort_sks_search_task (void *cls) |
70 | { | 70 | { |
71 | if (sks_search == NULL) | 71 | if (sks_search == NULL) |
72 | return; | 72 | return; |
73 | GNUNET_FS_search_stop(sks_search); | 73 | GNUNET_FS_search_stop (sks_search); |
74 | sks_search = NULL; | 74 | sks_search = NULL; |
75 | if (ksk_search == NULL) | 75 | if (ksk_search == NULL) |
76 | { | 76 | { |
77 | GNUNET_FS_stop(fs); | 77 | GNUNET_FS_stop (fs); |
78 | if (NULL != kill_task) | 78 | if (NULL != kill_task) |
79 | GNUNET_SCHEDULER_cancel(kill_task); | 79 | GNUNET_SCHEDULER_cancel (kill_task); |
80 | } | 80 | } |
81 | } | 81 | } |
82 | 82 | ||
83 | 83 | ||
84 | static void | 84 | static void |
85 | do_timeout(void *cls) | 85 | do_timeout (void *cls) |
86 | { | 86 | { |
87 | err = 1; | 87 | err = 1; |
88 | fprintf(stderr, "%s", "Operation timed out\n"); | 88 | fprintf (stderr, "%s", "Operation timed out\n"); |
89 | kill_task = NULL; | 89 | kill_task = NULL; |
90 | abort_sks_search_task(NULL); | 90 | abort_sks_search_task (NULL); |
91 | abort_ksk_search_task(NULL); | 91 | abort_ksk_search_task (NULL); |
92 | } | 92 | } |
93 | 93 | ||
94 | 94 | ||
95 | static void * | 95 | static void * |
96 | progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event) | 96 | progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event) |
97 | { | 97 | { |
98 | switch (event->status) | 98 | switch (event->status) |
99 | { | ||
100 | case GNUNET_FS_STATUS_SEARCH_RESULT: | ||
101 | if (sks_search == event->value.search.sc) | ||
99 | { | 102 | { |
100 | case GNUNET_FS_STATUS_SEARCH_RESULT: | 103 | if (! GNUNET_FS_uri_test_equal |
101 | if (sks_search == event->value.search.sc) | 104 | (sks_expect_uri, event->value.search.specifics.result.uri)) |
102 | { | 105 | { |
103 | if (!GNUNET_FS_uri_test_equal | 106 | fprintf (stderr, "%s", "Wrong result for sks search!\n"); |
104 | (sks_expect_uri, event->value.search.specifics.result.uri)) | 107 | err = 1; |
105 | { | 108 | } |
106 | fprintf(stderr, "%s", "Wrong result for sks search!\n"); | 109 | /* give system 1ms to initiate update search! */ |
107 | err = 1; | 110 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS, |
108 | } | 111 | &abort_sks_search_task, NULL); |
109 | /* give system 1ms to initiate update search! */ | ||
110 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MILLISECONDS, | ||
111 | &abort_sks_search_task, NULL); | ||
112 | } | ||
113 | else if (ksk_search == event->value.search.sc) | ||
114 | { | ||
115 | if (!GNUNET_FS_uri_test_equal | ||
116 | (ksk_expect_uri, event->value.search.specifics.result.uri)) | ||
117 | { | ||
118 | fprintf(stderr, "%s", "Wrong result for ksk search!\n"); | ||
119 | err = 1; | ||
120 | } | ||
121 | GNUNET_SCHEDULER_add_now(&abort_ksk_search_task, NULL); | ||
122 | } | ||
123 | else | ||
124 | { | ||
125 | fprintf(stderr, "%s", "Unexpected search result received!\n"); | ||
126 | GNUNET_break(0); | ||
127 | } | ||
128 | break; | ||
129 | |||
130 | case GNUNET_FS_STATUS_SEARCH_ERROR: | ||
131 | fprintf(stderr, "Error searching file: %s\n", | ||
132 | event->value.search.specifics.error.message); | ||
133 | if (sks_search == event->value.search.sc) | ||
134 | GNUNET_SCHEDULER_add_now(&abort_sks_search_task, NULL); | ||
135 | else if (ksk_search == event->value.search.sc) | ||
136 | GNUNET_SCHEDULER_add_now(&abort_ksk_search_task, NULL); | ||
137 | else | ||
138 | GNUNET_break(0); | ||
139 | break; | ||
140 | |||
141 | case GNUNET_FS_STATUS_SEARCH_START: | ||
142 | GNUNET_assert((NULL == event->value.search.cctx) || | ||
143 | (0 == strcmp("sks_search", event->value.search.cctx)) || | ||
144 | (0 == strcmp("ksk_search", event->value.search.cctx))); | ||
145 | if (NULL == event->value.search.cctx) | ||
146 | { | ||
147 | GNUNET_assert(0 == strcmp("sks_search", event->value.search.pctx)); | ||
148 | update_started = GNUNET_YES; | ||
149 | } | ||
150 | GNUNET_assert(1 == event->value.search.anonymity); | ||
151 | break; | ||
152 | |||
153 | case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: | ||
154 | return NULL; | ||
155 | |||
156 | case GNUNET_FS_STATUS_SEARCH_STOPPED: | ||
157 | return NULL; | ||
158 | |||
159 | default: | ||
160 | fprintf(stderr, "Unexpected event: %d\n", event->status); | ||
161 | break; | ||
162 | } | 112 | } |
113 | else if (ksk_search == event->value.search.sc) | ||
114 | { | ||
115 | if (! GNUNET_FS_uri_test_equal | ||
116 | (ksk_expect_uri, event->value.search.specifics.result.uri)) | ||
117 | { | ||
118 | fprintf (stderr, "%s", "Wrong result for ksk search!\n"); | ||
119 | err = 1; | ||
120 | } | ||
121 | GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL); | ||
122 | } | ||
123 | else | ||
124 | { | ||
125 | fprintf (stderr, "%s", "Unexpected search result received!\n"); | ||
126 | GNUNET_break (0); | ||
127 | } | ||
128 | break; | ||
129 | |||
130 | case GNUNET_FS_STATUS_SEARCH_ERROR: | ||
131 | fprintf (stderr, "Error searching file: %s\n", | ||
132 | event->value.search.specifics.error.message); | ||
133 | if (sks_search == event->value.search.sc) | ||
134 | GNUNET_SCHEDULER_add_now (&abort_sks_search_task, NULL); | ||
135 | else if (ksk_search == event->value.search.sc) | ||
136 | GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL); | ||
137 | else | ||
138 | GNUNET_break (0); | ||
139 | break; | ||
140 | |||
141 | case GNUNET_FS_STATUS_SEARCH_START: | ||
142 | GNUNET_assert ((NULL == event->value.search.cctx) || | ||
143 | (0 == strcmp ("sks_search", event->value.search.cctx)) || | ||
144 | (0 == strcmp ("ksk_search", event->value.search.cctx))); | ||
145 | if (NULL == event->value.search.cctx) | ||
146 | { | ||
147 | GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx)); | ||
148 | update_started = GNUNET_YES; | ||
149 | } | ||
150 | GNUNET_assert (1 == event->value.search.anonymity); | ||
151 | break; | ||
152 | |||
153 | case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: | ||
154 | return NULL; | ||
155 | |||
156 | case GNUNET_FS_STATUS_SEARCH_STOPPED: | ||
157 | return NULL; | ||
158 | |||
159 | default: | ||
160 | fprintf (stderr, "Unexpected event: %d\n", event->status); | ||
161 | break; | ||
162 | } | ||
163 | return event->value.search.cctx; | 163 | return event->value.search.cctx; |
164 | } | 164 | } |
165 | 165 | ||
166 | 166 | ||
167 | static void | 167 | static void |
168 | publish_cont(void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg) | 168 | publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg) |
169 | { | 169 | { |
170 | char *msg; | 170 | char *msg; |
171 | struct GNUNET_FS_Uri *sks_uri; | 171 | struct GNUNET_FS_Uri *sks_uri; |
@@ -174,37 +174,37 @@ publish_cont(void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg) | |||
174 | char *ret; | 174 | char *ret; |
175 | 175 | ||
176 | if (NULL != emsg) | 176 | if (NULL != emsg) |
177 | { | 177 | { |
178 | fprintf(stderr, "Error publishing: %s\n", emsg); | 178 | fprintf (stderr, "Error publishing: %s\n", emsg); |
179 | err = 1; | 179 | err = 1; |
180 | GNUNET_FS_stop(fs); | 180 | GNUNET_FS_stop (fs); |
181 | return; | 181 | return; |
182 | } | 182 | } |
183 | ret = GNUNET_STRINGS_data_to_string(&nsid, sizeof(nsid), buf, sizeof(buf)); | 183 | ret = GNUNET_STRINGS_data_to_string (&nsid, sizeof(nsid), buf, sizeof(buf)); |
184 | GNUNET_assert(NULL != ret); | 184 | GNUNET_assert (NULL != ret); |
185 | ret[0] = '\0'; | 185 | ret[0] = '\0'; |
186 | GNUNET_snprintf(sbuf, sizeof(sbuf), "gnunet://fs/sks/%s/this", buf); | 186 | GNUNET_snprintf (sbuf, sizeof(sbuf), "gnunet://fs/sks/%s/this", buf); |
187 | sks_uri = GNUNET_FS_uri_parse(sbuf, &msg); | 187 | sks_uri = GNUNET_FS_uri_parse (sbuf, &msg); |
188 | if (NULL == sks_uri) | 188 | if (NULL == sks_uri) |
189 | { | 189 | { |
190 | fprintf(stderr, "failed to parse URI `%s': %s\n", sbuf, msg); | 190 | fprintf (stderr, "failed to parse URI `%s': %s\n", sbuf, msg); |
191 | err = 1; | 191 | err = 1; |
192 | GNUNET_FS_stop(fs); | 192 | GNUNET_FS_stop (fs); |
193 | GNUNET_free_non_null(msg); | 193 | GNUNET_free_non_null (msg); |
194 | return; | 194 | return; |
195 | } | 195 | } |
196 | ksk_search = | 196 | ksk_search = |
197 | GNUNET_FS_search_start(fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, | 197 | GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, |
198 | "ksk_search"); | 198 | "ksk_search"); |
199 | sks_search = | 199 | sks_search = |
200 | GNUNET_FS_search_start(fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, | 200 | GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, |
201 | "sks_search"); | 201 | "sks_search"); |
202 | GNUNET_FS_uri_destroy(sks_uri); | 202 | GNUNET_FS_uri_destroy (sks_uri); |
203 | } | 203 | } |
204 | 204 | ||
205 | 205 | ||
206 | static void | 206 | static void |
207 | sks_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) | 207 | sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) |
208 | { | 208 | { |
209 | struct GNUNET_CONTAINER_MetaData *meta; | 209 | struct GNUNET_CONTAINER_MetaData *meta; |
210 | struct GNUNET_FS_Uri *ksk_uri; | 210 | struct GNUNET_FS_Uri *ksk_uri; |
@@ -212,61 +212,61 @@ sks_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) | |||
212 | struct GNUNET_FS_BlockOptions bo; | 212 | struct GNUNET_FS_BlockOptions bo; |
213 | 213 | ||
214 | if (NULL == uri) | 214 | if (NULL == uri) |
215 | { | 215 | { |
216 | fprintf(stderr, "Error publishing: %s\n", emsg); | 216 | fprintf (stderr, "Error publishing: %s\n", emsg); |
217 | err = 1; | 217 | err = 1; |
218 | GNUNET_FS_stop(fs); | 218 | GNUNET_FS_stop (fs); |
219 | return; | 219 | return; |
220 | } | 220 | } |
221 | meta = GNUNET_CONTAINER_meta_data_create(); | 221 | meta = GNUNET_CONTAINER_meta_data_create (); |
222 | msg = NULL; | 222 | msg = NULL; |
223 | ksk_uri = GNUNET_FS_uri_parse("gnunet://fs/ksk/ns-search", &msg); | 223 | ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/ns-search", &msg); |
224 | GNUNET_assert(NULL == msg); | 224 | GNUNET_assert (NULL == msg); |
225 | ksk_expect_uri = GNUNET_FS_uri_dup(uri); | 225 | ksk_expect_uri = GNUNET_FS_uri_dup (uri); |
226 | bo.content_priority = 1; | 226 | bo.content_priority = 1; |
227 | bo.anonymity_level = 1; | 227 | bo.anonymity_level = 1; |
228 | bo.replication_level = 0; | 228 | bo.replication_level = 0; |
229 | bo.expiration_time = | 229 | bo.expiration_time = |
230 | GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES); | 230 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); |
231 | GNUNET_FS_publish_ksk(fs, ksk_uri, meta, uri, &bo, | 231 | GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo, |
232 | GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL); | 232 | GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL); |
233 | GNUNET_FS_uri_destroy(ksk_uri); | 233 | GNUNET_FS_uri_destroy (ksk_uri); |
234 | GNUNET_CONTAINER_meta_data_destroy(meta); | 234 | GNUNET_CONTAINER_meta_data_destroy (meta); |
235 | } | 235 | } |
236 | 236 | ||
237 | 237 | ||
238 | static void | 238 | static void |
239 | adv_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) | 239 | adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) |
240 | { | 240 | { |
241 | struct GNUNET_CONTAINER_MetaData *meta; | 241 | struct GNUNET_CONTAINER_MetaData *meta; |
242 | struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; | 242 | struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; |
243 | struct GNUNET_FS_BlockOptions bo; | 243 | struct GNUNET_FS_BlockOptions bo; |
244 | 244 | ||
245 | if (NULL != emsg) | 245 | if (NULL != emsg) |
246 | { | 246 | { |
247 | fprintf(stderr, "Error publishing: %s\n", emsg); | 247 | fprintf (stderr, "Error publishing: %s\n", emsg); |
248 | err = 1; | 248 | err = 1; |
249 | GNUNET_FS_stop(fs); | 249 | GNUNET_FS_stop (fs); |
250 | return; | 250 | return; |
251 | } | 251 | } |
252 | ns = GNUNET_CRYPTO_ecdsa_key_create(); | 252 | ns = GNUNET_CRYPTO_ecdsa_key_create (); |
253 | meta = GNUNET_CONTAINER_meta_data_create(); | 253 | meta = GNUNET_CONTAINER_meta_data_create (); |
254 | sks_expect_uri = GNUNET_FS_uri_dup(uri); | 254 | sks_expect_uri = GNUNET_FS_uri_dup (uri); |
255 | bo.content_priority = 1; | 255 | bo.content_priority = 1; |
256 | bo.anonymity_level = 1; | 256 | bo.anonymity_level = 1; |
257 | bo.replication_level = 0; | 257 | bo.replication_level = 0; |
258 | bo.expiration_time = | 258 | bo.expiration_time = |
259 | GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES); | 259 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); |
260 | GNUNET_CRYPTO_ecdsa_key_get_public(ns, &nsid); | 260 | GNUNET_CRYPTO_ecdsa_key_get_public (ns, &nsid); |
261 | GNUNET_FS_publish_sks(fs, ns, "this", "next", meta, uri, | 261 | GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri, |
262 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL); | 262 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL); |
263 | GNUNET_CONTAINER_meta_data_destroy(meta); | 263 | GNUNET_CONTAINER_meta_data_destroy (meta); |
264 | GNUNET_free(ns); | 264 | GNUNET_free (ns); |
265 | } | 265 | } |
266 | 266 | ||
267 | 267 | ||
268 | static void | 268 | static void |
269 | testNamespace() | 269 | testNamespace () |
270 | { | 270 | { |
271 | struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; | 271 | struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; |
272 | struct GNUNET_FS_BlockOptions bo; | 272 | struct GNUNET_FS_BlockOptions bo; |
@@ -274,46 +274,46 @@ testNamespace() | |||
274 | struct GNUNET_FS_Uri *ksk_uri; | 274 | struct GNUNET_FS_Uri *ksk_uri; |
275 | struct GNUNET_FS_Uri *sks_uri; | 275 | struct GNUNET_FS_Uri *sks_uri; |
276 | 276 | ||
277 | ns = GNUNET_CRYPTO_ecdsa_key_create(); | 277 | ns = GNUNET_CRYPTO_ecdsa_key_create (); |
278 | meta = GNUNET_CONTAINER_meta_data_create(); | 278 | meta = GNUNET_CONTAINER_meta_data_create (); |
279 | ksk_uri = GNUNET_FS_uri_parse("gnunet://fs/ksk/testnsa", NULL); | 279 | ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL); |
280 | bo.content_priority = 1; | 280 | bo.content_priority = 1; |
281 | bo.anonymity_level = 1; | 281 | bo.anonymity_level = 1; |
282 | bo.replication_level = 0; | 282 | bo.replication_level = 0; |
283 | bo.expiration_time = | 283 | bo.expiration_time = |
284 | GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES); | 284 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); |
285 | sks_uri = GNUNET_FS_uri_sks_create(&nsid, "root"); | 285 | sks_uri = GNUNET_FS_uri_sks_create (&nsid, "root"); |
286 | GNUNET_FS_publish_ksk(fs, | 286 | GNUNET_FS_publish_ksk (fs, |
287 | ksk_uri, meta, sks_uri, | 287 | ksk_uri, meta, sks_uri, |
288 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, | 288 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, |
289 | &adv_cont, NULL); | 289 | &adv_cont, NULL); |
290 | GNUNET_FS_uri_destroy(sks_uri); | 290 | GNUNET_FS_uri_destroy (sks_uri); |
291 | kill_task = | 291 | kill_task = |
292 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, &do_timeout, | 292 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout, |
293 | NULL); | 293 | NULL); |
294 | GNUNET_FS_uri_destroy(ksk_uri); | 294 | GNUNET_FS_uri_destroy (ksk_uri); |
295 | GNUNET_CONTAINER_meta_data_destroy(meta); | 295 | GNUNET_CONTAINER_meta_data_destroy (meta); |
296 | GNUNET_free(ns); | 296 | GNUNET_free (ns); |
297 | } | 297 | } |
298 | 298 | ||
299 | 299 | ||
300 | static void | 300 | static void |
301 | run(void *cls, | 301 | run (void *cls, |
302 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 302 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
303 | struct GNUNET_TESTING_Peer *peer) | 303 | struct GNUNET_TESTING_Peer *peer) |
304 | { | 304 | { |
305 | fs = GNUNET_FS_start(cfg, "test-fs-namespace", &progress_cb, NULL, | 305 | fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL, |
306 | GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); | 306 | GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); |
307 | testNamespace(); | 307 | testNamespace (); |
308 | } | 308 | } |
309 | 309 | ||
310 | 310 | ||
311 | int | 311 | int |
312 | main(int argc, char *argv[]) | 312 | main (int argc, char *argv[]) |
313 | { | 313 | { |
314 | if (0 != GNUNET_TESTING_peer_run("test-fs-namespace", | 314 | if (0 != GNUNET_TESTING_peer_run ("test-fs-namespace", |
315 | "test_fs_namespace_data.conf", | 315 | "test_fs_namespace_data.conf", |
316 | &run, NULL)) | 316 | &run, NULL)) |
317 | return 1; | 317 | return 1; |
318 | return err; | 318 | return err; |
319 | } | 319 | } |