Add additional namespaces for Google Talk which are used for the gmail client.
[asterisk/asterisk.git] / tests / test_config.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2010, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \brief Configuration unit tests
22  *
23  * \author Mark Michelson <mmichelson@digium.com>
24  *
25  */
26
27 /*** MODULEINFO
28         <depend>TEST_FRAMEWORK</depend>
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$");
35
36 #include <math.h> /* HUGE_VAL */
37
38 #include "asterisk/config.h"
39 #include "asterisk/module.h"
40 #include "asterisk/test.h"
41 #include "asterisk/paths.h"
42 #include "asterisk/config_options.h"
43 #include "asterisk/netsock2.h"
44 #include "asterisk/acl.h"
45 #include "asterisk/frame.h"
46 #include "asterisk/utils.h"
47 #include "asterisk/logger.h"
48
49 #define CONFIG_FILE "test_config.conf"
50
51 /*
52  * This builds the folowing config:
53  * [Capitals]
54  * Germany = Berlin
55  * China = Beijing
56  * Canada = Ottawa
57  *
58  * [Protagonists]
59  * 1984 = Winston Smith
60  * Green Eggs And Ham = Sam I Am
61  * The Kalevala = Vainamoinen
62  *
63  * This config is used for all tests below.
64  */
65 const char cat1[] = "Capitals";
66 const char cat1varname1[] = "Germany";
67 const char cat1varvalue1[] = "Berlin";
68 const char cat1varname2[] = "China";
69 const char cat1varvalue2[] = "Beijing";
70 const char cat1varname3[] = "Canada";
71 const char cat1varvalue3[] = "Ottawa";
72
73 const char cat2[] = "Protagonists";
74 const char cat2varname1[] = "1984";
75 const char cat2varvalue1[] = "Winston Smith";
76 const char cat2varname2[] = "Green Eggs And Ham";
77 const char cat2varvalue2[] = "Sam I Am";
78 const char cat2varname3[] = "The Kalevala";
79 const char cat2varvalue3[] = "Vainamoinen";
80
81 struct pair {
82         const char *name;
83         const char *val;
84 };
85
86 struct association {
87         const char *category;
88         struct pair vars[3];
89 } categories [] = {
90         { cat1,
91                 {
92                         { cat1varname1, cat1varvalue1 },
93                         { cat1varname2, cat1varvalue2 },
94                         { cat1varname3, cat1varvalue3 },
95                 }
96         },
97         { cat2,
98                 {
99                         { cat2varname1, cat2varvalue1 },
100                         { cat2varname2, cat2varvalue2 },
101                         { cat2varname3, cat2varvalue3 },
102                 }
103         },
104 };
105
106 /*!
107  * \brief Build ast_config struct from above definitions
108  *
109  * \retval NULL Failed to build the config
110  * \retval non-NULL An ast_config struct populated with data
111  */
112 static struct ast_config *build_cfg(void)
113 {
114         struct ast_config *cfg;
115         struct association *cat_iter;
116         struct pair *var_iter;
117         size_t i;
118         size_t j;
119
120         cfg = ast_config_new();
121         if (!cfg) {
122                 goto fail;
123         }
124
125         for (i = 0; i < ARRAY_LEN(categories); ++i) {
126                 struct ast_category *cat;
127                 cat_iter = &categories[i];
128
129                 cat = ast_category_new(cat_iter->category, "", 999999);
130                 if (!cat) {
131                         goto fail;
132                 }
133                 ast_category_append(cfg, cat);
134
135                 for (j = 0; j < ARRAY_LEN(cat_iter->vars); ++j) {
136                         struct ast_variable *var;
137                         var_iter = &cat_iter->vars[j];
138
139                         var = ast_variable_new(var_iter->name, var_iter->val, "");
140                         if (!var) {
141                                 goto fail;
142                         }
143                         ast_variable_append(cat, var);
144                 }
145         }
146
147         return cfg;
148
149 fail:
150         ast_config_destroy(cfg);
151         return NULL;
152 }
153
154 /*!
155  * \brief Tests that the contents of an ast_config is what is expected
156  *
157  * \param cfg Config to test
158  * \retval -1 Failed to pass a test
159  * \retval 0 Config passes checks
160  */
161 static int test_config_validity(struct ast_config *cfg)
162 {
163         int i;
164         const char *cat_iter = NULL;
165         /* Okay, let's see if the correct content is there */
166         for (i = 0; i < ARRAY_LEN(categories); ++i) {
167                 struct ast_variable *var = NULL;
168                 size_t j;
169                 cat_iter = ast_category_browse(cfg, cat_iter);
170                 if (strcmp(cat_iter, categories[i].category)) {
171                         ast_log(LOG_ERROR, "Category name mismatch, %s does not match %s\n", cat_iter, categories[i].category);
172                         return -1;
173                 }
174                 for (j = 0; j < ARRAY_LEN(categories[i].vars); ++j) {
175                         var = var ? var->next : ast_variable_browse(cfg, cat_iter);
176                         if (strcmp(var->name, categories[i].vars[j].name)) {
177                                 ast_log(LOG_ERROR, "Variable name mismatch, %s does not match %s\n", var->name, categories[i].vars[j].name);
178                                 return -1;
179                         }
180                         if (strcmp(var->value, categories[i].vars[j].val)) {
181                                 ast_log(LOG_ERROR, "Variable value mismatch, %s does not match %s\n", var->value, categories[i].vars[j].val);
182                                 return -1;
183                         }
184                 }
185         }
186         return 0;
187 }
188
189 AST_TEST_DEFINE(copy_config)
190 {
191         enum ast_test_result_state res = AST_TEST_FAIL;
192         struct ast_config *cfg = NULL;
193         struct ast_config *copy = NULL;
194
195         switch (cmd) {
196         case TEST_INIT:
197                 info->name = "copy_config";
198                 info->category = "/main/config/";
199                 info->summary = "Test copying configuration";
200                 info->description =
201                         "Ensure that variables and categories are copied correctly";
202                 return AST_TEST_NOT_RUN;
203         case TEST_EXECUTE:
204                 break;
205         }
206
207         cfg = build_cfg();
208         if (!cfg) {
209                 goto out;
210         }
211
212         copy = ast_config_copy(cfg);
213         if (!copy) {
214                 goto out;
215         }
216
217         if (test_config_validity(copy) != 0) {
218                 goto out;
219         }
220
221         res = AST_TEST_PASS;
222
223 out:
224         ast_config_destroy(cfg);
225         ast_config_destroy(copy);
226         return res;
227 }
228
229 /*!
230  * \brief Write the config file to disk
231  *
232  * This is necessary for testing config hooks since
233  * they are only triggered when a config is read from
234  * its intended storage medium
235  */
236 static int write_config_file(void)
237 {
238         int i;
239         FILE *config_file;
240         char filename[PATH_MAX];
241
242         snprintf(filename, sizeof(filename), "%s/%s",
243                         ast_config_AST_CONFIG_DIR, CONFIG_FILE);
244         config_file = fopen(filename, "w");
245
246         if (!config_file) {
247                 return -1;
248         }
249
250         for (i = 0; i < ARRAY_LEN(categories); ++i) {
251                 int j;
252                 fprintf(config_file, "[%s]\n", categories[i].category);
253                 for (j = 0; j < ARRAY_LEN(categories[i].vars); ++j) {
254                         fprintf(config_file, "%s = %s\n",
255                                         categories[i].vars[j].name,
256                                         categories[i].vars[j].val);
257                 }
258         }
259
260         fclose(config_file);
261         return 0;
262 }
263
264 /*!
265  * \brief Delete config file created by write_config_file
266  */
267 static void delete_config_file(void)
268 {
269         char filename[PATH_MAX];
270         snprintf(filename, sizeof(filename), "%s/%s",
271                         ast_config_AST_CONFIG_DIR, CONFIG_FILE);
272         unlink(filename);
273 }
274
275 /*
276  * Boolean to indicate if the config hook has run
277  */
278 static int hook_run;
279
280 /*
281  * Boolean to indicate if, when the hook runs, the
282  * data passed to it is what is expected
283  */
284 static int hook_config_sane;
285
286 static int hook_cb(struct ast_config *cfg)
287 {
288         hook_run = 1;
289         if (test_config_validity(cfg) == 0) {
290                 hook_config_sane = 1;
291         }
292         ast_config_destroy(cfg);
293         return 0;
294 }
295
296 AST_TEST_DEFINE(config_hook)
297 {
298         enum ast_test_result_state res = AST_TEST_FAIL;
299         enum config_hook_flags hook_flags = { 0, };
300         struct ast_flags config_flags = { CONFIG_FLAG_FILEUNCHANGED };
301         struct ast_config *cfg;
302
303         switch (cmd) {
304         case TEST_INIT:
305                 info->name = "config_hook";
306                 info->category = "/main/config/";
307                 info->summary = "Test config hooks";
308                 info->description =
309                         "Ensure that config hooks are called at approriate times,"
310                         "not called at inappropriate times, and that all information"
311                         "that should be present is present.";
312                 return AST_TEST_NOT_RUN;
313         case TEST_EXECUTE:
314                 break;
315         }
316
317         write_config_file();
318
319         /*
320          * Register a config hook to run when CONFIG_FILE is loaded by this module
321          */
322         ast_config_hook_register("test_hook",
323                         CONFIG_FILE,
324                         AST_MODULE,
325                         hook_flags,
326                         hook_cb);
327
328         /*
329          * Try loading the config file. This should result in the hook
330          * being called
331          */
332         cfg = ast_config_load(CONFIG_FILE, config_flags);
333         ast_config_destroy(cfg);
334         if (!hook_run || !hook_config_sane) {
335                 ast_test_status_update(test, "Config hook either did not run or was given bad data!\n");
336                 goto out;
337         }
338
339         /*
340          * Now try loading the wrong config file but from the right module.
341          * Hook should not run
342          */
343         hook_run = 0;
344         cfg = ast_config_load("asterisk.conf", config_flags);
345         ast_config_destroy(cfg);
346         if (hook_run) {
347                 ast_test_status_update(test, "Config hook ran even though an incorrect file was specified.\n");
348                 goto out;
349         }
350
351         /*
352          * Now try loading the correct config file but from the wrong module.
353          * Hook should not run
354          */
355         hook_run = 0;
356         cfg = ast_config_load2(CONFIG_FILE, "fake_module.so", config_flags);
357         ast_config_destroy(cfg);
358         if (hook_run) {
359                 ast_test_status_update(test, "Config hook ran even though an incorrect module was specified.\n");
360                 goto out;
361         }
362
363         /*
364          * Now try loading the file correctly, but without any changes to the file.
365          * Hook should not run
366          */
367         hook_run = 0;
368         cfg = ast_config_load(CONFIG_FILE, config_flags);
369         /* Only destroy this cfg conditionally. Otherwise a crash happens. */
370         if (cfg != CONFIG_STATUS_FILEUNCHANGED) {
371                 ast_config_destroy(cfg);
372         }
373         if (hook_run) {
374                 ast_test_status_update(test, "Config hook ran even though file contents had not changed\n");
375                 goto out;
376         }
377
378         res = AST_TEST_PASS;
379
380 out:
381         delete_config_file();
382         return res;
383 }
384
385 enum {
386         EXPECT_FAIL = 0,
387         EXPECT_SUCCEED,
388 };
389
390 #define TOOBIG_I32 "2147483649"
391 #define TOOSMALL_I32 "-2147483649"
392 #define TOOBIG_U32 "4294967297"
393 #define TOOSMALL_U32 "-4294967297"
394 #define DEFAULTVAL 42
395 #define EPSILON 0.001
396
397 #define TEST_PARSE(input, should_succeed, expected_result, flags, result, ...) do {\
398         int __res = ast_parse_arg(input, (flags), result, ##__VA_ARGS__); \
399         if (!__res == !should_succeed) { \
400                 ast_test_status_update(test, "ast_parse_arg failed on '%s'. %d/%d\n", input, __res, should_succeed); \
401                 ret = AST_TEST_FAIL; \
402         } else { \
403                 if (((flags) & PARSE_TYPE) == PARSE_INT32) { \
404                         int32_t *r = (int32_t *) (void *) result; \
405                         int32_t e = (int32_t) expected_result; \
406                         if (*r != e) { \
407                                 ast_test_status_update(test, "ast_parse_arg int32_t failed with %d != %d\n", *r, e); \
408                                 ret = AST_TEST_FAIL; \
409                         } \
410                 } else if (((flags) & PARSE_TYPE) == PARSE_UINT32) { \
411                         uint32_t *r = (uint32_t *) (void *) result; \
412                         uint32_t e = (uint32_t) expected_result; \
413                         if (*r != e) { \
414                                 ast_test_status_update(test, "ast_parse_arg uint32_t failed with %u != %u\n", *r, e); \
415                                 ret = AST_TEST_FAIL; \
416                         } \
417                 } else if (((flags) & PARSE_TYPE) == PARSE_DOUBLE) { \
418                         double *r = (double *) (void *) result; \
419                         double e = (double) expected_result; \
420                         if (fabs(*r - e) > EPSILON) { \
421                                 ast_test_status_update(test, "ast_parse_arg double failed with %f != %f\n", *r, e); \
422                                 ret = AST_TEST_FAIL; \
423                         } \
424                 } \
425         } \
426         *(result) = DEFAULTVAL; \
427 } while (0)
428
429 AST_TEST_DEFINE(ast_parse_arg_test)
430 {
431         int ret = AST_TEST_PASS;
432         int32_t int32_t_val = DEFAULTVAL;
433         uint32_t uint32_t_val = DEFAULTVAL;
434         double double_val = DEFAULTVAL;
435
436         switch (cmd) {
437         case TEST_INIT:
438                 info->name = "ast_parse_arg";
439                 info->category = "/config/";
440                 info->summary = "Test the output of ast_parse_arg";
441                 info->description =
442                         "Ensures that ast_parse_arg behaves as expected";
443                 return AST_TEST_NOT_RUN;
444         case TEST_EXECUTE:
445                 break;
446         }
447
448         /* int32 testing */
449         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32, &int32_t_val);
450         TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32, &int32_t_val);
451         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32, &int32_t_val);
452         TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32, &int32_t_val);
453         TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32, &int32_t_val);
454         TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32, &int32_t_val);
455         TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32, &int32_t_val);
456         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
457         TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
458         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
459         TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
460         TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
461         TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
462         TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
463
464         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, 0, 200);
465         TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, -200, 100);
466         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, -1, 0);
467         TEST_PARSE("123", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, 0, 122);
468         TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, -122, 100);
469         TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, 1, 100);
470         TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, INT_MIN, INT_MAX);
471         TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, INT_MIN, INT_MAX);
472         TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, INT_MIN, INT_MAX);
473         TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, INT_MIN, INT_MAX);
474         TEST_PARSE("123", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, 0, 200);
475         TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, -200, 100);
476         TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, -1, 0);
477         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, 0, 122);
478         TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, -122, 100);
479         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, 1, 100);
480         TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, INT_MIN, INT_MAX);
481         TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, INT_MIN, INT_MAX);
482         TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, INT_MIN, INT_MAX);
483         TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, INT_MIN, INT_MAX);
484
485         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, 0, 200);
486         TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, -200, 100);
487         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, -1, 0);
488         TEST_PARSE("123", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, 0, 122);
489         TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, -122, 100);
490         TEST_PARSE("0", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, 1, 100);
491         TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
492         TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
493         TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
494         TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
495         TEST_PARSE("123", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, 0, 200);
496         TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, -200, 100);
497         TEST_PARSE("0", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, -1, 0);
498         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, 0, 122);
499         TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, -122, 100);
500         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, 1, 100);
501         TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
502         TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
503         TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
504         TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
505
506         /* uuint32 testing */
507         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32, &uint32_t_val);
508         TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
509         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32, &uint32_t_val);
510         TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
511         TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
512         TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
513         TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
514
515         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
516         TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
517         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
518         TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
519         TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
520         TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
521         TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
522
523         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, 0, 200);
524         TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, 0, 200);
525         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, 0, 1);
526
527         TEST_PARSE("123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, 0, 122);
528         TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, 1, 100);
529         TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
530         TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
531         TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
532         TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
533
534         TEST_PARSE("123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, 0, 200);
535         TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, 0, 200);
536         TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, 0, 1);
537
538         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, 0, 122);
539         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, 1, 100);
540         TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
541         TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
542         TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
543         TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
544
545         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, 0, 200);
546         TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, 0, 200);
547         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, 0, 1);
548         TEST_PARSE("123", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, 0, 122);
549         TEST_PARSE("0", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, 1, 100);
550         TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
551         TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
552         TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
553         TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
554         TEST_PARSE("123", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, 0, 200);
555         TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, 0, 100);
556         TEST_PARSE("0", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, 0, 1);
557         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, 0, 122);
558         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, 1, 100);
559         TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
560         TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
561         TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
562         TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
563
564         TEST_PARSE("   -123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
565
566         /* double testing */
567         TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_DOUBLE, &double_val);
568         TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE, &double_val);
569         TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_DOUBLE, &double_val);
570         TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE, &double_val);
571         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE, &double_val);
572         TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE, &double_val);
573         TEST_PARSE("7.0not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE, &double_val);
574         TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE | PARSE_DEFAULT, &double_val, 7.0);
575         TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE | PARSE_DEFAULT, &double_val, 7.0);
576         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE | PARSE_DEFAULT, &double_val, 7.0);
577         TEST_PARSE("not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT, &double_val, 7.0);
578         TEST_PARSE("7.0not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT, &double_val, 7.0);
579
580         TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, 0.0, 200.0);
581         TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, -200.0, 100.0);
582         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, -1.0, 0.0);
583         TEST_PARSE("123.123", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, 0.0, 122.0);
584         TEST_PARSE("-123.123", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, -122.0, 100.0);
585         TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, 1.0, 100.0);
586         TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, -HUGE_VAL, HUGE_VAL);
587         TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, -HUGE_VAL, HUGE_VAL);
588         TEST_PARSE("123.123", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, 0.0, 200.0);
589         TEST_PARSE("-123.123", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, -200.0, 100.0);
590         TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, -1.0, 0.0);
591         TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, 0.0, 122.0);
592         TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, -122.0, 100.0);
593         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, 1.0, 100.0);
594         TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, -HUGE_VAL, HUGE_VAL);
595         TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, -HUGE_VAL, HUGE_VAL);
596
597         TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, 0.0, 200.0);
598         TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, -200.0, 100.0);
599         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, -1.0, 0.0);
600         TEST_PARSE("123.123", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, 0.0, 122.0);
601         TEST_PARSE("-123.123", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, -122.0, 100.0);
602         TEST_PARSE("0", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, 1.0, 100.0);
603         TEST_PARSE("not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, -HUGE_VAL, HUGE_VAL);
604         TEST_PARSE("7not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, -HUGE_VAL, HUGE_VAL);
605         TEST_PARSE("123.123", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, 0.0, 200.0);
606         TEST_PARSE("-123.123", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, -200.0, 100.0);
607         TEST_PARSE("0", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, -1.0, 0.0);
608         TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, 0.0, 122.0);
609         TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, -122.0, 100.0);
610         TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, 1.0, 100.0);
611         TEST_PARSE("not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, -HUGE_VAL, HUGE_VAL);
612         TEST_PARSE("7not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, -HUGE_VAL, HUGE_VAL);
613
614         /* ast_sockaddr_parse is tested extensively in test_netsock2.c and PARSE_ADDR is a very simple wrapper */
615
616         return ret;
617 }
618 struct test_item {
619         AST_DECLARE_STRING_FIELDS(
620                 AST_STRING_FIELD(name);
621                 AST_STRING_FIELD(stropt);
622         );
623         int32_t intopt;
624         uint32_t uintopt;
625         unsigned int flags;
626         double doubleopt;
627         struct ast_sockaddr sockaddropt;
628         int boolopt;
629         struct ast_ha *aclopt;
630         struct ast_codec_pref codecprefopt;
631         struct ast_format_cap *codeccapopt;
632         unsigned int customopt:1;
633 };
634 struct test_config {
635         struct test_item *global;
636         struct test_item *global_defaults;
637         struct ao2_container *items;
638 };
639
640 static int test_item_hash(const void *obj, const int flags)
641 {
642         const struct test_item *item = obj;
643         const char *name = (flags & OBJ_KEY) ? obj : item->name;
644         return ast_str_case_hash(name);
645 }
646 static int test_item_cmp(void *obj, void *arg, int flags)
647 {
648         struct test_item *one = obj, *two = arg;
649         const char *match = (flags & OBJ_KEY) ? arg : two->name;
650         return strcasecmp(one->name, match) ? 0 : (CMP_MATCH | CMP_STOP);
651 }
652 static void test_item_destructor(void *obj)
653 {
654         struct test_item *item = obj;
655         ast_string_field_free_memory(item);
656         if (item->codeccapopt) {
657                 ast_format_cap_destroy(item->codeccapopt);
658         }
659         if (item->aclopt) {
660                 ast_free_ha(item->aclopt);
661         }
662         return;
663 }
664 static void *test_item_alloc(const char *cat)
665 {
666         struct test_item *item;
667         if (!(item = ao2_alloc(sizeof(*item), test_item_destructor))) {
668                 return NULL;
669         }
670         if (ast_string_field_init(item, 128)) {
671                 ao2_ref(item, -1);
672                 return NULL;
673         }
674         if (!(item->codeccapopt = ast_format_cap_alloc())) {
675                 ao2_ref(item, -1);
676                 return NULL;
677         }
678         ast_string_field_set(item, name, cat);
679         return item;
680 }
681 static void test_config_destructor(void *obj)
682 {
683         struct test_config *cfg = obj;
684         ao2_cleanup(cfg->global);
685         ao2_cleanup(cfg->global_defaults);
686         ao2_cleanup(cfg->items);
687 }
688 static void *test_config_alloc(void)
689 {
690         struct test_config *cfg;
691         if (!(cfg = ao2_alloc(sizeof(*cfg), test_config_destructor))) {
692                 goto error;
693         }
694         if (!(cfg->global = test_item_alloc("global"))) {
695                 goto error;
696         }
697         if (!(cfg->global_defaults = test_item_alloc("global_defaults"))) {
698                 goto error;
699         }
700         if (!(cfg->items = ao2_container_alloc(1, test_item_hash, test_item_cmp))) {
701                 goto error;
702         }
703         return cfg;
704 error:
705         ao2_cleanup(cfg);
706         return NULL;
707 }
708 static void *test_item_find(struct ao2_container *container, const char *cat)
709 {
710         return ao2_find(container, cat, OBJ_KEY);
711 }
712
713 static int customopt_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
714 {
715         struct test_item *item = obj;
716         if (!strcasecmp(var->name, "customopt")) {
717                 item->customopt = ast_true(var->value);
718         } else {
719                 return -1;
720         }
721
722         return 0;
723 }
724
725 static struct aco_type global = {
726         .type = ACO_GLOBAL,
727         .item_offset = offsetof(struct test_config, global),
728         .category_match = ACO_WHITELIST,
729         .category = "^global$",
730 };
731 static struct aco_type global_defaults = {
732         .type = ACO_GLOBAL,
733         .item_offset = offsetof(struct test_config, global_defaults),
734         .category_match = ACO_WHITELIST,
735         .category = "^global_defaults$",
736 };
737 static struct aco_type item = {
738         .type = ACO_ITEM,
739         .category_match = ACO_BLACKLIST,
740         .category = "^(global|global_defaults)$",
741         .item_alloc = test_item_alloc,
742         .item_find = test_item_find,
743         .item_offset = offsetof(struct test_config, items),
744 };
745
746 struct aco_file config_test_conf = {
747         .filename = "config_test.conf",
748         .types = ACO_TYPES(&global, &global_defaults, &item),
749 };
750
751 static AO2_GLOBAL_OBJ_STATIC(global_obj);
752 CONFIG_INFO_STANDARD(cfg_info, global_obj, test_config_alloc,
753         .files = ACO_FILES(&config_test_conf),
754 );
755
756 AST_TEST_DEFINE(config_options_test)
757 {
758         int res = AST_TEST_PASS, x, error;
759         struct test_item defaults = { 0, }, configs = { 0, };
760         struct test_item *arr[4];
761         struct ast_sockaddr acl_allow = {{ 0, }}, acl_fail = {{ 0, }};
762         RAII_VAR(struct test_config *, cfg, NULL, ao2_cleanup);
763         RAII_VAR(struct test_item *, item, NULL, ao2_cleanup);
764         RAII_VAR(struct test_item *, item_defaults, NULL, ao2_cleanup);
765
766         switch (cmd) {
767         case TEST_INIT:
768                 info->name = "config_options_test";
769                 info->category = "/config/";
770                 info->summary = "Config opptions unit test";
771                 info->description =
772                         "Tests the Config Options API";
773                 return AST_TEST_NOT_RUN;
774         case TEST_EXECUTE:
775                 break;
776         }
777
778 #define INT_DEFAULT "-2"
779 #define INT_CONFIG "-1"
780 #define UINT_DEFAULT "2"
781 #define UINT_CONFIG "1"
782 #define DOUBLE_DEFAULT "1.1"
783 #define DOUBLE_CONFIG "0.1"
784 #define SOCKADDR_DEFAULT "4.3.2.1:4321"
785 #define SOCKADDR_CONFIG "1.2.3.4:1234"
786 #define BOOL_DEFAULT "false"
787 #define BOOL_CONFIG "true"
788 #define BOOLFLAG1_DEFAULT "false"
789 #define BOOLFLAG1_CONFIG "true"
790 #define BOOLFLAG2_DEFAULT "false"
791 #define BOOLFLAG2_CONFIG "false"
792 #define BOOLFLAG3_DEFAULT "false"
793 #define BOOLFLAG3_CONFIG "true"
794 #define ACL_DEFAULT NULL
795 #define ACL_CONFIG_PERMIT "1.2.3.4/32"
796 #define ACL_CONFIG_DENY "0.0.0.0/0"
797 #define CODEC_DEFAULT "!all,alaw"
798 #define CODEC_CONFIG "!all,ulaw,g729"
799 #define STR_DEFAULT "default"
800 #define STR_CONFIG "test"
801 #define CUSTOM_DEFAULT "no"
802 #define CUSTOM_CONFIG "yes"
803
804 #define BOOLFLAG1 1 << 0
805 #define BOOLFLAG2 1 << 1
806 #define BOOLFLAG3 1 << 2
807
808         if (aco_info_init(&cfg_info)) {
809                 ast_test_status_update(test, "Could not init cfg info\n");
810                 return AST_TEST_FAIL;
811         }
812
813         /* Register all options */
814         aco_option_register(&cfg_info, "intopt", ACO_EXACT, config_test_conf.types, INT_DEFAULT, OPT_INT_T, 0, FLDSET(struct test_item, intopt));
815         aco_option_register(&cfg_info, "uintopt", ACO_EXACT, config_test_conf.types, UINT_DEFAULT, OPT_UINT_T, 0, FLDSET(struct test_item, uintopt));
816         aco_option_register(&cfg_info, "doubleopt", ACO_EXACT, config_test_conf.types, DOUBLE_DEFAULT, OPT_DOUBLE_T, 0, FLDSET(struct test_item, doubleopt));
817         aco_option_register(&cfg_info, "sockaddropt", ACO_EXACT, config_test_conf.types, SOCKADDR_DEFAULT, OPT_SOCKADDR_T, 0, FLDSET(struct test_item, sockaddropt));
818         aco_option_register(&cfg_info, "boolopt", ACO_EXACT, config_test_conf.types, BOOL_DEFAULT, OPT_BOOL_T, 1, FLDSET(struct test_item, boolopt));
819         aco_option_register(&cfg_info, "boolflag1", ACO_EXACT, config_test_conf.types, BOOLFLAG1_DEFAULT, OPT_BOOLFLAG_T, 1, FLDSET(struct test_item, flags), BOOLFLAG1);
820         aco_option_register(&cfg_info, "boolflag2", ACO_EXACT, config_test_conf.types, BOOLFLAG2_DEFAULT, OPT_BOOLFLAG_T, 1, FLDSET(struct test_item, flags), BOOLFLAG2);
821         aco_option_register(&cfg_info, "boolflag3", ACO_EXACT, config_test_conf.types, BOOLFLAG3_DEFAULT, OPT_BOOLFLAG_T, 1, FLDSET(struct test_item, flags), BOOLFLAG3);
822         aco_option_register(&cfg_info, "aclpermitopt", ACO_EXACT, config_test_conf.types, ACL_DEFAULT, OPT_ACL_T, 1, FLDSET(struct test_item, aclopt));
823         aco_option_register(&cfg_info, "acldenyopt", ACO_EXACT, config_test_conf.types, ACL_DEFAULT, OPT_ACL_T, 0, FLDSET(struct test_item, aclopt));
824         aco_option_register(&cfg_info, "codecopt", ACO_EXACT, config_test_conf.types, CODEC_DEFAULT, OPT_CODEC_T, 1, FLDSET(struct test_item, codecprefopt, codeccapopt));
825         aco_option_register(&cfg_info, "stropt", ACO_EXACT, config_test_conf.types, STR_DEFAULT, OPT_STRINGFIELD_T, 0, STRFLDSET(struct test_item, stropt));
826         aco_option_register_custom(&cfg_info, "customopt", ACO_EXACT, config_test_conf.types, CUSTOM_DEFAULT, customopt_handler, 0);
827
828         if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) {
829                 ast_test_status_update(test, "Could not parse config\n");
830                 return AST_TEST_FAIL;
831         }
832
833         ast_parse_arg(INT_DEFAULT, PARSE_INT32, &defaults.intopt);
834         ast_parse_arg(INT_CONFIG, PARSE_INT32, &configs.intopt);
835         ast_parse_arg(UINT_DEFAULT, PARSE_UINT32, &defaults.uintopt);
836         ast_parse_arg(UINT_CONFIG, PARSE_UINT32, &configs.uintopt);
837         ast_parse_arg(DOUBLE_DEFAULT, PARSE_DOUBLE, &defaults.doubleopt);
838         ast_parse_arg(DOUBLE_CONFIG, PARSE_DOUBLE, &configs.doubleopt);
839         ast_parse_arg(SOCKADDR_DEFAULT, PARSE_ADDR, &defaults.sockaddropt);
840         ast_parse_arg(SOCKADDR_CONFIG, PARSE_ADDR, &configs.sockaddropt);
841         defaults.boolopt = ast_true(BOOL_DEFAULT);
842         configs.boolopt = ast_true(BOOL_CONFIG);
843         ast_set2_flag(&defaults, ast_true(BOOLFLAG1_DEFAULT), BOOLFLAG1);
844         ast_set2_flag(&defaults, ast_true(BOOLFLAG2_DEFAULT), BOOLFLAG2);
845         ast_set2_flag(&defaults, ast_true(BOOLFLAG3_DEFAULT), BOOLFLAG3);
846         ast_set2_flag(&configs, ast_true(BOOLFLAG1_CONFIG), BOOLFLAG1);
847         ast_set2_flag(&configs, ast_true(BOOLFLAG2_CONFIG), BOOLFLAG2);
848         ast_set2_flag(&configs, ast_true(BOOLFLAG3_CONFIG), BOOLFLAG3);
849
850         defaults.aclopt = NULL;
851         configs.aclopt = ast_append_ha("deny", ACL_CONFIG_DENY, configs.aclopt, &error);
852         configs.aclopt = ast_append_ha("permit", ACL_CONFIG_PERMIT, configs.aclopt, &error);
853         ast_sockaddr_parse(&acl_allow, "1.2.3.4", PARSE_PORT_FORBID);
854         ast_sockaddr_parse(&acl_fail, "1.1.1.1", PARSE_PORT_FORBID);
855
856         defaults.codeccapopt = ast_format_cap_alloc();
857         ast_parse_allow_disallow(&defaults.codecprefopt, defaults.codeccapopt, CODEC_DEFAULT, 1);
858
859         configs.codeccapopt = ast_format_cap_alloc();
860         ast_parse_allow_disallow(&configs.codecprefopt, configs.codeccapopt, CODEC_CONFIG, 1);
861
862         ast_string_field_init(&defaults, 128);
863         ast_string_field_init(&configs, 128);
864         ast_string_field_set(&defaults, stropt, STR_DEFAULT);
865         ast_string_field_set(&configs, stropt, STR_CONFIG);
866
867         defaults.customopt = ast_true(CUSTOM_DEFAULT);
868         configs.customopt = ast_true(CUSTOM_CONFIG);
869
870
871         cfg = ao2_global_obj_ref(global_obj);
872         if (!(item = ao2_find(cfg->items, "item", OBJ_KEY))) {
873                 ast_test_status_update(test, "could not look up 'item'\n");
874                 return AST_TEST_FAIL;
875         }
876         if (!(item_defaults = ao2_find(cfg->items, "item_defaults", OBJ_KEY))) {
877                 ast_test_status_update(test, "could not look up 'item_defaults'\n");
878                 return AST_TEST_FAIL;
879         }
880         arr[0] = cfg->global;
881         arr[1] = item;
882         arr[2] = cfg->global_defaults;
883         arr[3] = item_defaults;
884         /* Test global and item against configs, global_defaults and item_defaults against defaults */
885
886 #define NOT_EQUAL_FAIL(field)  \
887         if (arr[x]->field != control->field) { \
888                 ast_test_status_update(test, "%s did not match: %d != %d with x = %d\n", #field, arr[x]->field, control->field, x); \
889                 res = AST_TEST_FAIL; \
890         }
891         for (x = 0; x < 4; x++) {
892                 struct test_item *control = x < 2 ? &configs : &defaults;
893
894                 NOT_EQUAL_FAIL(intopt);
895                 NOT_EQUAL_FAIL(uintopt);
896                 NOT_EQUAL_FAIL(boolopt);
897                 NOT_EQUAL_FAIL(flags);
898                 NOT_EQUAL_FAIL(customopt);
899                 if (fabs(arr[x]->doubleopt - control->doubleopt) > 0.001) {
900                         ast_test_status_update(test, "doubleopt did not match: %f vs %f on loop %d\n", arr[x]->doubleopt, control->doubleopt, x);
901                         res = AST_TEST_FAIL;
902                 }
903                 if (ast_sockaddr_cmp(&arr[x]->sockaddropt, &control->sockaddropt)) {
904                         ast_test_status_update(test, "sockaddr did not match on loop %d\n", x);
905                         res = AST_TEST_FAIL;
906                 }
907                 if (!ast_format_cap_identical(arr[x]->codeccapopt, control->codeccapopt)) {
908                         char buf1[128], buf2[128];
909                         ast_getformatname_multiple(buf1, sizeof(buf1), arr[x]->codeccapopt);
910                         ast_getformatname_multiple(buf2, sizeof(buf2), control->codeccapopt);
911                         ast_test_status_update(test, "format did not match: '%s' vs '%s' on loop %d\n", buf1, buf2, x);
912                         res = AST_TEST_FAIL;
913                 }
914                 if (strcasecmp(arr[x]->stropt, control->stropt)) {
915                         ast_test_status_update(test, "stropt did not match: '%s' vs '%s' on loop %d\n", arr[x]->stropt, control->stropt, x);
916                         res = AST_TEST_FAIL;
917                 }
918                 if (arr[x]->aclopt != control->aclopt && (ast_apply_ha(arr[x]->aclopt, &acl_allow) != ast_apply_ha(control->aclopt, &acl_allow) ||
919                                 ast_apply_ha(arr[x]->aclopt, &acl_fail) != ast_apply_ha(control->aclopt, &acl_fail))) {
920                         ast_test_status_update(test, "acl not match: on loop %d\n", x);
921                         res = AST_TEST_FAIL;
922                 }
923         }
924
925         ast_free_ha(configs.aclopt);
926         ast_format_cap_destroy(defaults.codeccapopt);
927         ast_format_cap_destroy(configs.codeccapopt);
928         ast_string_field_free_memory(&defaults);
929         ast_string_field_free_memory(&configs);
930         return res;
931 }
932
933 static int unload_module(void)
934 {
935         AST_TEST_UNREGISTER(copy_config);
936         AST_TEST_UNREGISTER(config_hook);
937         AST_TEST_UNREGISTER(ast_parse_arg_test);
938         AST_TEST_UNREGISTER(config_options_test);
939         return 0;
940 }
941
942 static int load_module(void)
943 {
944         AST_TEST_REGISTER(copy_config);
945         AST_TEST_REGISTER(config_hook);
946         AST_TEST_REGISTER(ast_parse_arg_test);
947         AST_TEST_REGISTER(config_options_test);
948         return AST_MODULE_LOAD_SUCCESS;
949 }
950
951 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Config test module");
952