diff options
Diffstat (limited to 'src/fs/test_fs_namespace.c')
-rw-r--r-- | src/fs/test_fs_namespace.c | 327 |
1 files changed, 166 insertions, 161 deletions
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c index 43c899b72..3abbd5063 100644 --- a/src/fs/test_fs_namespace.c +++ b/src/fs/test_fs_namespace.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 fs/test_fs_namespace.c | 22 | * @file fs/test_fs_namespace.c |
@@ -49,118 +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) | ||
59 | { | 55 | { |
60 | GNUNET_FS_stop (fs); | 56 | GNUNET_FS_search_stop(ksk_search); |
61 | if (NULL != kill_task) | 57 | ksk_search = NULL; |
62 | GNUNET_SCHEDULER_cancel (kill_task); | 58 | if (sks_search == NULL) |
59 | { | ||
60 | GNUNET_FS_stop(fs); | ||
61 | if (NULL != kill_task) | ||
62 | GNUNET_SCHEDULER_cancel(kill_task); | ||
63 | } | ||
63 | } | 64 | } |
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) | ||
102 | { | ||
103 | if (!GNUNET_FS_uri_test_equal | ||
104 | (sks_expect_uri, event->value.search.specifics.result.uri)) | ||
105 | { | ||
106 | fprintf (stderr, "%s", "Wrong result for sks search!\n"); | ||
107 | err = 1; | ||
108 | } | ||
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 | case GNUNET_FS_STATUS_SEARCH_ERROR: | ||
130 | fprintf (stderr, "Error searching file: %s\n", | ||
131 | event->value.search.specifics.error.message); | ||
132 | if (sks_search == event->value.search.sc) | ||
133 | GNUNET_SCHEDULER_add_now (&abort_sks_search_task, NULL); | ||
134 | else if (ksk_search == event->value.search.sc) | ||
135 | GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL); | ||
136 | else | ||
137 | GNUNET_break (0); | ||
138 | break; | ||
139 | case GNUNET_FS_STATUS_SEARCH_START: | ||
140 | GNUNET_assert ((NULL == event->value.search.cctx) || | ||
141 | (0 == strcmp ("sks_search", event->value.search.cctx)) || | ||
142 | (0 == strcmp ("ksk_search", event->value.search.cctx))); | ||
143 | if (NULL == event->value.search.cctx) | ||
144 | { | 99 | { |
145 | GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx)); | 100 | case GNUNET_FS_STATUS_SEARCH_RESULT: |
146 | update_started = GNUNET_YES; | 101 | if (sks_search == event->value.search.sc) |
102 | { | ||
103 | if (!GNUNET_FS_uri_test_equal | ||
104 | (sks_expect_uri, event->value.search.specifics.result.uri)) | ||
105 | { | ||
106 | fprintf(stderr, "%s", "Wrong result for sks search!\n"); | ||
107 | err = 1; | ||
108 | } | ||
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; | ||
147 | } | 162 | } |
148 | GNUNET_assert (1 == event->value.search.anonymity); | ||
149 | break; | ||
150 | case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED: | ||
151 | return NULL; | ||
152 | case GNUNET_FS_STATUS_SEARCH_STOPPED: | ||
153 | return NULL; | ||
154 | default: | ||
155 | fprintf (stderr, "Unexpected event: %d\n", event->status); | ||
156 | break; | ||
157 | } | ||
158 | return event->value.search.cctx; | 163 | return event->value.search.cctx; |
159 | } | 164 | } |
160 | 165 | ||
161 | 166 | ||
162 | static void | 167 | static void |
163 | 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) |
164 | { | 169 | { |
165 | char *msg; | 170 | char *msg; |
166 | struct GNUNET_FS_Uri *sks_uri; | 171 | struct GNUNET_FS_Uri *sks_uri; |
@@ -169,37 +174,37 @@ publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg) | |||
169 | char *ret; | 174 | char *ret; |
170 | 175 | ||
171 | if (NULL != emsg) | 176 | if (NULL != emsg) |
172 | { | 177 | { |
173 | fprintf (stderr, "Error publishing: %s\n", emsg); | 178 | fprintf(stderr, "Error publishing: %s\n", emsg); |
174 | err = 1; | 179 | err = 1; |
175 | GNUNET_FS_stop (fs); | 180 | GNUNET_FS_stop(fs); |
176 | return; | 181 | return; |
177 | } | 182 | } |
178 | 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)); |
179 | GNUNET_assert (NULL != ret); | 184 | GNUNET_assert(NULL != ret); |
180 | ret[0] = '\0'; | 185 | ret[0] = '\0'; |
181 | GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", buf); | 186 | GNUNET_snprintf(sbuf, sizeof(sbuf), "gnunet://fs/sks/%s/this", buf); |
182 | sks_uri = GNUNET_FS_uri_parse (sbuf, &msg); | 187 | sks_uri = GNUNET_FS_uri_parse(sbuf, &msg); |
183 | if (NULL == sks_uri) | 188 | if (NULL == sks_uri) |
184 | { | 189 | { |
185 | fprintf (stderr, "failed to parse URI `%s': %s\n", sbuf, msg); | 190 | fprintf(stderr, "failed to parse URI `%s': %s\n", sbuf, msg); |
186 | err = 1; | 191 | err = 1; |
187 | GNUNET_FS_stop (fs); | 192 | GNUNET_FS_stop(fs); |
188 | GNUNET_free_non_null (msg); | 193 | GNUNET_free_non_null(msg); |
189 | return; | 194 | return; |
190 | } | 195 | } |
191 | ksk_search = | 196 | ksk_search = |
192 | 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, |
193 | "ksk_search"); | 198 | "ksk_search"); |
194 | sks_search = | 199 | sks_search = |
195 | 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, |
196 | "sks_search"); | 201 | "sks_search"); |
197 | GNUNET_FS_uri_destroy (sks_uri); | 202 | GNUNET_FS_uri_destroy(sks_uri); |
198 | } | 203 | } |
199 | 204 | ||
200 | 205 | ||
201 | static void | 206 | static void |
202 | 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) |
203 | { | 208 | { |
204 | struct GNUNET_CONTAINER_MetaData *meta; | 209 | struct GNUNET_CONTAINER_MetaData *meta; |
205 | struct GNUNET_FS_Uri *ksk_uri; | 210 | struct GNUNET_FS_Uri *ksk_uri; |
@@ -207,61 +212,61 @@ sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg) | |||
207 | struct GNUNET_FS_BlockOptions bo; | 212 | struct GNUNET_FS_BlockOptions bo; |
208 | 213 | ||
209 | if (NULL == uri) | 214 | if (NULL == uri) |
210 | { | 215 | { |
211 | fprintf (stderr, "Error publishing: %s\n", emsg); | 216 | fprintf(stderr, "Error publishing: %s\n", emsg); |
212 | err = 1; | 217 | err = 1; |
213 | GNUNET_FS_stop (fs); | 218 | GNUNET_FS_stop(fs); |
214 | return; | 219 | return; |
215 | } | 220 | } |
216 | meta = GNUNET_CONTAINER_meta_data_create (); | 221 | meta = GNUNET_CONTAINER_meta_data_create(); |
217 | msg = NULL; | 222 | msg = NULL; |
218 | 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); |
219 | GNUNET_assert (NULL == msg); | 224 | GNUNET_assert(NULL == msg); |
220 | ksk_expect_uri = GNUNET_FS_uri_dup (uri); | 225 | ksk_expect_uri = GNUNET_FS_uri_dup(uri); |
221 | bo.content_priority = 1; | 226 | bo.content_priority = 1; |
222 | bo.anonymity_level = 1; | 227 | bo.anonymity_level = 1; |
223 | bo.replication_level = 0; | 228 | bo.replication_level = 0; |
224 | bo.expiration_time = | 229 | bo.expiration_time = |
225 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); | 230 | GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES); |
226 | GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo, | 231 | GNUNET_FS_publish_ksk(fs, ksk_uri, meta, uri, &bo, |
227 | GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL); | 232 | GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL); |
228 | GNUNET_FS_uri_destroy (ksk_uri); | 233 | GNUNET_FS_uri_destroy(ksk_uri); |
229 | GNUNET_CONTAINER_meta_data_destroy (meta); | 234 | GNUNET_CONTAINER_meta_data_destroy(meta); |
230 | } | 235 | } |
231 | 236 | ||
232 | 237 | ||
233 | static void | 238 | static void |
234 | 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) |
235 | { | 240 | { |
236 | struct GNUNET_CONTAINER_MetaData *meta; | 241 | struct GNUNET_CONTAINER_MetaData *meta; |
237 | struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; | 242 | struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; |
238 | struct GNUNET_FS_BlockOptions bo; | 243 | struct GNUNET_FS_BlockOptions bo; |
239 | 244 | ||
240 | if (NULL != emsg) | 245 | if (NULL != emsg) |
241 | { | 246 | { |
242 | fprintf (stderr, "Error publishing: %s\n", emsg); | 247 | fprintf(stderr, "Error publishing: %s\n", emsg); |
243 | err = 1; | 248 | err = 1; |
244 | GNUNET_FS_stop (fs); | 249 | GNUNET_FS_stop(fs); |
245 | return; | 250 | return; |
246 | } | 251 | } |
247 | ns = GNUNET_CRYPTO_ecdsa_key_create (); | 252 | ns = GNUNET_CRYPTO_ecdsa_key_create(); |
248 | meta = GNUNET_CONTAINER_meta_data_create (); | 253 | meta = GNUNET_CONTAINER_meta_data_create(); |
249 | sks_expect_uri = GNUNET_FS_uri_dup (uri); | 254 | sks_expect_uri = GNUNET_FS_uri_dup(uri); |
250 | bo.content_priority = 1; | 255 | bo.content_priority = 1; |
251 | bo.anonymity_level = 1; | 256 | bo.anonymity_level = 1; |
252 | bo.replication_level = 0; | 257 | bo.replication_level = 0; |
253 | bo.expiration_time = | 258 | bo.expiration_time = |
254 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); | 259 | GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES); |
255 | GNUNET_CRYPTO_ecdsa_key_get_public (ns, &nsid); | 260 | GNUNET_CRYPTO_ecdsa_key_get_public(ns, &nsid); |
256 | GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri, | 261 | GNUNET_FS_publish_sks(fs, ns, "this", "next", meta, uri, |
257 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL); | 262 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL); |
258 | GNUNET_CONTAINER_meta_data_destroy (meta); | 263 | GNUNET_CONTAINER_meta_data_destroy(meta); |
259 | GNUNET_free (ns); | 264 | GNUNET_free(ns); |
260 | } | 265 | } |
261 | 266 | ||
262 | 267 | ||
263 | static void | 268 | static void |
264 | testNamespace () | 269 | testNamespace() |
265 | { | 270 | { |
266 | struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; | 271 | struct GNUNET_CRYPTO_EcdsaPrivateKey *ns; |
267 | struct GNUNET_FS_BlockOptions bo; | 272 | struct GNUNET_FS_BlockOptions bo; |
@@ -269,46 +274,46 @@ testNamespace () | |||
269 | struct GNUNET_FS_Uri *ksk_uri; | 274 | struct GNUNET_FS_Uri *ksk_uri; |
270 | struct GNUNET_FS_Uri *sks_uri; | 275 | struct GNUNET_FS_Uri *sks_uri; |
271 | 276 | ||
272 | ns = GNUNET_CRYPTO_ecdsa_key_create (); | 277 | ns = GNUNET_CRYPTO_ecdsa_key_create(); |
273 | meta = GNUNET_CONTAINER_meta_data_create (); | 278 | meta = GNUNET_CONTAINER_meta_data_create(); |
274 | ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL); | 279 | ksk_uri = GNUNET_FS_uri_parse("gnunet://fs/ksk/testnsa", NULL); |
275 | bo.content_priority = 1; | 280 | bo.content_priority = 1; |
276 | bo.anonymity_level = 1; | 281 | bo.anonymity_level = 1; |
277 | bo.replication_level = 0; | 282 | bo.replication_level = 0; |
278 | bo.expiration_time = | 283 | bo.expiration_time = |
279 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); | 284 | GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES); |
280 | sks_uri = GNUNET_FS_uri_sks_create (&nsid, "root"); | 285 | sks_uri = GNUNET_FS_uri_sks_create(&nsid, "root"); |
281 | GNUNET_FS_publish_ksk (fs, | 286 | GNUNET_FS_publish_ksk(fs, |
282 | ksk_uri, meta, sks_uri, | 287 | ksk_uri, meta, sks_uri, |
283 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, | 288 | &bo, GNUNET_FS_PUBLISH_OPTION_NONE, |
284 | &adv_cont, NULL); | 289 | &adv_cont, NULL); |
285 | GNUNET_FS_uri_destroy (sks_uri); | 290 | GNUNET_FS_uri_destroy(sks_uri); |
286 | kill_task = | 291 | kill_task = |
287 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout, | 292 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, &do_timeout, |
288 | NULL); | 293 | NULL); |
289 | GNUNET_FS_uri_destroy (ksk_uri); | 294 | GNUNET_FS_uri_destroy(ksk_uri); |
290 | GNUNET_CONTAINER_meta_data_destroy (meta); | 295 | GNUNET_CONTAINER_meta_data_destroy(meta); |
291 | GNUNET_free (ns); | 296 | GNUNET_free(ns); |
292 | } | 297 | } |
293 | 298 | ||
294 | 299 | ||
295 | static void | 300 | static void |
296 | run (void *cls, | 301 | run(void *cls, |
297 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 302 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
298 | struct GNUNET_TESTING_Peer *peer) | 303 | struct GNUNET_TESTING_Peer *peer) |
299 | { | 304 | { |
300 | fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL, | 305 | fs = GNUNET_FS_start(cfg, "test-fs-namespace", &progress_cb, NULL, |
301 | GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); | 306 | GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END); |
302 | testNamespace (); | 307 | testNamespace(); |
303 | } | 308 | } |
304 | 309 | ||
305 | 310 | ||
306 | int | 311 | int |
307 | main (int argc, char *argv[]) | 312 | main(int argc, char *argv[]) |
308 | { | 313 | { |
309 | if (0 != GNUNET_TESTING_peer_run ("test-fs-namespace", | 314 | if (0 != GNUNET_TESTING_peer_run("test-fs-namespace", |
310 | "test_fs_namespace_data.conf", | 315 | "test_fs_namespace_data.conf", |
311 | &run, NULL)) | 316 | &run, NULL)) |
312 | return 1; | 317 | return 1; |
313 | return err; | 318 | return err; |
314 | } | 319 | } |