Merge branch 'master' of ssh://gnunet.org/gnunet
[oweals/gnunet.git] / src / util / test_configuration.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2003, 2004, 2005, 2006, 2007 GNUnet e.V.
4
5      GNUnet is free software; you can redistribute it and/or modify
6      it under the terms of the GNU General Public License as published
7      by the Free Software Foundation; either version 3, or (at your
8      option) any later version.
9
10      GNUnet is distributed in the hope that it will be useful, but
11      WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13      General Public License for more details.
14
15      You should have received a copy of the GNU General Public License
16      along with GNUnet; see the file COPYING.  If not, write to the
17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18      Boston, MA 02110-1301, USA.
19 */
20 /**
21  * @file util/test_configuration.c
22  * @brief Test that the configuration module works.
23  * @author Christian Grothoff
24  */
25
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28
29
30 /* Test Configuration Diffs Options */
31 enum
32 {
33   EDIT_NOTHING,
34   EDIT_SECTION,
35   EDIT_ALL,
36   ADD_NEW_SECTION,
37   ADD_NEW_ENTRY,
38   REMOVE_SECTION,
39   REMOVE_ENTRY,
40   COMPARE,
41   PRINT
42 };
43
44 static struct GNUNET_CONFIGURATION_Handle *cfg;
45 static struct GNUNET_CONFIGURATION_Handle *cfg_default;
46
47 struct DiffsCBData
48 {
49   struct GNUNET_CONFIGURATION_Handle *cfg;
50   struct GNUNET_CONFIGURATION_Handle *cfgDiffs;
51   const char *section;
52   int callBackOption;
53   int status;
54 };
55
56
57 static void
58 initDiffsCBData (struct DiffsCBData *cbData)
59 {
60   cbData->section = NULL;
61   cbData->cfg = NULL;
62   cbData->cfgDiffs = NULL;
63   cbData->callBackOption = -1;
64   cbData->status = 0;
65 }
66
67
68 /**
69  * callback function for modifying
70  * and comparing configuration
71 */
72 static void
73 diffsCallBack (void *cls, const char *section, const char *option,
74                const char *value)
75 {
76   struct DiffsCBData *cbData = cls;
77   int cbOption = cbData->callBackOption;
78
79   switch (cbOption)
80   {
81   case EDIT_SECTION:
82     if (NULL == cbData->section)
83       cbData->section = section;
84     if (strcmp (cbData->section, section) == 0)
85     {
86       GNUNET_CONFIGURATION_set_value_string (cbData->cfg, section, option,
87                                              "new-value");
88       GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section, option,
89                                              "new-value");
90     }
91     break;
92   case EDIT_ALL:
93     GNUNET_CONFIGURATION_set_value_string (cbData->cfg, section, option,
94                                            "new-value");
95     GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section, option,
96                                            "new-value");
97     break;
98   case ADD_NEW_ENTRY:
99   {
100     static int hit = 0;
101
102     if (hit == 0)
103     {
104       hit = 1;
105       GNUNET_CONFIGURATION_set_value_string (cbData->cfg, section, "new-key",
106                                              "new-value");
107       GNUNET_CONFIGURATION_set_value_string (cbData->cfgDiffs, section,
108                                              "new-key", "new-value");
109     }
110     break;
111   }
112   case COMPARE:
113   {
114     int ret;
115     char *diffValue;
116
117     diffValue = NULL;
118     ret =
119         GNUNET_CONFIGURATION_get_value_string (cbData->cfgDiffs, section,
120                                                option, &diffValue);
121     if (NULL != diffValue)
122     {
123       if (ret == GNUNET_SYSERR || strcmp (diffValue, value) != 0)
124         cbData->status = 1;
125     }
126     else
127       cbData->status = 1;
128     GNUNET_free_non_null (diffValue);
129     break;
130   }
131 #if 0
132   case PRINT:
133     if (NULL == cbData->section)
134     {
135       cbData->section = section;
136       printf ("\nSection: %s\n", section);
137     }
138     else if (strcmp (cbData->section, section) != 0)
139     {
140       cbData->section = section;
141       printf ("\nSection: %s\n", section);
142     }
143     printf ("%s = %s\n", option, value);
144 #endif
145   default:
146     break;
147   }
148 }
149
150
151 static struct GNUNET_CONFIGURATION_Handle *
152 editConfiguration (struct GNUNET_CONFIGURATION_Handle *cfg, int option)
153 {
154   struct DiffsCBData diffsCB;
155
156   initDiffsCBData (&diffsCB);
157   diffsCB.cfgDiffs = GNUNET_CONFIGURATION_create ();
158
159   switch (option)
160   {
161   case EDIT_SECTION:
162   case EDIT_ALL:
163   case ADD_NEW_ENTRY:
164     diffsCB.callBackOption = option;
165     diffsCB.cfg = cfg;
166     GNUNET_CONFIGURATION_iterate (cfg, diffsCallBack, &diffsCB);
167     break;
168   case EDIT_NOTHING:
169     /* Do nothing */
170     break;
171   case ADD_NEW_SECTION:
172   {
173     int i;
174     char *key;
175
176     for (i = 0; i < 5; i++)
177     {
178       GNUNET_asprintf (&key, "key%d", i);
179       GNUNET_CONFIGURATION_set_value_string (cfg, "new-section", key,
180                                              "new-value");
181       GNUNET_CONFIGURATION_set_value_string (diffsCB.cfgDiffs, "new-section",
182                                              key, "new-value");
183       GNUNET_free (key);
184     }
185     break;
186   }
187   case REMOVE_SECTION:
188     break;
189   case REMOVE_ENTRY:
190     break;
191   default:
192     break;
193   }
194
195   return diffsCB.cfgDiffs;
196 }
197
198 /**
199  * Checking configuration diffs
200  */
201 static int
202 checkDiffs (struct GNUNET_CONFIGURATION_Handle *cfg_default, int option)
203 {
204   struct GNUNET_CONFIGURATION_Handle *cfg;
205   struct GNUNET_CONFIGURATION_Handle *cfgDiffs;
206   struct DiffsCBData cbData;
207   int ret;
208   char *diffsFileName;
209
210   initDiffsCBData (&cbData);
211
212   cfg = GNUNET_CONFIGURATION_create ();
213   /* load defaults */
214   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (cfg, NULL));
215
216   /* Modify configuration and save it */
217   cfgDiffs = editConfiguration (cfg, option);
218   diffsFileName = GNUNET_DISK_mktemp ("gnunet-test-configurations-diffs.conf");
219   if (diffsFileName == NULL)
220   {
221     GNUNET_break (0);
222     GNUNET_CONFIGURATION_destroy (cfg);
223     GNUNET_CONFIGURATION_destroy (cfgDiffs);
224     return 1;
225   }
226   GNUNET_CONFIGURATION_write_diffs (cfg_default, cfg, diffsFileName);
227   GNUNET_CONFIGURATION_destroy (cfg);
228
229   /* Compare the dumped configuration with modifications done */
230   cfg = GNUNET_CONFIGURATION_create ();
231   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, diffsFileName));
232   if (0 != remove (diffsFileName))
233     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "remove", diffsFileName);
234   cbData.callBackOption = COMPARE;
235   cbData.cfgDiffs = cfgDiffs;
236   GNUNET_CONFIGURATION_iterate (cfg, diffsCallBack, &cbData);
237   if (1 == (ret = cbData.status))
238   {
239     FPRINTF (stderr, "%s",
240              "Incorrect Configuration Diffs: Diffs may contain data not actually edited\n");
241     goto housekeeping;
242   }
243   cbData.cfgDiffs = cfg;
244   GNUNET_CONFIGURATION_iterate (cfgDiffs, diffsCallBack, &cbData);
245   if ((ret = cbData.status) == 1)
246     FPRINTF (stderr, "%s",
247              "Incorrect Configuration Diffs: Data may be missing in diffs\n");
248
249 housekeeping:
250 #if 0
251   cbData.section = NULL;
252   cbData.callBackOption = PRINT;
253   printf ("\nExpected Diffs:\n");
254   GNUNET_CONFIGURATION_iterate (cfgDiffs, diffsCallBack, &cbData);
255   cbData.section = NULL;
256   printf ("\nActual Diffs:\n");
257   GNUNET_CONFIGURATION_iterate (cfg, diffsCallBack, &cbData);
258 #endif
259   GNUNET_CONFIGURATION_destroy (cfg);
260   GNUNET_CONFIGURATION_destroy (cfgDiffs);
261   GNUNET_free (diffsFileName);
262   return ret;
263 }
264
265
266 static int
267 testConfig ()
268 {
269   char *c;
270   unsigned long long l;
271
272   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "test", "b", &c))
273     return 1;
274   if (0 != strcmp ("b", c))
275   {
276     FPRINTF (stderr, "Got `%s'\n", c);
277     GNUNET_free (c);
278     return 2;
279   }
280   GNUNET_free (c);
281   if (GNUNET_OK !=
282       GNUNET_CONFIGURATION_get_value_number (cfg, "test", "five", &l))
283   {
284     GNUNET_break (0);
285     return 3;
286   }
287   if (5 != l)
288   {
289     GNUNET_break (0);
290     return 4;
291   }
292   GNUNET_CONFIGURATION_set_value_string (cfg, "more", "c", "YES");
293   if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_yesno (cfg, "more", "c"))
294   {
295     GNUNET_break (0);
296     return 5;
297   }
298   GNUNET_CONFIGURATION_set_value_number (cfg, "NUMBERS", "TEN", 10);
299   if (GNUNET_OK !=
300       GNUNET_CONFIGURATION_get_value_string (cfg, "NUMBERS", "TEN", &c))
301   {
302     GNUNET_break (0);
303     return 6;
304   }
305   if (0 != strcmp (c, "10"))
306   {
307     GNUNET_free (c);
308     GNUNET_break (0);
309     return 7;
310   }
311   GNUNET_free (c);
312
313   if (GNUNET_OK !=
314       GNUNET_CONFIGURATION_get_value_filename (cfg, "last", "test", &c))
315   {
316     GNUNET_break (0);
317     return 8;
318   }
319 #ifndef MINGW
320   if (0 != strcmp (c, "/hello/world"))
321 #else
322 #define HI "\\hello\\world"
323   if (strstr (c, HI) != c + strlen (c) - strlen (HI))
324 #endif
325   {
326     GNUNET_break (0);
327     GNUNET_free (c);
328     return 9;
329   }
330   GNUNET_free (c);
331
332   if (GNUNET_OK !=
333       GNUNET_CONFIGURATION_get_value_size (cfg, "last", "size", &l))
334   {
335     GNUNET_break (0);
336     return 10;
337   }
338   if (l != 512 * 1024)
339   {
340     GNUNET_break (0);
341     return 11;
342   }
343   return 0;
344 }
345
346 static const char *want[] = {
347   "/Hello",
348   "/File Name",
349   "/World",
350   NULL,
351   NULL,
352 };
353
354 static int
355 check (void *data, const char *fn)
356 {
357   int *idx = data;
358
359   if (0 == strcmp (want[*idx], fn))
360   {
361     (*idx)++;
362     return GNUNET_OK;
363   }
364   GNUNET_break (0);
365   return GNUNET_SYSERR;
366 }
367
368 static int
369 testConfigFilenames ()
370 {
371   int idx;
372
373   idx = 0;
374   if (3 !=
375       GNUNET_CONFIGURATION_iterate_value_filenames (cfg, "FILENAMES", "test",
376                                                     &check, &idx))
377   {
378     GNUNET_break (0);
379     return 8;
380   }
381   if (idx != 3)
382     return 16;
383   if (GNUNET_OK !=
384       GNUNET_CONFIGURATION_remove_value_filename (cfg, "FILENAMES", "test",
385                                                   "/File Name"))
386   {
387     GNUNET_break (0);
388     return 24;
389   }
390
391   if (GNUNET_NO !=
392       GNUNET_CONFIGURATION_remove_value_filename (cfg, "FILENAMES", "test",
393                                                   "/File Name"))
394   {
395     GNUNET_break (0);
396     return 32;
397   }
398   if (GNUNET_NO !=
399       GNUNET_CONFIGURATION_remove_value_filename (cfg, "FILENAMES", "test",
400                                                   "Stuff"))
401   {
402     GNUNET_break (0);
403     return 40;
404   }
405
406   if (GNUNET_NO !=
407       GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
408                                                   "/Hello"))
409   {
410     GNUNET_break (0);
411     return 48;
412   }
413   if (GNUNET_NO !=
414       GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
415                                                   "/World"))
416   {
417     GNUNET_break (0);
418     return 56;
419   }
420
421   if (GNUNET_YES !=
422       GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
423                                                   "/File 1"))
424   {
425     GNUNET_break (0);
426     return 64;
427   }
428
429   if (GNUNET_YES !=
430       GNUNET_CONFIGURATION_append_value_filename (cfg, "FILENAMES", "test",
431                                                   "/File 2"))
432   {
433     GNUNET_break (0);
434     return 72;
435   }
436
437   idx = 0;
438   want[1] = "/World";
439   want[2] = "/File 1";
440   want[3] = "/File 2";
441   if (4 !=
442       GNUNET_CONFIGURATION_iterate_value_filenames (cfg, "FILENAMES", "test",
443                                                     &check, &idx))
444   {
445     GNUNET_break (0);
446     return 80;
447   }
448   if (idx != 4)
449   {
450     GNUNET_break (0);
451     return 88;
452   }
453   return 0;
454 }
455
456
457 int
458 main (int argc, char *argv[])
459 {
460   int failureCount = 0;
461   char *c;
462
463   GNUNET_log_setup ("test_configuration", "WARNING", NULL);
464   cfg = GNUNET_CONFIGURATION_create ();
465   GNUNET_assert (cfg != NULL);
466   if (GNUNET_OK !=
467       GNUNET_CONFIGURATION_parse (cfg, "test_configuration_data.conf"))
468   {
469     FPRINTF (stderr, "%s",  "Failed to parse configuration file\n");
470     GNUNET_CONFIGURATION_destroy (cfg);
471     return 1;
472   }
473   failureCount += testConfig ();
474   if (failureCount > 0)
475     goto error;
476
477   failureCount = testConfigFilenames ();
478   if (failureCount > 0)
479     goto error;
480
481   if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg, "/tmp/gnunet-test.conf"))
482   {
483     FPRINTF (stderr, "%s",  "Failed to write configuration file\n");
484     GNUNET_CONFIGURATION_destroy (cfg);
485     return 1;
486   }
487   GNUNET_CONFIGURATION_destroy (cfg);
488   GNUNET_assert (0 == UNLINK ("/tmp/gnunet-test.conf"));
489
490   cfg = GNUNET_CONFIGURATION_create ();
491   if (GNUNET_OK !=
492       GNUNET_CONFIGURATION_load (cfg, "test_configuration_data.conf"))
493   {
494     GNUNET_break (0);
495     GNUNET_CONFIGURATION_destroy (cfg);
496     return 1;
497   }
498   if (GNUNET_OK !=
499       GNUNET_CONFIGURATION_get_value_string (cfg, "TESTING", "WEAKRANDOM", &c))
500   {
501     GNUNET_break (0);
502     GNUNET_CONFIGURATION_destroy (cfg);
503     return 1;
504   }
505   if (0 != strcmp (c, "YES"))
506   {
507     GNUNET_break (0);
508     GNUNET_free (c);
509     GNUNET_CONFIGURATION_destroy (cfg);
510     return 1;
511   }
512
513   GNUNET_free (c);
514   GNUNET_CONFIGURATION_destroy (cfg);
515
516   /* Testing configuration diffs */
517   cfg_default = GNUNET_CONFIGURATION_create ();
518   if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg_default, NULL))
519   {
520     GNUNET_break (0);
521     GNUNET_CONFIGURATION_destroy (cfg_default);
522     return 1;
523   }
524
525   /* Nothing changed in the new configuration */
526   failureCount += checkDiffs (cfg_default, EDIT_NOTHING);
527
528   /* Modify all entries of the last section */
529   failureCount += checkDiffs (cfg_default, EDIT_SECTION);
530
531   /* Add a new section */
532   failureCount += checkDiffs (cfg_default, ADD_NEW_SECTION);
533
534   /* Add a new entry to the last section */
535   failureCount += checkDiffs (cfg_default, ADD_NEW_ENTRY);
536
537   /* Modify all entries in the configuration */
538   failureCount += checkDiffs (cfg_default, EDIT_ALL);
539
540   GNUNET_CONFIGURATION_destroy (cfg_default);
541
542 error:
543   if (failureCount != 0)
544   {
545     FPRINTF (stderr, "Test failed: %u\n", failureCount);
546     return 1;
547   }
548   return 0;
549 }