aboutsummaryrefslogtreecommitdiff
path: root/src/fs/test_fs_namespace.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/fs/test_fs_namespace.c')
-rw-r--r--src/fs/test_fs_namespace.c384
1 files changed, 170 insertions, 214 deletions
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index b4d487ddc..96caa8dfa 100644
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -67,11 +67,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
67 p->cfg = GNUNET_CONFIGURATION_create (); 67 p->cfg = GNUNET_CONFIGURATION_create ();
68#if START_ARM 68#if START_ARM
69 p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm", 69 p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
70 "gnunet-service-arm", 70 "gnunet-service-arm",
71#if VERBOSE 71#if VERBOSE
72 "-L", "DEBUG", 72 "-L", "DEBUG",
73#endif 73#endif
74 "-c", cfgname, NULL); 74 "-c", cfgname, NULL);
75#endif 75#endif
76 GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); 76 GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
77} 77}
@@ -82,68 +82,64 @@ stop_arm (struct PeerContext *p)
82{ 82{
83#if START_ARM 83#if START_ARM
84 if (NULL != p->arm_proc) 84 if (NULL != p->arm_proc)
85 { 85 {
86 if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM)) 86 if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
87 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); 87 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
88 if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK) 88 if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
89 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid"); 89 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
90 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 90 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
91 "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc)); 91 "ARM process %u stopped\n",
92 GNUNET_OS_process_close (p->arm_proc); 92 GNUNET_OS_process_get_pid (p->arm_proc));
93 p->arm_proc = NULL; 93 GNUNET_OS_process_close (p->arm_proc);
94 } 94 p->arm_proc = NULL;
95 }
95#endif 96#endif
96 GNUNET_CONFIGURATION_destroy (p->cfg); 97 GNUNET_CONFIGURATION_destroy (p->cfg);
97} 98}
98 99
99 100
100static void 101static void
101abort_ksk_search_task (void *cls, 102abort_ksk_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
102 const struct GNUNET_SCHEDULER_TaskContext *tc)
103{ 103{
104 if (ksk_search != NULL) 104 if (ksk_search != NULL)
105 {
106 GNUNET_FS_search_stop (ksk_search);
107 ksk_search = NULL;
108 if (sks_search == NULL)
105 { 109 {
106 GNUNET_FS_search_stop (ksk_search); 110 GNUNET_FS_stop (fs);
107 ksk_search = NULL; 111 if (GNUNET_SCHEDULER_NO_TASK != kill_task)
108 if (sks_search == NULL) 112 GNUNET_SCHEDULER_cancel (kill_task);
109 {
110 GNUNET_FS_stop (fs);
111 if (GNUNET_SCHEDULER_NO_TASK != kill_task)
112 GNUNET_SCHEDULER_cancel (kill_task);
113 }
114 } 113 }
114 }
115} 115}
116 116
117 117
118static void 118static void
119abort_sks_search_task (void *cls, 119abort_sks_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
120 const struct GNUNET_SCHEDULER_TaskContext *tc)
121{ 120{
122 struct GNUNET_FS_Namespace *ns; 121 struct GNUNET_FS_Namespace *ns;
123 122
124 if (sks_search == NULL) 123 if (sks_search == NULL)
125 return; 124 return;
126 GNUNET_FS_search_stop (sks_search); 125 GNUNET_FS_search_stop (sks_search);
127 sks_search = NULL; 126 sks_search = NULL;
128 ns = GNUNET_FS_namespace_create (fs, 127 ns = GNUNET_FS_namespace_create (fs, "testNamespace");
129 "testNamespace");
130 GNUNET_assert (NULL != ns); 128 GNUNET_assert (NULL != ns);
131 GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES)); 129 GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES));
132 if (ksk_search == NULL) 130 if (ksk_search == NULL)
133 { 131 {
134 GNUNET_FS_stop (fs); 132 GNUNET_FS_stop (fs);
135 if (GNUNET_SCHEDULER_NO_TASK != kill_task) 133 if (GNUNET_SCHEDULER_NO_TASK != kill_task)
136 GNUNET_SCHEDULER_cancel (kill_task); 134 GNUNET_SCHEDULER_cancel (kill_task);
137 } 135 }
138} 136}
139 137
140 138
141static void 139static void
142do_timeout (void *cls, 140do_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
143 const struct GNUNET_SCHEDULER_TaskContext *tc)
144{ 141{
145 fprintf (stderr, 142 fprintf (stderr, "Operation timed out\n");
146 "Operation timed out\n");
147 kill_task = GNUNET_SCHEDULER_NO_TASK; 143 kill_task = GNUNET_SCHEDULER_NO_TASK;
148 abort_sks_search_task (NULL, tc); 144 abort_sks_search_task (NULL, tc);
149 abort_ksk_search_task (NULL, tc); 145 abort_ksk_search_task (NULL, tc);
@@ -152,134 +148,121 @@ do_timeout (void *cls,
152 148
153 149
154static void * 150static void *
155progress_cb (void *cls, 151progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
156 const struct GNUNET_FS_ProgressInfo *event)
157{ 152{
158 switch (event->status) 153 switch (event->status)
154 {
155 case GNUNET_FS_STATUS_SEARCH_RESULT:
156 if (sks_search == event->value.search.sc)
157 {
158 if (!GNUNET_FS_uri_test_equal (sks_expect_uri,
159 event->value.search.specifics.result.uri))
160 {
161 fprintf (stderr, "Wrong result for sks search!\n");
162 err = 1;
163 }
164 /* give system 1ms to initiate update search! */
165 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
166 &abort_sks_search_task, NULL);
167 }
168 else if (ksk_search == event->value.search.sc)
159 { 169 {
160 case GNUNET_FS_STATUS_SEARCH_RESULT: 170 if (!GNUNET_FS_uri_test_equal (ksk_expect_uri,
161 if (sks_search == event->value.search.sc) 171 event->value.search.specifics.result.uri))
162 { 172 {
163 if (! GNUNET_FS_uri_test_equal (sks_expect_uri, 173 fprintf (stderr, "Wrong result for ksk search!\n");
164 event->value.search.specifics.result.uri)) 174 err = 1;
165 { 175 }
166 fprintf (stderr, 176 GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task,
167 "Wrong result for sks search!\n"); 177 NULL,
168 err = 1; 178 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
169 }
170 /* give system 1ms to initiate update search! */
171 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
172 &abort_sks_search_task,
173 NULL);
174 }
175 else if (ksk_search == event->value.search.sc)
176 {
177 if (! GNUNET_FS_uri_test_equal (ksk_expect_uri,
178 event->value.search.specifics.result.uri))
179 {
180 fprintf (stderr,
181 "Wrong result for ksk search!\n");
182 err = 1;
183 }
184 GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task,
185 NULL,
186 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
187 }
188 else
189 {
190 fprintf (stderr,
191 "Unexpected search result received!\n");
192 GNUNET_break (0);
193 }
194 break;
195 case GNUNET_FS_STATUS_SEARCH_ERROR:
196 fprintf (stderr,
197 "Error searching file: %s\n",
198 event->value.search.specifics.error.message);
199 if (sks_search == event->value.search.sc)
200 GNUNET_SCHEDULER_add_continuation (&abort_sks_search_task,
201 NULL,
202 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
203 else if (ksk_search == event->value.search.sc)
204 GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task,
205 NULL,
206 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
207 else
208 GNUNET_break (0);
209 break;
210 case GNUNET_FS_STATUS_SEARCH_START:
211 GNUNET_assert ( (NULL == event->value.search.cctx) ||
212 (0 == strcmp ("sks_search", event->value.search.cctx)) ||
213 (0 == strcmp ("ksk_search", event->value.search.cctx)));
214 if (NULL == event->value.search.cctx)
215 {
216 GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx));
217 update_started = GNUNET_YES;
218 }
219 GNUNET_assert (1 == event->value.search.anonymity);
220 break;
221 case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
222 return NULL;
223 case GNUNET_FS_STATUS_SEARCH_STOPPED:
224 return NULL;
225 default:
226 fprintf (stderr,
227 "Unexpected event: %d\n",
228 event->status);
229 break;
230 } 179 }
180 else
181 {
182 fprintf (stderr, "Unexpected search result received!\n");
183 GNUNET_break (0);
184 }
185 break;
186 case GNUNET_FS_STATUS_SEARCH_ERROR:
187 fprintf (stderr,
188 "Error searching file: %s\n",
189 event->value.search.specifics.error.message);
190 if (sks_search == event->value.search.sc)
191 GNUNET_SCHEDULER_add_continuation (&abort_sks_search_task,
192 NULL,
193 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
194 else if (ksk_search == event->value.search.sc)
195 GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task,
196 NULL,
197 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
198 else
199 GNUNET_break (0);
200 break;
201 case GNUNET_FS_STATUS_SEARCH_START:
202 GNUNET_assert ((NULL == event->value.search.cctx) ||
203 (0 == strcmp ("sks_search", event->value.search.cctx)) ||
204 (0 == strcmp ("ksk_search", event->value.search.cctx)));
205 if (NULL == event->value.search.cctx)
206 {
207 GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx));
208 update_started = GNUNET_YES;
209 }
210 GNUNET_assert (1 == event->value.search.anonymity);
211 break;
212 case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
213 return NULL;
214 case GNUNET_FS_STATUS_SEARCH_STOPPED:
215 return NULL;
216 default:
217 fprintf (stderr, "Unexpected event: %d\n", event->status);
218 break;
219 }
231 return event->value.search.cctx; 220 return event->value.search.cctx;
232} 221}
233 222
234 223
235static void 224static void
236publish_cont (void *cls, 225publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
237 const struct GNUNET_FS_Uri *ksk_uri,
238 const char *emsg)
239{ 226{
240 char *msg; 227 char *msg;
241 struct GNUNET_FS_Uri *sks_uri; 228 struct GNUNET_FS_Uri *sks_uri;
242 char sbuf[1024]; 229 char sbuf[1024];
243 struct GNUNET_CRYPTO_HashAsciiEncoded enc; 230 struct GNUNET_CRYPTO_HashAsciiEncoded enc;
244 231
245 if (NULL != emsg) 232 if (NULL != emsg)
246 { 233 {
247 fprintf (stderr, "Error publishing: %s\n", emsg); 234 fprintf (stderr, "Error publishing: %s\n", emsg);
248 err = 1; 235 err = 1;
249 GNUNET_FS_stop (fs); 236 GNUNET_FS_stop (fs);
250 return; 237 return;
251 } 238 }
252 GNUNET_CRYPTO_hash_to_enc (&nsid, 239 GNUNET_CRYPTO_hash_to_enc (&nsid, &enc);
253 &enc); 240 GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", &enc);
254 GNUNET_snprintf (sbuf,
255 sizeof (sbuf),
256 "gnunet://fs/sks/%s/this",
257 &enc);
258 sks_uri = GNUNET_FS_uri_parse (sbuf, &msg); 241 sks_uri = GNUNET_FS_uri_parse (sbuf, &msg);
259 if (msg != NULL) 242 if (msg != NULL)
260 { 243 {
261 fprintf (stderr, "failed to parse URI `%s': %s\n", 244 fprintf (stderr, "failed to parse URI `%s': %s\n", sbuf, msg);
262 sbuf, 245 err = 1;
263 msg); 246 GNUNET_FS_stop (fs);
264 err = 1; 247 GNUNET_free (msg);
265 GNUNET_FS_stop (fs); 248 return;
266 GNUNET_free (msg); 249 }
267 return; 250 ksk_search =
268 } 251 GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
269 ksk_search = GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, "ksk_search"); 252 "ksk_search");
270 sks_search = GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE, "sks_search"); 253 sks_search =
254 GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
255 "sks_search");
271 GNUNET_FS_uri_destroy (sks_uri); 256 GNUNET_FS_uri_destroy (sks_uri);
272} 257}
273 258
274 259
275static void 260static void
276sks_cont (void *cls, 261sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
277 const struct GNUNET_FS_Uri *uri,
278 const char *emsg)
279{ 262{
280 struct GNUNET_CONTAINER_MetaData *meta; 263 struct GNUNET_CONTAINER_MetaData *meta;
281 struct GNUNET_FS_Uri *ksk_uri; 264 struct GNUNET_FS_Uri *ksk_uri;
282 char * msg; 265 char *msg;
283 struct GNUNET_FS_BlockOptions bo; 266 struct GNUNET_FS_BlockOptions bo;
284 267
285 meta = GNUNET_CONTAINER_meta_data_create (); 268 meta = GNUNET_CONTAINER_meta_data_create ();
@@ -290,38 +273,30 @@ sks_cont (void *cls,
290 bo.content_priority = 1; 273 bo.content_priority = 1;
291 bo.anonymity_level = 1; 274 bo.anonymity_level = 1;
292 bo.replication_level = 0; 275 bo.replication_level = 0;
293 bo.expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); 276 bo.expiration_time =
294 GNUNET_FS_publish_ksk (fs, 277 GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
295 ksk_uri, 278 GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo,
296 meta, 279 GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL);
297 uri,
298 &bo,
299 GNUNET_FS_PUBLISH_OPTION_NONE,
300 &publish_cont,
301 NULL);
302 GNUNET_FS_uri_destroy (ksk_uri); 280 GNUNET_FS_uri_destroy (ksk_uri);
303 GNUNET_CONTAINER_meta_data_destroy (meta); 281 GNUNET_CONTAINER_meta_data_destroy (meta);
304} 282}
305 283
306 284
307static void 285static void
308adv_cont (void *cls, 286adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
309 const struct GNUNET_FS_Uri *uri,
310 const char *emsg)
311{ 287{
312 struct GNUNET_CONTAINER_MetaData *meta; 288 struct GNUNET_CONTAINER_MetaData *meta;
313 struct GNUNET_FS_Namespace *ns; 289 struct GNUNET_FS_Namespace *ns;
314 struct GNUNET_FS_BlockOptions bo; 290 struct GNUNET_FS_BlockOptions bo;
315 291
316 if (NULL != emsg) 292 if (NULL != emsg)
317 { 293 {
318 fprintf (stderr, "Error publishing: %s\n", emsg); 294 fprintf (stderr, "Error publishing: %s\n", emsg);
319 err = 1; 295 err = 1;
320 GNUNET_FS_stop (fs); 296 GNUNET_FS_stop (fs);
321 return; 297 return;
322 } 298 }
323 ns = GNUNET_FS_namespace_create (fs, 299 ns = GNUNET_FS_namespace_create (fs, "testNamespace");
324 "testNamespace");
325 GNUNET_assert (NULL != ns); 300 GNUNET_assert (NULL != ns);
326 meta = GNUNET_CONTAINER_meta_data_create (); 301 meta = GNUNET_CONTAINER_meta_data_create ();
327 GNUNET_assert (NULL == emsg); 302 GNUNET_assert (NULL == emsg);
@@ -329,31 +304,21 @@ adv_cont (void *cls,
329 bo.content_priority = 1; 304 bo.content_priority = 1;
330 bo.anonymity_level = 1; 305 bo.anonymity_level = 1;
331 bo.replication_level = 0; 306 bo.replication_level = 0;
332 bo.expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); 307 bo.expiration_time =
333 GNUNET_FS_publish_sks (fs, 308 GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
334 ns, 309 GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri, /* FIXME: this is non-sense (use CHK URI!?) */
335 "this", 310 &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL);
336 "next",
337 meta,
338 uri, /* FIXME: this is non-sense (use CHK URI!?) */
339 &bo,
340 GNUNET_FS_PUBLISH_OPTION_NONE,
341 &sks_cont,
342 NULL);
343 GNUNET_CONTAINER_meta_data_destroy (meta); 311 GNUNET_CONTAINER_meta_data_destroy (meta);
344 GNUNET_FS_namespace_delete (ns, GNUNET_NO); 312 GNUNET_FS_namespace_delete (ns, GNUNET_NO);
345} 313}
346 314
347 315
348static void 316static void
349ns_iterator (void *cls, 317ns_iterator (void *cls, const char *name, const GNUNET_HashCode * id)
350 const char *name,
351 const GNUNET_HashCode *id)
352{ 318{
353 int *ok = cls; 319 int *ok = cls;
354 320
355 if (0 != strcmp (name, 321 if (0 != strcmp (name, "testNamespace"))
356 "testNamespace"))
357 return; 322 return;
358 *ok = GNUNET_YES; 323 *ok = GNUNET_YES;
359 nsid = *id; 324 nsid = *id;
@@ -369,35 +334,30 @@ testNamespace ()
369 struct GNUNET_FS_Uri *ksk_uri; 334 struct GNUNET_FS_Uri *ksk_uri;
370 int ok; 335 int ok;
371 336
372 ns = GNUNET_FS_namespace_create (fs, 337 ns = GNUNET_FS_namespace_create (fs, "testNamespace");
373 "testNamespace");
374 GNUNET_assert (NULL != ns); 338 GNUNET_assert (NULL != ns);
375 ok = GNUNET_NO; 339 ok = GNUNET_NO;
376 GNUNET_FS_namespace_list (fs, &ns_iterator, &ok); 340 GNUNET_FS_namespace_list (fs, &ns_iterator, &ok);
377 if (GNUNET_NO == ok) 341 if (GNUNET_NO == ok)
378 { 342 {
379 fprintf (stderr, "namespace_list failed to find namespace!\n"); 343 fprintf (stderr, "namespace_list failed to find namespace!\n");
380 GNUNET_FS_namespace_delete (ns, GNUNET_YES); 344 GNUNET_FS_namespace_delete (ns, GNUNET_YES);
381 GNUNET_FS_stop (fs); 345 GNUNET_FS_stop (fs);
382 err = 1; 346 err = 1;
383 return; 347 return;
384 } 348 }
385 meta = GNUNET_CONTAINER_meta_data_create (); 349 meta = GNUNET_CONTAINER_meta_data_create ();
386 ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL); 350 ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL);
387 bo.content_priority = 1; 351 bo.content_priority = 1;
388 bo.anonymity_level = 1; 352 bo.anonymity_level = 1;
389 bo.replication_level = 0; 353 bo.replication_level = 0;
390 bo.expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); 354 bo.expiration_time =
391 GNUNET_FS_namespace_advertise (fs, 355 GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
392 ksk_uri, 356 GNUNET_FS_namespace_advertise (fs, ksk_uri, ns, meta, &bo, "root", &adv_cont,
393 ns, 357 NULL);
394 meta, 358 kill_task =
395 &bo, 359 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout,
396 "root", 360 NULL);
397 &adv_cont, NULL);
398 kill_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
399 &do_timeout,
400 NULL);
401 GNUNET_FS_uri_destroy (ksk_uri); 361 GNUNET_FS_uri_destroy (ksk_uri);
402 GNUNET_FS_namespace_delete (ns, GNUNET_NO); 362 GNUNET_FS_namespace_delete (ns, GNUNET_NO);
403 GNUNET_CONTAINER_meta_data_destroy (meta); 363 GNUNET_CONTAINER_meta_data_destroy (meta);
@@ -407,16 +367,13 @@ testNamespace ()
407static void 367static void
408run (void *cls, 368run (void *cls,
409 char *const *args, 369 char *const *args,
410 const char *cfgfile, 370 const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
411 const struct GNUNET_CONFIGURATION_Handle *cfg)
412{ 371{
413 setup_peer (&p1, "test_fs_namespace_data.conf"); 372 setup_peer (&p1, "test_fs_namespace_data.conf");
414 fs = GNUNET_FS_start (cfg, 373 fs = GNUNET_FS_start (cfg,
415 "test-fs-namespace", 374 "test-fs-namespace",
416 &progress_cb, 375 &progress_cb,
417 NULL, 376 NULL, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
418 GNUNET_FS_FLAGS_NONE,
419 GNUNET_FS_OPTIONS_END);
420 testNamespace (); 377 testNamespace ();
421} 378}
422 379
@@ -424,7 +381,7 @@ run (void *cls,
424int 381int
425main (int argc, char *argv[]) 382main (int argc, char *argv[])
426{ 383{
427 char *const argvx[] = { 384 char *const argvx[] = {
428 "test-fs-namespace", 385 "test-fs-namespace",
429 "-c", 386 "-c",
430 "test_fs_namespace_data.conf", 387 "test_fs_namespace_data.conf",
@@ -437,23 +394,22 @@ main (int argc, char *argv[])
437 GNUNET_GETOPT_OPTION_END 394 GNUNET_GETOPT_OPTION_END
438 }; 395 };
439 396
440 GNUNET_log_setup ("test_fs_namespace", 397 GNUNET_log_setup ("test_fs_namespace",
441#if VERBOSE 398#if VERBOSE
442 "DEBUG", 399 "DEBUG",
443#else 400#else
444 "WARNING", 401 "WARNING",
445#endif 402#endif
446 NULL); 403 NULL);
447 GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1, 404 GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
448 argvx, "test-fs-namespace", 405 argvx, "test-fs-namespace",
449 "nohelp", options, &run, NULL); 406 "nohelp", options, &run, NULL);
450 stop_arm (&p1); 407 stop_arm (&p1);
451 if (GNUNET_YES != update_started) 408 if (GNUNET_YES != update_started)
452 { 409 {
453 fprintf (stderr, 410 fprintf (stderr, "Update search never started!\n");
454 "Update search never started!\n"); 411 err = 1;
455 err = 1; 412 }
456 }
457 GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-namespace/"); 413 GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-namespace/");
458 return err; 414 return err;
459} 415}
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-18 23:59:34 +0000