test_config.c File Reference

Configuration unit tests. More...

#include "asterisk.h"
#include <math.h>
#include <sys/stat.h>
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/test.h"
#include "asterisk/paths.h"
#include "asterisk/config_options.h"
#include "asterisk/netsock2.h"
#include "asterisk/acl.h"
#include "asterisk/app.h"
#include "asterisk/pbx.h"
#include "asterisk/frame.h"
#include "asterisk/utils.h"
#include "asterisk/logger.h"
#include "asterisk/format_cap.h"

Include dependency graph for test_config.c:

Go to the source code of this file.

Data Structures
struct	association
struct	pair
struct	test_config
struct	test_item

Macros
#define	ACL_CONFIG_DENY   "0.0.0.0/0"
#define	ACL_CONFIG_PERMIT   "1.2.3.4/32"
#define	ACL_DEFAULT   NULL
#define	BOOL_CONFIG   "true"
#define	BOOL_DEFAULT   "false"
#define	BOOLFLAG1   1 << 0
#define	BOOLFLAG1_CONFIG   "true"
#define	BOOLFLAG1_DEFAULT   "false"
#define	BOOLFLAG2   1 << 1
#define	BOOLFLAG2_CONFIG   "false"
#define	BOOLFLAG2_DEFAULT   "false"
#define	BOOLFLAG3   1 << 2
#define	BOOLFLAG3_CONFIG   "true"
#define	BOOLFLAG3_DEFAULT   "false"
#define	CODEC_CONFIG   "!all,ulaw,g729"
#define	CODEC_DEFAULT   "!all,alaw"
#define	CONFIG_FILE   "test_config.conf"
#define	CONFIG_INCLUDE_FILE   "test_config_include.conf"
#define	CUSTOM_CONFIG   "yes"
#define	CUSTOM_DEFAULT   "no"
#define	DEFAULTVAL   42
#define	DOUBLE_CONFIG   "0.1"
#define	DOUBLE_DEFAULT   "1.1"
#define	EPSILON   0.001
#define	INT_CONFIG   "-1"
#define	INT_DEFAULT   "-2"
#define	NOT_EQUAL_FAIL(field, format)
#define	SOCKADDR_CONFIG   "1.2.3.4:1234"
#define	SOCKADDR_DEFAULT   "4.3.2.1:4321"
#define	STR_CONFIG   "test"
#define	STR_DEFAULT   "default"
#define	TEST_PARSE(input, should_succeed, expected_result, flags, result, ...)
#define	TIMELEN_CONFIG   "1"
#define	TIMELEN_DEFAULT   "2"
#define	TOOBIG_I32   "2147483649"
#define	TOOBIG_U32   "4294967297"
#define	TOOSMALL_I32   "-2147483649"
#define	TOOSMALL_U32   "-4294967297"
#define	UINT_CONFIG   "1"
#define	UINT_DEFAULT   "2"

Enumerations
enum	{ EXPECT_FAIL = 0 , EXPECT_SUCCEED }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static	AO2_GLOBAL_OBJ_STATIC (global_obj)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (ast_parse_arg_test)
	AST_TEST_DEFINE (config_basic_ops)
	AST_TEST_DEFINE (config_dialplan_function)
	AST_TEST_DEFINE (config_filtered_ops)
	AST_TEST_DEFINE (config_hook)
	AST_TEST_DEFINE (config_options_test)
	AST_TEST_DEFINE (config_save)
	AST_TEST_DEFINE (config_template_ops)
	AST_TEST_DEFINE (copy_config)
	AST_TEST_DEFINE (variable_list_from_string)
	AST_TEST_DEFINE (variable_list_join_replace)
	AST_TEST_DEFINE (variable_lists_match)
static struct ast_config *	build_cfg (void)
	Build ast_config struct from above definitions.
	CONFIG_INFO_TEST (cfg_info, global_obj, test_config_alloc,.files=ACO_FILES(&config_test_conf),)
static int	customopt_handler (const struct aco_option *opt, struct ast_variable *var, void *obj)
static void	delete_config_file (void)
	Delete config file created by write_config_file.
static int	hook_cb (struct ast_config *cfg)
static int	load_module (void)
static void *	test_config_alloc (void)
static void	test_config_destructor (void *obj)
static int	test_config_validity (struct ast_config *cfg)
	Tests that the contents of an ast_config is what is expected.
static void *	test_item_alloc (const char *cat)
static int	test_item_cmp (void *obj, void *arg, int flags)
static void	test_item_destructor (void *obj)
static void *	test_item_find (struct ao2_container *container, const char *cat)
static int	unload_module (void)
static int	write_config_file (void)
	Write the config file to disk.

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Config test module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static const struct ast_module_info *	ast_module_info = &__mod_info
const char	cat1 [] = "Capitals"
const char	cat1varname1 [] = "Germany"
const char	cat1varname2 [] = "China"
const char	cat1varname3 [] = "Canada"
const char	cat1varvalue1 [] = "Berlin"
const char	cat1varvalue2 [] = "Beijing"
const char	cat1varvalue3 [] = "Ottawa"
const char	cat2 [] = "Protagonists"
const char	cat2varname1 [] = "1984"
const char	cat2varname2 [] = "Green Eggs And Ham"
const char	cat2varname3 [] = "The Kalevala"
const char	cat2varvalue1 [] = "Winston Smith"
const char	cat2varvalue2 [] = "Sam I Am"
const char	cat2varvalue3 [] = "Vainamoinen"
struct association	categories []
struct aco_file	config_test_conf
static struct aco_type	global
static struct aco_type	global_defaults
static int	hook_config_sane
static int	hook_run
static struct aco_type	item
static const char *	item_blacklist []

Detailed Description

Configuration unit tests.

Author

Mark Michelson mmich.nosp@m.elso.nosp@m.n@dig.nosp@m.ium..nosp@m.com

Definition in file test_config.c.

Macro Definition Documentation

ACL_CONFIG_DENY

#define ACL_CONFIG_DENY   "0.0.0.0/0"

ACL_CONFIG_PERMIT

#define ACL_CONFIG_PERMIT   "1.2.3.4/32"

ACL_DEFAULT

#define ACL_DEFAULT   NULL

BOOL_CONFIG

#define BOOL_CONFIG   "true"

BOOL_DEFAULT

#define BOOL_DEFAULT   "false"

BOOLFLAG1

#define BOOLFLAG1   1 << 0

BOOLFLAG1_CONFIG

#define BOOLFLAG1_CONFIG   "true"

BOOLFLAG1_DEFAULT

#define BOOLFLAG1_DEFAULT   "false"

BOOLFLAG2

#define BOOLFLAG2   1 << 1

BOOLFLAG2_CONFIG

#define BOOLFLAG2_CONFIG   "false"

BOOLFLAG2_DEFAULT

#define BOOLFLAG2_DEFAULT   "false"

BOOLFLAG3

#define BOOLFLAG3   1 << 2

BOOLFLAG3_CONFIG

#define BOOLFLAG3_CONFIG   "true"

BOOLFLAG3_DEFAULT

#define BOOLFLAG3_DEFAULT   "false"

CODEC_CONFIG

#define CODEC_CONFIG   "!all,ulaw,g729"

CODEC_DEFAULT

#define CODEC_DEFAULT   "!all,alaw"

CONFIG_FILE

#define CONFIG_FILE   "test_config.conf"

Definition at line 51 of file test_config.c.

CONFIG_INCLUDE_FILE

#define CONFIG_INCLUDE_FILE   "test_config_include.conf"

Definition at line 52 of file test_config.c.

CUSTOM_CONFIG

#define CUSTOM_CONFIG   "yes"

CUSTOM_DEFAULT

#define CUSTOM_DEFAULT   "no"

DEFAULTVAL

#define DEFAULTVAL   42

Definition at line 1056 of file test_config.c.

DOUBLE_CONFIG

#define DOUBLE_CONFIG   "0.1"

DOUBLE_DEFAULT

#define DOUBLE_DEFAULT   "1.1"

EPSILON

#define EPSILON   0.001

Definition at line 1057 of file test_config.c.

INT_CONFIG

#define INT_CONFIG   "-1"

INT_DEFAULT

#define INT_DEFAULT   "-2"

NOT_EQUAL_FAIL

#define NOT_EQUAL_FAIL	(		field,
			format
	)

Value:

    if (arr[x]->field != control->field) { \
        ast_test_status_update(test, "%s did not match: " format " != " format " with x = %d\n", #field, arr[x]->field, control->field, x); \
        res = AST_TEST_FAIL; \
    }

SOCKADDR_CONFIG

#define SOCKADDR_CONFIG   "1.2.3.4:1234"

SOCKADDR_DEFAULT

#define SOCKADDR_DEFAULT   "4.3.2.1:4321"

STR_CONFIG

#define STR_CONFIG   "test"

STR_DEFAULT

#define STR_DEFAULT   "default"

TEST_PARSE

#define TEST_PARSE	(		input,
			should_succeed,
			expected_result,
			flags,
			result,
			...
	)

Definition at line 1059 of file test_config.c.

                                                                                  {\
    int __res = ast_parse_arg(input, (flags), result, ##__VA_ARGS__); \
    if (!__res == !should_succeed) { \
        ast_test_status_update(test, "ast_parse_arg failed on '%s'. %d/%d\n", input, __res, should_succeed); \
        ret = AST_TEST_FAIL; \
    } else { \
        if (((flags) & PARSE_TYPE) == PARSE_INT32) { \
            int32_t *r = (int32_t *) (void *) result; \
            int32_t e = (int32_t) expected_result; \
            if (*r != e) { \
                ast_test_status_update(test, "ast_parse_arg int32_t failed with %d != %d\n", *r, e); \
                ret = AST_TEST_FAIL; \
            } \
        } else if (((flags) & PARSE_TYPE) == PARSE_UINT32) { \
            uint32_t *r = (uint32_t *) (void *) result; \
            uint32_t e = (uint32_t) expected_result; \
            if (*r != e) { \
                ast_test_status_update(test, "ast_parse_arg uint32_t failed with %u != %u\n", *r, e); \
                ret = AST_TEST_FAIL; \
            } \
        } else if (((flags) & PARSE_TYPE) == PARSE_DOUBLE) { \
            double *r = (double *) (void *) result; \
            double e = (double) expected_result; \
            if (fabs(*r - e) > EPSILON) { \
                ast_test_status_update(test, "ast_parse_arg double failed with %f != %f\n", *r, e); \
                ret = AST_TEST_FAIL; \
            } \
        } else if (((flags) & PARSE_TYPE) == PARSE_TIMELEN) { \
            int *r = (int *) (void *) result; \
            int e = (int) expected_result; \
            if (*r != e) { \
                ast_test_status_update(test, "ast_parse_arg timelen failed with %d != %d\n", *r, e); \
                ret = AST_TEST_FAIL; \
            } \
        } \
    } \
    *(result) = DEFAULTVAL; \
} while (0)

TIMELEN_CONFIG

#define TIMELEN_CONFIG   "1"

TIMELEN_DEFAULT

#define TIMELEN_DEFAULT   "2"

TOOBIG_I32

#define TOOBIG_I32   "2147483649"

Definition at line 1052 of file test_config.c.

TOOBIG_U32

#define TOOBIG_U32   "4294967297"

Definition at line 1054 of file test_config.c.

TOOSMALL_I32

#define TOOSMALL_I32   "-2147483649"

Definition at line 1053 of file test_config.c.

TOOSMALL_U32

#define TOOSMALL_U32   "-4294967297"

Definition at line 1055 of file test_config.c.

UINT_CONFIG

#define UINT_CONFIG   "1"

UINT_DEFAULT

#define UINT_DEFAULT   "2"

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
EXPECT_FAIL
EXPECT_SUCCEED

Definition at line 1047 of file test_config.c.

     {
    EXPECT_FAIL = 0,
    EXPECT_SUCCEED,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2009 of file test_config.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 2009 of file test_config.c.

AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( global_obj  )

static

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 2009 of file test_config.c.

AST_TEST_DEFINE() [1/12]

AST_TEST_DEFINE

(

ast_parse_arg_test

)

Definition at line 1098 of file test_config.c.

{
    int ret = AST_TEST_PASS;
    int32_t int32_t_val = DEFAULTVAL;
    uint32_t uint32_t_val = DEFAULTVAL;
    int timelen_val = DEFAULTVAL;
    double double_val = DEFAULTVAL;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "ast_parse_arg";
        info->category = "/config/";
        info->summary = "Test the output of ast_parse_arg";
        info->description =
            "Ensures that ast_parse_arg behaves as expected";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    /* int32 testing */
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32, &int32_t_val);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32, &int32_t_val);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32, &int32_t_val);
    TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32, &int32_t_val);
    TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32, &int32_t_val);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32, &int32_t_val);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32, &int32_t_val);
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
    TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
    TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
    TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT, &int32_t_val, 7);
 
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, 0, 200);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, -200, 100);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, -1, 0);
    TEST_PARSE("123", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, 0, 122);
    TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, -122, 100);
    TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, 1, 100);
    TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_IN_RANGE, &int32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE("123", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, 0, 200);
    TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, -200, 100);
    TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, -1, 0);
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, 0, 122);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, -122, 100);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, 1, 100);
    TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_INT32 | PARSE_OUT_RANGE, &int32_t_val, INT_MIN, INT_MAX);
 
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, 0, 200);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, -200, 100);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, -1, 0);
    TEST_PARSE("123", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, 0, 122);
    TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, -122, 100);
    TEST_PARSE("0", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, 1, 100);
    TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE("123", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, 0, 200);
    TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, -200, 100);
    TEST_PARSE("0", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, -1, 0);
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, 0, 122);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, -122, 100);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, 1, 100);
    TEST_PARSE(TOOBIG_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE(TOOSMALL_I32, EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_INT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &int32_t_val, 7, INT_MIN, INT_MAX);
 
    /* uuint32 testing */
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32, &uint32_t_val);
    TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32, &uint32_t_val);
    TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
    TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
 
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
    TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
    TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
    TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
    TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT, &uint32_t_val, 7);
 
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, 0, 200);
    TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, 0, 200);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, 0, 1);
 
    TEST_PARSE("123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, 0, 122);
    TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, 1, 100);
    TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_IN_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
 
    TEST_PARSE("123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, 0, 200);
    TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, 0, 200);
    TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, 0, 1);
 
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, 0, 122);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, 1, 100);
    TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32 | PARSE_OUT_RANGE, &uint32_t_val, INT_MIN, INT_MAX);
 
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, 0, 200);
    TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, 0, 200);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, 0, 1);
    TEST_PARSE("123", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, 0, 122);
    TEST_PARSE("0", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, 1, 100);
    TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_IN_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE("123", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, 0, 200);
    TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, 0, 100);
    TEST_PARSE("0", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, 0, 1);
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, 0, 122);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, 1, 100);
    TEST_PARSE(TOOBIG_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE(TOOSMALL_U32, EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_UINT32 | PARSE_DEFAULT | PARSE_OUT_RANGE, &uint32_t_val, 7, INT_MIN, INT_MAX);
 
    TEST_PARSE("   -123", EXPECT_FAIL, DEFAULTVAL, PARSE_UINT32, &uint32_t_val);
 
    /* timelen testing */
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_TIMELEN, &timelen_val, TIMELEN_MILLISECONDS);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_TIMELEN, &timelen_val, TIMELEN_MILLISECONDS);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_TIMELEN, &timelen_val, TIMELEN_MILLISECONDS);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN, &timelen_val, TIMELEN_MILLISECONDS);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN, &timelen_val, TIMELEN_MILLISECONDS);
 
    TEST_PARSE("123s", EXPECT_SUCCEED, 123000, PARSE_TIMELEN, &timelen_val, TIMELEN_MILLISECONDS);
    TEST_PARSE("-123s", EXPECT_SUCCEED, -123000, PARSE_TIMELEN, &timelen_val, TIMELEN_MILLISECONDS);
    TEST_PARSE("1m", EXPECT_SUCCEED, 60000, PARSE_TIMELEN, &timelen_val, TIMELEN_MILLISECONDS);
    TEST_PARSE("1", EXPECT_SUCCEED, 60000, PARSE_TIMELEN, &timelen_val, TIMELEN_MINUTES);
    TEST_PARSE("1h", EXPECT_SUCCEED, 3600000, PARSE_TIMELEN, &timelen_val, TIMELEN_MILLISECONDS);
    TEST_PARSE("1", EXPECT_SUCCEED, 3600000, PARSE_TIMELEN, &timelen_val, TIMELEN_HOURS);
 
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_TIMELEN | PARSE_DEFAULT, &timelen_val, TIMELEN_MILLISECONDS, 7);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_TIMELEN | PARSE_DEFAULT, &timelen_val, TIMELEN_MILLISECONDS, 7);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_TIMELEN | PARSE_DEFAULT, &timelen_val, TIMELEN_MILLISECONDS, 7);
    TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT, &timelen_val, TIMELEN_MILLISECONDS, 7);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT, &timelen_val, TIMELEN_MILLISECONDS, 7);
 
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_TIMELEN | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 0, 200);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_TIMELEN | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, -200, 100);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_TIMELEN | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, -1, 0);
    TEST_PARSE("123", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 0, 122);
    TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, -122, 100);
    TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 1, 100);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, INT_MIN, INT_MAX);
    TEST_PARSE("123", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 0, 200);
    TEST_PARSE("-123", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, -200, 100);
    TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, -1, 0);
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_TIMELEN | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 0, 122);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_TIMELEN | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, -122, 100);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_TIMELEN | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 1, 100);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_TIMELEN | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, INT_MIN, INT_MAX);
 
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, 0, 200);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, -200, 100);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, -1, 0);
    TEST_PARSE("123", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, 0, 122);
    TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, -122, 100);
    TEST_PARSE("0", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, 1, 100);
    TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_IN_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, INT_MIN, INT_MAX);
    TEST_PARSE("123", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, 0, 200);
    TEST_PARSE("-123", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, -200, 100);
    TEST_PARSE("0", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, -1, 0);
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, 0, 122);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, -122, 100);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, 1, 100);
    TEST_PARSE("not a number", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, INT_MIN, INT_MAX);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7, PARSE_TIMELEN | PARSE_DEFAULT | PARSE_OUT_RANGE, &timelen_val, TIMELEN_MILLISECONDS, 7, INT_MIN, INT_MAX);
 
    /* double testing */
    TEST_PARSE("123", EXPECT_SUCCEED, 123, PARSE_DOUBLE, &double_val);
    TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE, &double_val);
    TEST_PARSE("-123", EXPECT_SUCCEED, -123, PARSE_DOUBLE, &double_val);
    TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE, &double_val);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE, &double_val);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE, &double_val);
    TEST_PARSE("7.0not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE, &double_val);
    TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE | PARSE_DEFAULT, &double_val, 7.0);
    TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE | PARSE_DEFAULT, &double_val, 7.0);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE | PARSE_DEFAULT, &double_val, 7.0);
    TEST_PARSE("not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT, &double_val, 7.0);
    TEST_PARSE("7.0not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT, &double_val, 7.0);
 
    TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, 0.0, 200.0);
    TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, -200.0, 100.0);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, -1.0, 0.0);
    TEST_PARSE("123.123", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, 0.0, 122.0);
    TEST_PARSE("-123.123", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, -122.0, 100.0);
    TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, 1.0, 100.0);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, -HUGE_VAL, HUGE_VAL);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_IN_RANGE, &double_val, -HUGE_VAL, HUGE_VAL);
    TEST_PARSE("123.123", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, 0.0, 200.0);
    TEST_PARSE("-123.123", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, -200.0, 100.0);
    TEST_PARSE("0", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, -1.0, 0.0);
    TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, 0.0, 122.0);
    TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, -122.0, 100.0);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, 1.0, 100.0);
    TEST_PARSE("not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, -HUGE_VAL, HUGE_VAL);
    TEST_PARSE("7not a number", EXPECT_FAIL, DEFAULTVAL, PARSE_DOUBLE | PARSE_OUT_RANGE, &double_val, -HUGE_VAL, HUGE_VAL);
 
    TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, 0.0, 200.0);
    TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, -200.0, 100.0);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, -1.0, 0.0);
    TEST_PARSE("123.123", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, 0.0, 122.0);
    TEST_PARSE("-123.123", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, -122.0, 100.0);
    TEST_PARSE("0", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, 1.0, 100.0);
    TEST_PARSE("not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, -HUGE_VAL, HUGE_VAL);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_IN_RANGE, &double_val, 7.0, -HUGE_VAL, HUGE_VAL);
    TEST_PARSE("123.123", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, 0.0, 200.0);
    TEST_PARSE("-123.123", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, -200.0, 100.0);
    TEST_PARSE("0", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, -1.0, 0.0);
    TEST_PARSE("123.123", EXPECT_SUCCEED, 123.123, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, 0.0, 122.0);
    TEST_PARSE("-123.123", EXPECT_SUCCEED, -123.123, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, -122.0, 100.0);
    TEST_PARSE("0", EXPECT_SUCCEED, 0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, 1.0, 100.0);
    TEST_PARSE("not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, -HUGE_VAL, HUGE_VAL);
    TEST_PARSE("7not a number", EXPECT_FAIL, 7.0, PARSE_DOUBLE | PARSE_DEFAULT | PARSE_OUT_RANGE, &double_val, 7.0, -HUGE_VAL, HUGE_VAL);
 
    /* ast_sockaddr_parse is tested extensively in test_netsock2.c and PARSE_ADDR is a very simple wrapper */
 
    return ret;
}

References AST_TEST_NOT_RUN, AST_TEST_PASS, DEFAULTVAL, EXPECT_FAIL, EXPECT_SUCCEED, PARSE_DEFAULT, PARSE_DOUBLE, PARSE_IN_RANGE, PARSE_INT32, PARSE_OUT_RANGE, PARSE_TIMELEN, PARSE_UINT32, TEST_EXECUTE, TEST_INIT, TEST_PARSE, TIMELEN_HOURS, TIMELEN_MILLISECONDS, TIMELEN_MINUTES, TOOBIG_I32, TOOBIG_U32, TOOSMALL_I32, and TOOSMALL_U32.

AST_TEST_DEFINE() [2/12]

AST_TEST_DEFINE

(

config_basic_ops

)

Definition at line 232 of file test_config.c.

{
    enum ast_test_result_state res = AST_TEST_FAIL;
    struct ast_config *cfg = NULL;
    struct ast_category *cat = NULL;
    struct ast_variable *var;
    struct ast_variable *varlist;
    char temp[32];
    const char *cat_name;
    const char *var_value;
    int i;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "config_basic_ops";
        info->category = "/main/config/";
        info->summary = "Test basic config ops";
        info->description = "Test basic config ops";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    cfg = ast_config_new();
    if (!cfg) {
        return res;
    }
 
    /* load the config */
    for(i = 0; i < 5; i++) {
        snprintf(temp, sizeof(temp), "test%d", i);
        ast_category_append(cfg, ast_category_new(temp, "dummy", -1));
    }
 
    /* test0 test1 test2 test3 test4 */
    /* check the config has 5 elements */
    i = 0;
    cat = NULL;
    while ((cat = ast_category_browse_filtered(cfg, NULL, cat, NULL))) {
        snprintf(temp, sizeof(temp), "test%d", i);
        if (strcmp(ast_category_get_name(cat), temp)) {
            ast_test_status_update(test, "%s != %s\n", ast_category_get_name(cat), temp);
            goto out;
        }
        i++;
    }
    if (i != 5) {
        ast_test_status_update(test, "There were %d matches instead of 5.\n", i);
        goto out;
    }
 
    /* search for test2 */
    cat = ast_category_get(cfg, "test2", NULL);
    if (!cat || strcmp(ast_category_get_name(cat), "test2")) {
        ast_test_status_update(test, "Get failed %s != %s\n", ast_category_get_name(cat), "test2");
        goto out;
    }
 
    /* delete test2 */
    cat = ast_category_delete(cfg, cat);
 
    /* Now: test0 test1 test3 test4 */
    /* make sure the curr category is test1 */
    if (!cat || strcmp(ast_category_get_name(cat), "test1")) {
        ast_test_status_update(test, "Delete failed %s != %s\n", ast_category_get_name(cat), "test1");
        goto out;
    }
 
    /* Now: test0 test1 test3 test4 */
    /* make sure the test2 is not found */
    cat = ast_category_get(cfg, "test2", NULL);
    if (cat) {
        ast_test_status_update(test, "Should not have found test2\n");
        goto out;
    }
 
    /* Now: test0 test1 test3 test4 */
    /* make sure the sequence is correctly missing test2 */
    i = 0;
    cat = NULL;
    while ((cat = ast_category_browse_filtered(cfg, NULL, cat, NULL))) {
        snprintf(temp, sizeof(temp), "test%d", i);
        if (strcmp(ast_category_get_name(cat), temp)) {
            ast_test_status_update(test, "%s != %s\n", ast_category_get_name(cat), temp);
            goto out;
        }
        i++;
        if (i == 2) {
            i++;
        }
    }
    if (i != 5) {
        ast_test_status_update(test, "There were %d matches instead of 5.\n", i);
        goto out;
    }
 
    /* insert test2 back in before test3 */
    ast_category_insert(cfg, ast_category_new("test2", "dummy", -1), "test3");
 
    /* Now: test0 test1 test2 test3 test4 */
    /* make sure the sequence is correct again */
    i = 0;
    cat = NULL;
    while ((cat = ast_category_browse_filtered(cfg, NULL, cat, NULL))) {
        snprintf(temp, sizeof(temp), "test%d", i);
        if (strcmp(ast_category_get_name(cat), temp)) {
            ast_test_status_update(test, "%s != %s\n", ast_category_get_name(cat), temp);
            goto out;
        }
        i++;
    }
    if (i != 5) {
        ast_test_status_update(test, "There were %d matches instead of 5.\n", i);
        goto out;
    }
 
    /* Now: test0 test1 test2 test3 test4 */
    /* make sure non filtered browse still works */
    i = 0;
    cat_name = NULL;
    while ((cat_name = ast_category_browse(cfg, cat_name))) {
        snprintf(temp, sizeof(temp), "test%d", i);
        if (strcmp(cat_name, temp)) {
            ast_test_status_update(test, "%s != %s\n", cat_name, temp);
            goto out;
        }
        i++;
    }
    if (i != 5) {
        ast_test_status_update(test, "There were %d matches instead of 5.\n", i);
        goto out;
    }
 
    /* append another test2 */
    ast_category_append(cfg, ast_category_new("test2", "dummy", -1));
    /* Now: test0 test1 test2 test3 test4 test2*/
    /* make sure only test2's are returned */
    i = 0;
    cat = NULL;
    while ((cat = ast_category_browse_filtered(cfg, "test2", cat, NULL))) {
        if (strcmp(ast_category_get_name(cat), "test2")) {
            ast_test_status_update(test, "Should have returned test2 instead of %s\n", ast_category_get_name(cat));
            goto out;
        }
        i++;
    }
    /* make sure 2 test2's were found */
    if (i != 2) {
        ast_test_status_update(test, "Should have found 2 test2's %d\n", i);
        goto out;
    }
 
    /* Test in-flight deletion using ast_category_browse_filtered */
    /* Now: test0 test1 test2 test3 test4 test2 */
    /* Delete the middle test2 and continue */
    cat = NULL;
    for(i = 0; i < 5; i++) {
        snprintf(temp, sizeof(temp), "test%d", i);
        cat = ast_category_browse_filtered(cfg, NULL, cat, NULL);
        cat_name = ast_category_get_name(cat);
        if (strcmp(cat_name, temp)) {
            ast_test_status_update(test, "Should have returned %s instead of %s: %d\n", temp, cat_name, i);
            goto out;
        }
        if (i == 2) {
            cat = ast_category_delete(cfg, cat);
        }
    }
 
    /* Now: test0 test3 test4 test2 */
    /* delete the head item */
    cat = ast_category_browse_filtered(cfg, NULL, NULL, NULL);
    cat_name = ast_category_get_name(cat);
    if (strcmp(cat_name, "test0")) {
        ast_test_status_update(test, "Should have returned test0 instead of %s\n", cat_name);
        goto out;
    }
    ast_category_delete(cfg, cat);
    /* Now: test3 test4 test2 */
 
    /* make sure head got updated to the new first element */
    cat = ast_category_browse_filtered(cfg, NULL, NULL, NULL);
    cat_name = ast_category_get_name(cat);
    if (strcmp(cat_name, "test1")) {
        ast_test_status_update(test, "Should have returned test3 instead of %s\n", cat_name);
        goto out;
    }
 
    /* delete the tail item */
    cat = ast_category_get(cfg, "test2", NULL);
    cat_name = ast_category_get_name(cat);
    if (strcmp(cat_name, "test2")) {
        ast_test_status_update(test, "Should have returned test2 instead of %s\n", cat_name);
        goto out;
    }
    ast_category_delete(cfg, cat);
    /* Now: test3 test4 */
 
    /* There should now only be 2 elements in the list */
    cat = NULL;
    cat = ast_category_browse_filtered(cfg, NULL, cat, NULL);
    cat_name = ast_category_get_name(cat);
    if (strcmp(cat_name, "test1")) {
        ast_test_status_update(test, "Should have returned test1 instead of %s\n", cat_name);
        goto out;
    }
 
    cat = ast_category_browse_filtered(cfg, NULL, cat, NULL);
    cat_name = ast_category_get_name(cat);
    if (strcmp(cat_name, "test3")) {
        ast_test_status_update(test, "Should have returned test3 instead of %s\n", cat_name);
        goto out;
    }
 
    cat = ast_category_browse_filtered(cfg, NULL, cat, NULL);
    cat_name = ast_category_get_name(cat);
    if (strcmp(cat_name, "test4")) {
        ast_test_status_update(test, "Should have returned test4 instead of %s\n", cat_name);
        goto out;
    }
 
    /* There should be nothing more */
    cat = ast_category_browse_filtered(cfg, NULL, cat, NULL);
    if (cat) {
        ast_test_status_update(test, "Should not have returned anything\n");
        goto out;
    }
 
    /* Test ast_variable retrieve.
     * Get the second category.
     */
    cat = ast_category_browse_filtered(cfg, NULL, NULL, NULL);
    cat = ast_category_browse_filtered(cfg, NULL, cat, NULL);
    cat_name = ast_category_get_name(cat);
    var = ast_variable_new("aaa", "bbb0", "dummy");
    if (!var) {
        ast_test_status_update(test, "Couldn't allocate variable.\n");
        goto out;
    }
    ast_variable_append(cat, var);
 
    /* Make sure we can retrieve with specific category name */
    var_value = ast_variable_retrieve(cfg, cat_name, "aaa");
    if (!var_value || strcmp(var_value, "bbb0")) {
        ast_test_status_update(test, "Variable not found or wrong value.\n");
        goto out;
    }
 
    /* Make sure we can retrieve with NULL category name */
    var_value = ast_variable_retrieve(cfg, NULL, "aaa");
    if (!var_value || strcmp(var_value, "bbb0")) {
        ast_test_status_update(test, "Variable not found or wrong value.\n");
        goto out;
    }
 
    /* Now test variable retrieve inside a browse loop
     * with multiple categories of the same name
     */
    cat = ast_category_new("test3", "dummy", -1);
    if (!cat) {
        ast_test_status_update(test, "Couldn't allocate category.\n");
        goto out;
    }
    var = ast_variable_new("aaa", "bbb1", "dummy");
    if (!var) {
        ast_test_status_update(test, "Couldn't allocate variable.\n");
        goto out;
    }
    ast_variable_append(cat, var);
    ast_category_append(cfg, cat);
 
    cat = ast_category_new("test3", "dummy", -1);
    if (!cat) {
        ast_test_status_update(test, "Couldn't allocate category.\n");
        goto out;
    }
    var = ast_variable_new("aaa", "bbb2", "dummy");
    if (!var) {
        ast_test_status_update(test, "Couldn't allocate variable.\n");
        goto out;
    }
    ast_variable_append(cat, var);
    ast_category_append(cfg, cat);
 
    cat_name = NULL;
    i = 0;
    while ((cat_name = ast_category_browse(cfg, cat_name))) {
        if (!strcmp(cat_name, "test3")) {
            snprintf(temp, sizeof(temp), "bbb%d", i);
 
            var_value = ast_variable_retrieve(cfg, cat_name, "aaa");
            if (!var_value || strcmp(var_value, temp)) {
                ast_test_status_update(test, "Variable not found or wrong value %s.\n", var_value);
                goto out;
            }
 
            var = ast_variable_browse(cfg, cat_name);
            if (!var->value || strcmp(var->value, temp)) {
                ast_test_status_update(test, "Variable not found or wrong value %s.\n", var->value);
                goto out;
            }
 
            i++;
        }
    }
    if (i != 3) {
        ast_test_status_update(test, "There should have been 3 matches instead of %d.\n", i);
        goto out;
    }
 
    varlist = ast_variable_new("name1", "value1", "");
    ast_variable_list_append_hint(&varlist, NULL, ast_variable_new("name1", "value2", ""));
    ast_variable_list_append_hint(&varlist, NULL, ast_variable_new("name1", "value3", ""));
 
    var_value = ast_variable_find_in_list(varlist, "name1");
    if (strcmp(var_value, "value1") != 0) {
        ast_test_status_update(test, "Wrong variable retrieved %s.\n", var_value);
        goto out;
    }
 
    var_value = ast_variable_find_last_in_list(varlist, "name1");
    if (strcmp(var_value, "value3") != 0) {
        ast_test_status_update(test, "Wrong variable retrieved %s.\n", var_value);
        goto out;
    }
 
    res = AST_TEST_PASS;
 
out:
    ast_config_destroy(cfg);
    return res;
}

References ast_category_append(), ast_category_browse(), ast_category_browse_filtered(), ast_category_delete(), ast_category_get(), ast_category_get_name(), ast_category_insert(), ast_category_new(), ast_config_destroy(), ast_config_new(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_variable_append(), ast_variable_browse(), ast_variable_find_in_list(), ast_variable_find_last_in_list(), ast_variable_list_append_hint(), ast_variable_new, ast_variable_retrieve(), NULL, out, TEST_EXECUTE, TEST_INIT, and var.

AST_TEST_DEFINE() [3/12]

AST_TEST_DEFINE

(

config_dialplan_function

)

Definition at line 1686 of file test_config.c.

{
    enum ast_test_result_state res = AST_TEST_PASS;
    FILE *config_file;
    char filename[PATH_MAX];
    struct ast_str *buf;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "config_dialplan_function";
        info->category = "/main/config/";
        info->summary = "Test AST_CONFIG dialplan function";
        info->description = "Test AST_CONFIG dialplan function";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    snprintf(filename, sizeof(filename), "%s/%s",
            ast_config_AST_CONFIG_DIR, CONFIG_FILE);
    config_file = fopen(filename, "w");
 
    if (!config_file) {
        return AST_TEST_FAIL;
    }
 
    fputs(
        "[c1t](!)\n"
        "var1=val1\n"
        "var1=val2\n"
        "var2=val21\n"
        "\n"
        "[c1](c1t)\n"
        "var1=val3\n"
        "var1=val4\n"
        , config_file);
 
    fclose(config_file);
 
    if (!(buf = ast_str_create(32))) {
        ast_test_status_update(test, "Failed to allocate return buffer\n");
        res = AST_TEST_FAIL;
        goto out;
    }
 
    if (ast_func_read2(NULL, "AST_CONFIG("CONFIG_FILE",c1,var1)", &buf, 32)) {
        ast_test_status_update(test, "Failed to retrieve field 'var1'\n");
        res = AST_TEST_FAIL;
        goto out;
    }
    if (strcmp(ast_str_buffer(buf), "val1")) {
        ast_test_status_update(test, "Got '%s', should be '%s'\n",
            ast_str_buffer(buf), "val1");
        res = AST_TEST_FAIL;
        goto out;
    }
 
    ast_str_reset(buf);
    if (ast_func_read2(NULL, "AST_CONFIG("CONFIG_FILE",c1,var1,0)", &buf, 32)) {
        ast_test_status_update(test, "Failed to retrieve field 'var1'\n");
        res = AST_TEST_FAIL;
        goto out;
    }
    if (strcmp(ast_str_buffer(buf), "val1")) {
        ast_test_status_update(test, "Got '%s', should be '%s'\n",
            ast_str_buffer(buf), "val1");
        res = AST_TEST_FAIL;
        goto out;
    }
 
    ast_str_reset(buf);
    if (ast_func_read2(NULL, "AST_CONFIG("CONFIG_FILE",c1,var1,1)", &buf, 32)) {
        ast_test_status_update(test, "Failed to retrieve field 'var1'\n");
        res = AST_TEST_FAIL;
        goto out;
    }
    if (strcmp(ast_str_buffer(buf), "val2")) {
        ast_test_status_update(test, "Got '%s', should be '%s'\n",
            ast_str_buffer(buf), "val2");
        res = AST_TEST_FAIL;
        goto out;
    }
 
    ast_str_reset(buf);
    if (ast_func_read2(NULL, "AST_CONFIG("CONFIG_FILE",c1,var1,2)", &buf, 32)) {
        ast_test_status_update(test, "Failed to retrieve field 'var1'\n");
        res = AST_TEST_FAIL;
        goto out;
    }
    if (strcmp(ast_str_buffer(buf), "val3")) {
        ast_test_status_update(test, "Got '%s', should be '%s'\n",
            ast_str_buffer(buf), "val3");
        res = AST_TEST_FAIL;
        goto out;
    }
 
    ast_str_reset(buf);
    if (ast_func_read2(NULL, "AST_CONFIG("CONFIG_FILE",c1,var1,3)", &buf, 32)) {
        ast_test_status_update(test, "Failed to retrieve field 'var1'\n");
        res = AST_TEST_FAIL;
        goto out;
    }
    if (strcmp(ast_str_buffer(buf), "val4")) {
        ast_test_status_update(test, "Got '%s', should be '%s'\n",
            ast_str_buffer(buf), "val4");
        res = AST_TEST_FAIL;
        goto out;
    }
 
    ast_str_reset(buf);
    if (ast_func_read2(NULL, "AST_CONFIG("CONFIG_FILE",c1,var1,-1)", &buf, 32)) {
        ast_test_status_update(test, "Failed to retrieve field 'var1'\n");
        res = AST_TEST_FAIL;
        goto out;
    }
    if (strcmp(ast_str_buffer(buf), "val4")) {
        ast_test_status_update(test, "Got '%s', should be '%s'\n",
            ast_str_buffer(buf), "val4");
        res = AST_TEST_FAIL;
        goto out;
    }
 
    ast_str_reset(buf);
    if (ast_func_read2(NULL, "AST_CONFIG("CONFIG_FILE",c1,var2,-1)", &buf, 32)) {
        ast_test_status_update(test, "Failed to retrieve field 'var2'\n");
        res = AST_TEST_FAIL;
        goto out;
    }
    if (strcmp(ast_str_buffer(buf), "val21")) {
        ast_test_status_update(test, "Got '%s', should be '%s'\n",
            ast_str_buffer(buf), "val21");
        res = AST_TEST_FAIL;
        goto out;
    }
 
    ast_str_reset(buf);
    if (!ast_func_read2(NULL, "AST_CONFIG("CONFIG_FILE",c1,var1,5)", &buf, 32)) {
        ast_test_status_update(test, "Should not have retrieved a value\n");
        res = AST_TEST_FAIL;
        goto out;
    }
 
out:
    if (buf) {
        ast_free(buf);
    }
    delete_config_file();
    return res;
}

References ast_config_AST_CONFIG_DIR, ast_free, ast_func_read2(), ast_str_buffer(), ast_str_create, ast_str_reset(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, buf, config_file, CONFIG_FILE, delete_config_file(), NULL, out, PATH_MAX, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [4/12]

AST_TEST_DEFINE

(

config_filtered_ops

)

Definition at line 565 of file test_config.c.

{
    enum ast_test_result_state res = AST_TEST_FAIL;
    struct ast_config *cfg = NULL;
    struct ast_category *cat = NULL;
    char temp[32];
    const char *value;
    int i;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "config_filtered_ops";
        info->category = "/main/config/";
        info->summary = "Test filtered config ops";
        info->description = "Test filtered config ops";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    cfg = ast_config_new();
    if (!cfg) {
        return res;
    }
 
    /* load the config */
    for(i = 0; i < 5; i++) {
        snprintf(temp, sizeof(temp), "test%d", i);
        cat = ast_category_new(temp, "dummy", -1);
        ast_variable_insert(cat, ast_variable_new("type", "a", "dummy"), "0");
        ast_category_append(cfg, cat);
    }
 
    for(i = 0; i < 5; i++) {
        snprintf(temp, sizeof(temp), "test%d", i);
        cat = ast_category_new(temp, "dummy", -1);
        ast_variable_insert(cat, ast_variable_new("type", "b", "dummy"), "0");
        ast_category_append(cfg, cat);
    }
 
    /* check the config has 5 elements for each type*/
    i = 0;
    cat = NULL;
    while ((cat = ast_category_browse_filtered(cfg, NULL, cat, "type=a"))) {
        snprintf(temp, sizeof(temp), "test%d", i);
        if (strcmp(ast_category_get_name(cat), temp)) {
            ast_test_status_update(test, "%s != %s\n", ast_category_get_name(cat), temp);
            goto out;
        }
        value = ast_variable_find(cat, "type");
        if (!value || strcmp(value, "a")) {
            ast_test_status_update(test, "Type %s != %s\n", "a", value);
            goto out;
        }
        i++;
    }
    if (i != 5) {
        ast_test_status_update(test, "There were %d matches instead of 5.\n", i);
        goto out;
    }
 
    i = 0;
    cat = NULL;
    while ((cat = ast_category_browse_filtered(cfg, NULL, cat, "type=b"))) {
        snprintf(temp, sizeof(temp), "test%d", i);
        if (!cat || strcmp(ast_category_get_name(cat), temp)) {
            ast_test_status_update(test, "%s != %s\n", ast_category_get_name(cat), temp);
            goto out;
        }
        value = ast_variable_find(cat, "type");
        if (!value || strcmp(value, "b")) {
            ast_test_status_update(test, "Type %s != %s\n", "b", value);
            goto out;
        }
        i++;
    }
    if (i != 5) {
        ast_test_status_update(test, "There were %d matches instead of 5.\n", i);
        goto out;
    }
 
    /* Delete b3 and make sure it's gone and a3 is still there.
     * Really this is a test of get since delete takes a specific category structure.
     */
    cat = ast_category_get(cfg, "test3", "type=b");
    value = ast_variable_find(cat, "type");
    if (strcmp(value, "b")) {
        ast_test_status_update(test, "Type %s != %s\n", "b", value);
        goto out;
    }
    ast_category_delete(cfg, cat);
 
    cat = ast_category_get(cfg, "test3", "type=b");
    if (cat) {
        ast_test_status_update(test, "Category b was not deleted.\n");
        goto out;
    }
 
    cat = ast_category_get(cfg, "test3", "type=a");
    if (!cat) {
        ast_test_status_update(test, "Category a was deleted.\n");
        goto out;
    }
 
    value = ast_variable_find(cat, "type");
    if (strcmp(value, "a")) {
        ast_test_status_update(test, "Type %s != %s\n", value, "a");
        goto out;
    }
 
    /* Basic regex stuff is handled by regcomp/regexec so not testing here.
     * Still need to test multiple name/value pairs though.
     */
    ast_category_empty(cat);
    ast_variable_insert(cat, ast_variable_new("type", "bx", "dummy"), "0");
    ast_variable_insert(cat, ast_variable_new("e", "z", "dummy"), "0");
 
    cat = ast_category_get(cfg, "test3", "type=.,e=z");
    if (!cat) {
        ast_test_status_update(test, "Category not found.\n");
        goto out;
    }
 
    cat = ast_category_get(cfg, "test3", "type=.,e=zX");
    if (cat) {
        ast_test_status_update(test, "Category found.\n");
        goto out;
    }
 
    cat = ast_category_get(cfg, "test3", "TEMPLATE=restrict,type=.,e=z");
    if (cat) {
        ast_test_status_update(test, "Category found.\n");
        goto out;
    }
 
    res = AST_TEST_PASS;
 
out:
    ast_config_destroy(cfg);
    return res;
}

References ast_category_append(), ast_category_browse_filtered(), ast_category_delete(), ast_category_empty(), ast_category_get(), ast_category_get_name(), ast_category_new(), ast_config_destroy(), ast_config_new(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_variable_find(), ast_variable_insert(), ast_variable_new, NULL, out, TEST_EXECUTE, TEST_INIT, and value.

AST_TEST_DEFINE() [5/12]

AST_TEST_DEFINE

(

config_hook

)

Definition at line 956 of file test_config.c.

{
    enum ast_test_result_state res = AST_TEST_FAIL;
    enum config_hook_flags hook_flags = { 0, };
    struct ast_flags config_flags = { 0 };
    struct ast_flags reload_flags = { CONFIG_FLAG_FILEUNCHANGED };
    struct ast_config *cfg;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "config_hook";
        info->category = "/main/config/";
        info->summary = "Test config hooks";
        info->description =
            "Ensure that config hooks are called at approriate times,"
            "not called at inappropriate times, and that all information"
            "that should be present is present.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    write_config_file();
 
    /*
     * Register a config hook to run when CONFIG_FILE is loaded by this module
     */
    ast_config_hook_register("test_hook",
            CONFIG_FILE,
            AST_MODULE,
            hook_flags,
            hook_cb);
 
    /*
     * Try loading the config file. This should result in the hook
     * being called
     */
    cfg = ast_config_load(CONFIG_FILE, config_flags);
    ast_config_destroy(cfg);
    if (!hook_run || !hook_config_sane) {
        ast_test_status_update(test, "Config hook either did not run or was given bad data!\n");
        goto out;
    }
 
    /*
     * Now try loading the wrong config file but from the right module.
     * Hook should not run
     */
    hook_run = 0;
    cfg = ast_config_load("asterisk.conf", config_flags);
    ast_config_destroy(cfg);
    if (hook_run) {
        ast_test_status_update(test, "Config hook ran even though an incorrect file was specified.\n");
        goto out;
    }
 
    /*
     * Now try loading the correct config file but from the wrong module.
     * Hook should not run
     */
    hook_run = 0;
    cfg = ast_config_load2(CONFIG_FILE, "fake_module.so", config_flags);
    ast_config_destroy(cfg);
    if (hook_run) {
        ast_test_status_update(test, "Config hook ran even though an incorrect module was specified.\n");
        goto out;
    }
 
    /*
     * Now try loading the file correctly, but without any changes to the file.
     * Hook should not run
     */
    hook_run = 0;
    cfg = ast_config_load(CONFIG_FILE, reload_flags);
    /* Only destroy this cfg conditionally. Otherwise a crash happens. */
    if (cfg != CONFIG_STATUS_FILEUNCHANGED) {
        ast_config_destroy(cfg);
    }
    if (hook_run) {
        ast_test_status_update(test, "Config hook ran even though file contents had not changed\n");
        goto out;
    }
 
    res = AST_TEST_PASS;
 
out:
    ast_config_hook_unregister("test_hook");
    delete_config_file();
    return res;
}

References ast_config_destroy(), ast_config_hook_register(), ast_config_hook_unregister(), ast_config_load, ast_config_load2(), AST_MODULE, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, CONFIG_FILE, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEUNCHANGED, delete_config_file(), hook_cb(), hook_config_sane, hook_run, out, TEST_EXECUTE, TEST_INIT, and write_config_file().

AST_TEST_DEFINE() [6/12]

AST_TEST_DEFINE

(

config_options_test

)

Definition at line 1482 of file test_config.c.

{
    int res = AST_TEST_PASS, x, error;
    struct test_item defaults = { 0, }, configs = { 0, };
    struct test_item *arr[4];
    struct ast_sockaddr acl_allow = {{ 0, }}, acl_fail = {{ 0, }};
    RAII_VAR(struct test_config *, cfg, NULL, ao2_cleanup);
    RAII_VAR(struct test_item *, item, NULL, ao2_cleanup);
    RAII_VAR(struct test_item *, item_defaults, NULL, ao2_cleanup);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "config_options_test";
        info->category = "/config/";
        info->summary = "Config options unit test";
        info->description =
            "Tests the Config Options API";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
#define INT_DEFAULT "-2"
#define INT_CONFIG "-1"
#define UINT_DEFAULT "2"
#define UINT_CONFIG "1"
#define TIMELEN_DEFAULT "2"
#define TIMELEN_CONFIG "1"
#define DOUBLE_DEFAULT "1.1"
#define DOUBLE_CONFIG "0.1"
#define SOCKADDR_DEFAULT "4.3.2.1:4321"
#define SOCKADDR_CONFIG "1.2.3.4:1234"
#define BOOL_DEFAULT "false"
#define BOOL_CONFIG "true"
#define BOOLFLAG1_DEFAULT "false"
#define BOOLFLAG1_CONFIG "true"
#define BOOLFLAG2_DEFAULT "false"
#define BOOLFLAG2_CONFIG "false"
#define BOOLFLAG3_DEFAULT "false"
#define BOOLFLAG3_CONFIG "true"
#define ACL_DEFAULT NULL
#define ACL_CONFIG_PERMIT "1.2.3.4/32"
#define ACL_CONFIG_DENY "0.0.0.0/0"
#define CODEC_DEFAULT "!all,alaw"
#define CODEC_CONFIG "!all,ulaw,g729"
#define STR_DEFAULT "default"
#define STR_CONFIG "test"
#define CUSTOM_DEFAULT "no"
#define CUSTOM_CONFIG "yes"
 
#define BOOLFLAG1 1 << 0
#define BOOLFLAG2 1 << 1
#define BOOLFLAG3 1 << 2
 
    if (aco_info_init(&cfg_info)) {
        ast_test_status_update(test, "Could not init cfg info\n");
        return AST_TEST_FAIL;
    }
 
    /* Register all options */
    aco_option_register(&cfg_info, "intopt", ACO_EXACT, config_test_conf.types, INT_DEFAULT, OPT_INT_T, 0, FLDSET(struct test_item, intopt));
    aco_option_register(&cfg_info, "uintopt", ACO_EXACT, config_test_conf.types, UINT_DEFAULT, OPT_UINT_T, 0, FLDSET(struct test_item, uintopt));
    aco_option_register(&cfg_info, "timelenopt1", ACO_EXACT, config_test_conf.types, TIMELEN_DEFAULT, OPT_TIMELEN_T, 0, FLDSET(struct test_item, timelenopt1), TIMELEN_MILLISECONDS);
    aco_option_register(&cfg_info, "timelenopt2", ACO_EXACT, config_test_conf.types, TIMELEN_DEFAULT, OPT_TIMELEN_T, 0, FLDSET(struct test_item, timelenopt2), TIMELEN_SECONDS);
    aco_option_register(&cfg_info, "timelenopt3", ACO_EXACT, config_test_conf.types, TIMELEN_DEFAULT, OPT_TIMELEN_T, 0, FLDSET(struct test_item, timelenopt3), TIMELEN_MINUTES);
    aco_option_register(&cfg_info, "timelenopt4", ACO_EXACT, config_test_conf.types, TIMELEN_DEFAULT, OPT_TIMELEN_T, 0, FLDSET(struct test_item, timelenopt4), TIMELEN_HOURS);
    aco_option_register(&cfg_info, "doubleopt", ACO_EXACT, config_test_conf.types, DOUBLE_DEFAULT, OPT_DOUBLE_T, 0, FLDSET(struct test_item, doubleopt));
    aco_option_register(&cfg_info, "sockaddropt", ACO_EXACT, config_test_conf.types, SOCKADDR_DEFAULT, OPT_SOCKADDR_T, 0, FLDSET(struct test_item, sockaddropt));
    aco_option_register(&cfg_info, "boolopt", ACO_EXACT, config_test_conf.types, BOOL_DEFAULT, OPT_BOOL_T, 1, FLDSET(struct test_item, boolopt));
    aco_option_register(&cfg_info, "boolflag1", ACO_EXACT, config_test_conf.types, BOOLFLAG1_DEFAULT, OPT_BOOLFLAG_T, 1, FLDSET(struct test_item, flags), BOOLFLAG1);
    aco_option_register(&cfg_info, "boolflag2", ACO_EXACT, config_test_conf.types, BOOLFLAG2_DEFAULT, OPT_BOOLFLAG_T, 1, FLDSET(struct test_item, flags), BOOLFLAG2);
    aco_option_register(&cfg_info, "boolflag3", ACO_EXACT, config_test_conf.types, BOOLFLAG3_DEFAULT, OPT_BOOLFLAG_T, 1, FLDSET(struct test_item, flags), BOOLFLAG3);
    aco_option_register(&cfg_info, "aclpermitopt", ACO_EXACT, config_test_conf.types, ACL_DEFAULT, OPT_ACL_T, 1, FLDSET(struct test_item, aclopt));
    aco_option_register(&cfg_info, "acldenyopt", ACO_EXACT, config_test_conf.types, ACL_DEFAULT, OPT_ACL_T, 0, FLDSET(struct test_item, aclopt));
    aco_option_register(&cfg_info, "codecopt", ACO_EXACT, config_test_conf.types, CODEC_DEFAULT, OPT_CODEC_T, 1, FLDSET(struct test_item, codeccapopt));
    aco_option_register(&cfg_info, "stropt", ACO_EXACT, config_test_conf.types, STR_DEFAULT, OPT_STRINGFIELD_T, 0, STRFLDSET(struct test_item, stropt));
    aco_option_register_custom(&cfg_info, "customopt", ACO_EXACT, config_test_conf.types, CUSTOM_DEFAULT, customopt_handler, 0);
    aco_option_register_deprecated(&cfg_info, "permit", config_test_conf.types, "aclpermitopt");
    aco_option_register_deprecated(&cfg_info, "deny", config_test_conf.types, "acldenyopt");
 
    if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) {
        ast_test_status_update(test, "Could not parse config\n");
        return AST_TEST_FAIL;
    }
 
    ast_parse_arg(INT_DEFAULT, PARSE_INT32, &defaults.intopt);
    ast_parse_arg(INT_CONFIG, PARSE_INT32, &configs.intopt);
    ast_parse_arg(TIMELEN_DEFAULT, PARSE_TIMELEN, &defaults.timelenopt1, TIMELEN_MILLISECONDS);
    ast_parse_arg(TIMELEN_CONFIG, PARSE_TIMELEN, &configs.timelenopt1, TIMELEN_MILLISECONDS);
    ast_parse_arg(TIMELEN_DEFAULT, PARSE_TIMELEN, &defaults.timelenopt2, TIMELEN_SECONDS);
    ast_parse_arg(TIMELEN_CONFIG, PARSE_TIMELEN, &configs.timelenopt2, TIMELEN_SECONDS);
    ast_parse_arg(TIMELEN_DEFAULT, PARSE_TIMELEN, &defaults.timelenopt3, TIMELEN_MINUTES);
    ast_parse_arg(TIMELEN_CONFIG, PARSE_TIMELEN, &configs.timelenopt3, TIMELEN_MINUTES);
    ast_parse_arg(TIMELEN_DEFAULT, PARSE_TIMELEN, &defaults.timelenopt4, TIMELEN_HOURS);
    ast_parse_arg(TIMELEN_CONFIG, PARSE_TIMELEN, &configs.timelenopt4, TIMELEN_HOURS);
    ast_parse_arg(UINT_DEFAULT, PARSE_UINT32, &defaults.uintopt);
    ast_parse_arg(UINT_CONFIG, PARSE_UINT32, &configs.uintopt);
    ast_parse_arg(DOUBLE_DEFAULT, PARSE_DOUBLE, &defaults.doubleopt);
    ast_parse_arg(DOUBLE_CONFIG, PARSE_DOUBLE, &configs.doubleopt);
    ast_parse_arg(SOCKADDR_DEFAULT, PARSE_ADDR, &defaults.sockaddropt);
    ast_parse_arg(SOCKADDR_CONFIG, PARSE_ADDR, &configs.sockaddropt);
    defaults.boolopt = ast_true(BOOL_DEFAULT);
    configs.boolopt = ast_true(BOOL_CONFIG);
    ast_set2_flag(&defaults, ast_true(BOOLFLAG1_DEFAULT), BOOLFLAG1);
    ast_set2_flag(&defaults, ast_true(BOOLFLAG2_DEFAULT), BOOLFLAG2);
    ast_set2_flag(&defaults, ast_true(BOOLFLAG3_DEFAULT), BOOLFLAG3);
    ast_set2_flag(&configs, ast_true(BOOLFLAG1_CONFIG), BOOLFLAG1);
    ast_set2_flag(&configs, ast_true(BOOLFLAG2_CONFIG), BOOLFLAG2);
    ast_set2_flag(&configs, ast_true(BOOLFLAG3_CONFIG), BOOLFLAG3);
 
    defaults.aclopt = NULL;
    configs.aclopt = ast_append_ha("deny", ACL_CONFIG_DENY, configs.aclopt, &error);
    configs.aclopt = ast_append_ha("permit", ACL_CONFIG_PERMIT, configs.aclopt, &error);
    ast_sockaddr_parse(&acl_allow, "1.2.3.4", PARSE_PORT_FORBID);
    ast_sockaddr_parse(&acl_fail, "1.1.1.1", PARSE_PORT_FORBID);
 
    defaults.codeccapopt = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    ast_format_cap_update_by_allow_disallow(defaults.codeccapopt, CODEC_DEFAULT, 1);
 
    configs.codeccapopt = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    ast_format_cap_update_by_allow_disallow(configs.codeccapopt, CODEC_CONFIG, 1);
 
    ast_string_field_init(&defaults, 128);
    ast_string_field_init(&configs, 128);
    ast_string_field_set(&defaults, stropt, STR_DEFAULT);
    ast_string_field_set(&configs, stropt, STR_CONFIG);
 
    defaults.customopt = ast_true(CUSTOM_DEFAULT);
    configs.customopt = ast_true(CUSTOM_CONFIG);
 
 
    cfg = ao2_global_obj_ref(global_obj);
    if (!(item = ao2_find(cfg->items, "item", OBJ_KEY))) {
        ast_test_status_update(test, "could not look up 'item'\n");
        return AST_TEST_FAIL;
    }
    if (!(item_defaults = ao2_find(cfg->items, "item_defaults", OBJ_KEY))) {
        ast_test_status_update(test, "could not look up 'item_defaults'\n");
        return AST_TEST_FAIL;
    }
    arr[0] = cfg->global;
    arr[1] = item;
    arr[2] = cfg->global_defaults;
    arr[3] = item_defaults;
    /* Test global and item against configs, global_defaults and item_defaults against defaults */
 
#define NOT_EQUAL_FAIL(field, format)  \
    if (arr[x]->field != control->field) { \
        ast_test_status_update(test, "%s did not match: " format " != " format " with x = %d\n", #field, arr[x]->field, control->field, x); \
        res = AST_TEST_FAIL; \
    }
    for (x = 0; x < 4; x++) {
        struct test_item *control = x < 2 ? &configs : &defaults;
 
        NOT_EQUAL_FAIL(intopt, "%d");
        NOT_EQUAL_FAIL(uintopt, "%u");
        NOT_EQUAL_FAIL(timelenopt1, "%d");
        NOT_EQUAL_FAIL(timelenopt2, "%d");
        NOT_EQUAL_FAIL(timelenopt3, "%d");
        NOT_EQUAL_FAIL(timelenopt4, "%d");
        NOT_EQUAL_FAIL(boolopt, "%d");
        NOT_EQUAL_FAIL(flags, "%u");
        NOT_EQUAL_FAIL(customopt, "%d");
        if (fabs(arr[x]->doubleopt - control->doubleopt) > 0.001) {
            ast_test_status_update(test, "doubleopt did not match: %f vs %f on loop %d\n", arr[x]->doubleopt, control->doubleopt, x);
            res = AST_TEST_FAIL;
        }
        if (ast_sockaddr_cmp(&arr[x]->sockaddropt, &control->sockaddropt)) {
            ast_test_status_update(test, "sockaddr did not match on loop %d\n", x);
            res = AST_TEST_FAIL;
        }
        if (!ast_format_cap_identical(arr[x]->codeccapopt, control->codeccapopt)) {
            struct ast_str *codec_buf1 = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
            struct ast_str *codec_buf2 = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
            ast_test_status_update(test, "format did not match: '%s' vs '%s' on loop %d\n",
                ast_format_cap_get_names(arr[x]->codeccapopt, &codec_buf1),
                ast_format_cap_get_names(control->codeccapopt, &codec_buf2),
                x);
            res = AST_TEST_FAIL;
        }
        if (strcasecmp(arr[x]->stropt, control->stropt)) {
            ast_test_status_update(test, "stropt did not match: '%s' vs '%s' on loop %d\n", arr[x]->stropt, control->stropt, x);
            res = AST_TEST_FAIL;
        }
        if (arr[x]->aclopt != control->aclopt && (ast_apply_ha(arr[x]->aclopt, &acl_allow) != ast_apply_ha(control->aclopt, &acl_allow) ||
                ast_apply_ha(arr[x]->aclopt, &acl_fail) != ast_apply_ha(control->aclopt, &acl_fail))) {
            ast_test_status_update(test, "acl not match: on loop %d\n", x);
            res = AST_TEST_FAIL;
        }
    }
 
    ast_free_ha(configs.aclopt);
    ao2_cleanup(defaults.codeccapopt);
    defaults.codeccapopt = NULL;
    ao2_cleanup(configs.codeccapopt);
    configs.codeccapopt = NULL;
    ast_string_field_free_memory(&defaults);
    ast_string_field_free_memory(&configs);
    aco_info_destroy(&cfg_info);
    ao2_global_obj_release(global_obj);
    return res;
}

References ACL_CONFIG_DENY, ACL_CONFIG_PERMIT, ACL_DEFAULT, test_item::aclopt, ACO_EXACT, aco_info_destroy(), aco_info_init(), aco_option_register, aco_option_register_custom, aco_option_register_deprecated(), aco_process_config(), ACO_PROCESS_ERROR, ao2_cleanup, ao2_find, ao2_global_obj_ref, ao2_global_obj_release, ast_append_ha(), ast_apply_ha(), ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_names(), ast_format_cap_identical(), AST_FORMAT_CAP_NAMES_LEN, ast_format_cap_update_by_allow_disallow(), ast_free_ha(), ast_parse_arg(), ast_set2_flag, ast_sockaddr_cmp(), ast_sockaddr_parse(), ast_str_alloca, ast_string_field_free_memory, ast_string_field_init, ast_string_field_set, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_true(), BOOL_CONFIG, BOOL_DEFAULT, BOOLFLAG1, BOOLFLAG1_CONFIG, BOOLFLAG1_DEFAULT, BOOLFLAG2, BOOLFLAG2_CONFIG, BOOLFLAG2_DEFAULT, BOOLFLAG3, BOOLFLAG3_CONFIG, BOOLFLAG3_DEFAULT, test_item::boolopt, CODEC_CONFIG, CODEC_DEFAULT, test_item::codeccapopt, config_test_conf, CUSTOM_CONFIG, CUSTOM_DEFAULT, test_item::customopt, customopt_handler(), DOUBLE_CONFIG, DOUBLE_DEFAULT, test_item::doubleopt, error(), test_item::flags, FLDSET, INT_CONFIG, INT_DEFAULT, test_item::intopt, item, NOT_EQUAL_FAIL, NULL, OBJ_KEY, OPT_ACL_T, OPT_BOOL_T, OPT_BOOLFLAG_T, OPT_CODEC_T, OPT_DOUBLE_T, OPT_INT_T, OPT_SOCKADDR_T, OPT_STRINGFIELD_T, OPT_TIMELEN_T, OPT_UINT_T, PARSE_ADDR, PARSE_DOUBLE, PARSE_INT32, PARSE_PORT_FORBID, PARSE_TIMELEN, PARSE_UINT32, RAII_VAR, SOCKADDR_CONFIG, SOCKADDR_DEFAULT, test_item::sockaddropt, STR_CONFIG, STR_DEFAULT, STRFLDSET, test_item::stropt, TEST_EXECUTE, TEST_INIT, TIMELEN_CONFIG, TIMELEN_DEFAULT, TIMELEN_HOURS, TIMELEN_MILLISECONDS, TIMELEN_MINUTES, TIMELEN_SECONDS, test_item::timelenopt1, test_item::timelenopt2, test_item::timelenopt3, test_item::timelenopt4, aco_file::types, UINT_CONFIG, UINT_DEFAULT, and test_item::uintopt.

AST_TEST_DEFINE() [7/12]

AST_TEST_DEFINE

(

config_save

)

Definition at line 885 of file test_config.c.

{
    enum ast_test_result_state res = AST_TEST_FAIL;
    struct ast_flags config_flags = { 0 };
    struct ast_config *cfg;
    char config_filename[PATH_MAX];
    char include_filename[PATH_MAX];
    struct stat config_stat;
    off_t before_save;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "config_save";
        info->category = "/main/config/";
        info->summary = "Test config save";
        info->description =
            "Test configuration save.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    if (write_config_file()) {
        ast_test_status_update(test, "Could not write initial config files\n");
        return res;
    }
 
    snprintf(config_filename, PATH_MAX, "%s/%s", ast_config_AST_CONFIG_DIR, CONFIG_FILE);
    snprintf(include_filename, PATH_MAX, "%s/%s", ast_config_AST_CONFIG_DIR, CONFIG_INCLUDE_FILE);
 
    cfg = ast_config_load(CONFIG_FILE, config_flags);
    if (!cfg) {
        ast_test_status_update(test, "Could not load config\n");
        goto out;
    }
 
    /* We need to re-save to get the generator header */
    if (ast_config_text_file_save(CONFIG_FILE, cfg, "TEST")) {
        ast_test_status_update(test, "Unable to write files\n");
        goto out;
    }
 
    stat(config_filename, &config_stat);
    before_save = config_stat.st_size;
 
    if (!ast_include_new(cfg, CONFIG_FILE, CONFIG_INCLUDE_FILE, 0, NULL, 4, include_filename, PATH_MAX)) {
        ast_test_status_update(test, "Could not create include\n");
        goto out;
    }
 
    if (ast_config_text_file_save(CONFIG_FILE, cfg, "TEST")) {
        ast_test_status_update(test, "Unable to write files\n");
        goto out;
    }
 
    stat(config_filename, &config_stat);
    if (config_stat.st_size <= before_save) {
        ast_test_status_update(test, "Did not save config file with #include\n");
        goto out;
    }
 
    res = AST_TEST_PASS;
 
out:
    ast_config_destroy(cfg);
    unlink(config_filename);
    unlink(include_filename);
 
    return res;
}

References ast_config_AST_CONFIG_DIR, ast_config_destroy(), ast_config_load, ast_config_text_file_save(), ast_include_new(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, CONFIG_FILE, config_filename, CONFIG_INCLUDE_FILE, NULL, out, PATH_MAX, TEST_EXECUTE, TEST_INIT, and write_config_file().

AST_TEST_DEFINE() [8/12]

AST_TEST_DEFINE

(

config_template_ops

)

Definition at line 707 of file test_config.c.

{
    enum ast_test_result_state res = AST_TEST_FAIL;
    struct ast_config *cfg = NULL;
    struct ast_category *cat = NULL;
    char temp[32];
    const char *value;
    int i;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "config_template_ops";
        info->category = "/main/config/";
        info->summary = "Test template config ops";
        info->description = "Test template config ops";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    cfg = ast_config_new();
    if (!cfg) {
        return res;
    }
 
    /* load the config with 5 templates and 5 regular */
    for(i = 0; i < 5; i++) {
        snprintf(temp, sizeof(temp), "test%d", i);
        cat = ast_category_new_template(temp, "dummy", -1);
        ast_variable_insert(cat, ast_variable_new("type", "a", "dummy"), "0");
        ast_category_append(cfg, cat);
    }
 
    for(i = 0; i < 5; i++) {
        snprintf(temp, sizeof(temp), "test%d", i);
        cat = ast_category_new(temp, "dummy", -1);
        ast_variable_insert(cat, ast_variable_new("type", "b", "dummy"), "0");
        ast_category_append(cfg, cat);
    }
 
    /* check the config has 5 template elements of type a */
    i = 0;
    cat = NULL;
    while ((cat = ast_category_browse_filtered(cfg, NULL, cat, "TEMPLATES=restrict,type=a"))) {
        snprintf(temp, sizeof(temp), "test%d", i);
        if (strcmp(ast_category_get_name(cat), temp)) {
            ast_test_status_update(test, "%s != %s\n", ast_category_get_name(cat), temp);
            goto out;
        }
        value = ast_variable_find(cat, "type");
        if (!value || strcmp(value, "a")) {
            ast_test_status_update(test, "Type %s != %s\n", value, "a");
            goto out;
        }
        i++;
    }
    if (i != 5) {
        ast_test_status_update(test, "There were %d matches instead of 5.\n", i);
        goto out;
    }
 
    /* Test again with 'include'.  There should still only be 5 (type a) */
    i = 0;
    cat = NULL;
    while ((cat = ast_category_browse_filtered(cfg, NULL, cat, "TEMPLATES=include,type=a"))) {
        snprintf(temp, sizeof(temp), "test%d", i);
        if (strcmp(ast_category_get_name(cat), temp)) {
            ast_test_status_update(test, "%s != %s\n", ast_category_get_name(cat), temp);
            goto out;
        }
        value = ast_variable_find(cat, "type");
        if (!value || strcmp(value, "a")) {
            ast_test_status_update(test, "Type %s != %s\n", value, "a");
            goto out;
        }
        i++;
    }
    if (i != 5) {
        ast_test_status_update(test, "There were %d matches instead of 5.\n", i);
        goto out;
    }
 
    /* Test again with 'include' but no type.  There should now be 10 (type a and type b) */
    i = 0;
    cat = NULL;
    while ((cat = ast_category_browse_filtered(cfg, NULL, cat, "TEMPLATES=include"))) {
        i++;
    }
    if (i != 10) {
        ast_test_status_update(test, "There were %d matches instead of 10.\n", i);
        goto out;
    }
 
    /* Test again with 'restrict' and type b.  There should 0 */
    i = 0;
    cat = NULL;
    while ((cat = ast_category_browse_filtered(cfg, NULL, cat, "TEMPLATES=restrict,type=b"))) {
        i++;
    }
    if (i != 0) {
        ast_test_status_update(test, "There were %d matches instead of 0.\n", i);
        goto out;
    }
 
    res = AST_TEST_PASS;
 
out:
    ast_config_destroy(cfg);
    return res;
}

References ast_category_append(), ast_category_browse_filtered(), ast_category_get_name(), ast_category_new(), ast_category_new_template(), ast_config_destroy(), ast_config_new(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_variable_find(), ast_variable_insert(), ast_variable_new, NULL, out, TEST_EXECUTE, TEST_INIT, and value.

AST_TEST_DEFINE() [9/12]

AST_TEST_DEFINE

(

copy_config

)

Definition at line 192 of file test_config.c.

{
    enum ast_test_result_state res = AST_TEST_FAIL;
    struct ast_config *cfg = NULL;
    struct ast_config *copy = NULL;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "copy_config";
        info->category = "/main/config/";
        info->summary = "Test copying configuration";
        info->description =
            "Ensure that variables and categories are copied correctly";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    cfg = build_cfg();
    if (!cfg) {
        goto out;
    }
 
    copy = ast_config_copy(cfg);
    if (!copy) {
        goto out;
    }
 
    if (test_config_validity(copy) != 0) {
        goto out;
    }
 
    res = AST_TEST_PASS;
 
out:
    ast_config_destroy(cfg);
    ast_config_destroy(copy);
    return res;
}

References ast_config_copy(), ast_config_destroy(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, build_cfg(), copy(), NULL, out, test_config_validity(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [10/12]

AST_TEST_DEFINE

(

variable_list_from_string

)

Definition at line 1947 of file test_config.c.

{
    RAII_VAR(struct ast_variable *, list, NULL, ast_variables_destroy);
    RAII_VAR(struct ast_str *, str, NULL, ast_free);
    char *parse_string;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "variable_list_from_quoted_string";
        info->category = "/main/config/";
        info->summary = "Test parsing a string into a variable list";
        info->description = info->summary;
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    parse_string = "000= '', 111=, 222 = , 333 = ' ', abc = 'def', ghi = 'j,kl', mno='pq=r', stu = 'vwx=\"yz\", ABC = \"DEF\"'";
    list = ast_variable_list_from_quoted_string(parse_string, ",", "=", "'");
    ast_test_validate(test, list != NULL);
    str = ast_variable_list_join(list, "|", "^", "@", NULL);
 
    ast_test_validate(test,
        strcmp(ast_str_buffer(str), "000^@@|111^@@|222^@@|333^@ @|abc^@def@|ghi^@j,kl@|mno^@pq=r@|stu^@vwx=\"yz\", ABC = \"DEF\"@") == 0);
 
    return AST_TEST_PASS;
}

References ast_free, ast_str_buffer(), AST_TEST_NOT_RUN, AST_TEST_PASS, ast_variable_list_from_quoted_string(), ast_variable_list_join(), ast_variables_destroy(), NULL, RAII_VAR, str, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [11/12]

AST_TEST_DEFINE

(

variable_list_join_replace

)

Definition at line 1896 of file test_config.c.

{
    RAII_VAR(struct ast_variable *, list, NULL, ast_variables_destroy);
    RAII_VAR(struct ast_str *, str, NULL, ast_free);
    struct ast_variable *bbb;
    int rc;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "variable_list_join_replace";
        info->category = "/main/config/";
        info->summary = "Test joining a variable list";
        info->description = info->summary;
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    list = ast_variable_new("aaa", "111", "");
    bbb = ast_variable_new("bbb", "222", "");
    ast_variable_list_append(&list, bbb);
    ast_variable_list_append(&list, ast_variable_new("ccc", "33 33", ""));
 
    str = ast_variable_list_join(list, ", ", " = ", "\"", &str);
    ast_test_validate(test, strcmp(ast_str_buffer(str), "aaa = \"111\", bbb = \"222\", ccc = \"33 33\"") == 0);
    ast_free(str);
 
    str = ast_str_create(AST_MAX_USER_FIELD);
    str = ast_variable_list_join(list, ", ", " = ", "\"", &str);
    ast_test_validate(test, strcmp(ast_str_buffer(str), "aaa = \"111\", bbb = \"222\", ccc = \"33 33\"") == 0);
    ast_free(str);
 
    str = ast_variable_list_join(list, ", ", " = ", "\"", NULL);
    ast_test_validate(test, strcmp(ast_str_buffer(str), "aaa = \"111\", bbb = \"222\", ccc = \"33 33\"") == 0);
    ast_free(str);
 
    /* Replace the head item in the list */
    rc = ast_variable_list_replace_variable(&list, list, ast_variable_new("ddd", "444", ""));
    ast_test_validate(test, rc == 0);
    str = ast_variable_list_join(list, ", ", " = ", "\"", NULL);
    ast_test_validate(test, strcmp(ast_str_buffer(str), "ddd = \"444\", bbb = \"222\", ccc = \"33 33\"") == 0);
    ast_free(str);
 
    rc = ast_variable_list_replace_variable(&list, bbb, ast_variable_new("eee", "555", ""));
    ast_test_validate(test, rc == 0);
    str = ast_variable_list_join(list, ", ", " = ", "\"", NULL);
    ast_test_validate(test, strcmp(ast_str_buffer(str), "ddd = \"444\", eee = \"555\", ccc = \"33 33\"") == 0);
 
    return AST_TEST_PASS;
}

References ast_free, AST_MAX_USER_FIELD, ast_str_buffer(), ast_str_create, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_variable_list_append, ast_variable_list_join(), ast_variable_list_replace_variable(), ast_variable_new, ast_variables_destroy(), NULL, RAII_VAR, str, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [12/12]

AST_TEST_DEFINE

(

variable_lists_match

)

Definition at line 1836 of file test_config.c.

{
    RAII_VAR(struct ast_variable *, left, NULL, ast_variables_destroy);
    RAII_VAR(struct ast_variable *, right, NULL, ast_variables_destroy);
    struct ast_variable *var;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "variable_lists_match";
        info->category = "/main/config/";
        info->summary = "Test ast_variable_lists_match";
        info->description = "Test ast_variable_lists_match";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    var = ast_variable_new("aaa", "111", "");
    ast_test_validate(test, var);
    left = var;
    var = ast_variable_new("bbb", "222", "");
    ast_test_validate(test, var);
    ast_variable_list_append(&left, var);
 
    var = ast_variable_new("aaa", "111", "");
    ast_test_validate(test, var);
    right = var;
 
    ast_test_validate(test, ast_variable_lists_match(left, right, 0));
    ast_test_validate(test, !ast_variable_lists_match(left, right, 1));
 
    var = ast_variable_new("bbb", "222", "");
    ast_test_validate(test, var);
    ast_variable_list_append(&right, var);
 
    ast_test_validate(test, ast_variable_lists_match(left, right, 0));
    ast_test_validate(test, ast_variable_lists_match(left, right, 1));
 
    var = ast_variable_new("ccc >", "333", "");
    ast_test_validate(test, var);
    ast_variable_list_append(&right, var);
 
    ast_test_validate(test, !ast_variable_lists_match(left, right, 0));
    ast_test_validate(test, !ast_variable_lists_match(left, right, 1));
 
    var = ast_variable_new("ccc", "444", "");
    ast_test_validate(test, var);
    ast_variable_list_append(&left, var);
 
    ast_test_validate(test, ast_variable_lists_match(left, right, 0));
    ast_test_validate(test, !ast_variable_lists_match(left, right, 1));
 
    ast_test_validate(test, !ast_variable_lists_match(left, NULL, 0));
    ast_test_validate(test, ast_variable_lists_match(NULL, NULL, 0));
    ast_test_validate(test, !ast_variable_lists_match(NULL, right, 0));
    ast_test_validate(test, ast_variable_lists_match(left, left, 0));
 
    return AST_TEST_PASS;
}

References AST_TEST_NOT_RUN, AST_TEST_PASS, ast_variable_list_append, ast_variable_lists_match(), ast_variable_new, ast_variables_destroy(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and var.

build_cfg()

static struct ast_config * build_cfg ( void  )

static

Build ast_config struct from above definitions.

Return values

NULL	Failed to build the config
non-NULL	An ast_config struct populated with data

Definition at line 115 of file test_config.c.

{
    struct ast_config *cfg;
    struct association *cat_iter;
    struct pair *var_iter;
    size_t i;
    size_t j;
 
    cfg = ast_config_new();
    if (!cfg) {
        goto fail;
    }
 
    for (i = 0; i < ARRAY_LEN(categories); ++i) {
        struct ast_category *cat;
        cat_iter = &categories[i];
 
        cat = ast_category_new(cat_iter->category, "", 999999);
        if (!cat) {
            goto fail;
        }
        ast_category_append(cfg, cat);
 
        for (j = 0; j < ARRAY_LEN(cat_iter->vars); ++j) {
            struct ast_variable *var;
            var_iter = &cat_iter->vars[j];
 
            var = ast_variable_new(var_iter->name, var_iter->val, "");
            if (!var) {
                goto fail;
            }
            ast_variable_append(cat, var);
        }
    }
 
    return cfg;
 
fail:
    ast_config_destroy(cfg);
    return NULL;
}

References ARRAY_LEN, ast_category_append(), ast_category_new(), ast_config_destroy(), ast_config_new(), ast_variable_append(), ast_variable_new, categories, association::category, pair::name, NULL, pair::val, var, and association::vars.

Referenced by AST_TEST_DEFINE().

CONFIG_INFO_TEST()

CONFIG_INFO_TEST	(	cfg_info	,
		global_obj	,
		test_config_alloc	,
		.	files = ACO_FILES(&config_test_conf)
	)

customopt_handler()

static int customopt_handler ( const struct aco_option *  opt, struct ast_variable *  var, void *  obj  )

static

Definition at line 1433 of file test_config.c.

{
    struct test_item *item = obj;
    if (!strcasecmp(var->name, "customopt")) {
        item->customopt = ast_true(var->value);
    } else {
        return -1;
    }
 
    return 0;
}

References ast_true(), item, and var.

Referenced by AST_TEST_DEFINE().

delete_config_file()

static void delete_config_file ( void  )

static

Delete config file created by write_config_file.

Definition at line 856 of file test_config.c.

{
    char filename[PATH_MAX];
    snprintf(filename, sizeof(filename), "%s/%s",
            ast_config_AST_CONFIG_DIR, CONFIG_FILE);
    unlink(filename);
}

References ast_config_AST_CONFIG_DIR, CONFIG_FILE, and PATH_MAX.

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

hook_cb()

static int hook_cb ( struct ast_config *  cfg )

static

Definition at line 875 of file test_config.c.

{
    hook_run = 1;
    if (test_config_validity(cfg) == 0) {
        hook_config_sane = 1;
    }
    ast_config_destroy(cfg);
    return 0;
}

References ast_config_destroy(), hook_config_sane, hook_run, and test_config_validity().

Referenced by ast_bridge_move_hook(), ast_bridge_talk_detector_hook(), ast_config_hook_register(), and AST_TEST_DEFINE().

load_module()

static int load_module ( void  )

static

Definition at line 1992 of file test_config.c.

{
    AST_TEST_REGISTER(config_save);
    AST_TEST_REGISTER(config_basic_ops);
    AST_TEST_REGISTER(config_filtered_ops);
    AST_TEST_REGISTER(config_template_ops);
    AST_TEST_REGISTER(copy_config);
    AST_TEST_REGISTER(config_hook);
    AST_TEST_REGISTER(ast_parse_arg_test);
    AST_TEST_REGISTER(config_options_test);
    AST_TEST_REGISTER(config_dialplan_function);
    AST_TEST_REGISTER(variable_lists_match);
    AST_TEST_REGISTER(variable_list_join_replace);
    AST_TEST_REGISTER(variable_list_from_string);
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

test_config_alloc()

static void * test_config_alloc ( void  )

static

Definition at line 1407 of file test_config.c.

{
    struct test_config *cfg;
    if (!(cfg = ao2_alloc(sizeof(*cfg), test_config_destructor))) {
        goto error;
    }
    if (!(cfg->global = test_item_alloc("global"))) {
        goto error;
    }
    if (!(cfg->global_defaults = test_item_alloc("global_defaults"))) {
        goto error;
    }
    cfg->items = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, test_item_cmp);
    if (!cfg->items) {
        goto error;
    }
    return cfg;
error:
    ao2_cleanup(cfg);
    return NULL;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_cleanup, ao2_container_alloc_list, error(), test_config::global, test_config::global_defaults, test_config::items, NULL, test_config_destructor(), test_item_alloc(), and test_item_cmp().

test_config_destructor()

static void test_config_destructor ( void *  obj )

static

Definition at line 1400 of file test_config.c.

{
    struct test_config *cfg = obj;
    ao2_cleanup(cfg->global);
    ao2_cleanup(cfg->global_defaults);
    ao2_cleanup(cfg->items);
}

References ao2_cleanup, test_config::global, test_config::global_defaults, and test_config::items.

Referenced by test_config_alloc().

test_config_validity()

static int test_config_validity ( struct ast_config *  cfg )

static

Tests that the contents of an ast_config is what is expected.

Parameters

cfg	Config to test

Return values

-1	Failed to pass a test
0	Config passes checks

Definition at line 164 of file test_config.c.

{
    int i;
    const char *cat_iter = NULL;
    /* Okay, let's see if the correct content is there */
    for (i = 0; i < ARRAY_LEN(categories); ++i) {
        struct ast_variable *var = NULL;
        size_t j;
        cat_iter = ast_category_browse(cfg, cat_iter);
        if (strcmp(cat_iter, categories[i].category)) {
            ast_log(LOG_ERROR, "Category name mismatch, %s does not match %s\n", cat_iter, categories[i].category);
            return -1;
        }
        for (j = 0; j < ARRAY_LEN(categories[i].vars); ++j) {
            var = var ? var->next : ast_variable_browse(cfg, cat_iter);
            if (strcmp(var->name, categories[i].vars[j].name)) {
                ast_log(LOG_ERROR, "Variable name mismatch, %s does not match %s\n", var->name, categories[i].vars[j].name);
                return -1;
            }
            if (strcmp(var->value, categories[i].vars[j].val)) {
                ast_log(LOG_ERROR, "Variable value mismatch, %s does not match %s\n", var->value, categories[i].vars[j].val);
                return -1;
            }
        }
    }
    return 0;
}

References ARRAY_LEN, ast_category_browse(), ast_log, ast_variable_browse(), categories, LOG_ERROR, pair::name, NULL, pair::val, var, and association::vars.

Referenced by AST_TEST_DEFINE(), and hook_cb().

test_item_alloc()

static void * test_item_alloc ( const char *  cat )

static

Definition at line 1383 of file test_config.c.

{
    struct test_item *item;
    if (!(item = ao2_alloc(sizeof(*item), test_item_destructor))) {
        return NULL;
    }
    if (ast_string_field_init(item, 128)) {
        ao2_ref(item, -1);
        return NULL;
    }
    if (!(item->codeccapopt = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
        ao2_ref(item, -1);
        return NULL;
    }
    ast_string_field_set(item, name, cat);
    return item;
}

References ao2_alloc, ao2_ref, ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, ast_string_field_init, ast_string_field_set, item, name, NULL, and test_item_destructor().

Referenced by test_config_alloc().

test_item_cmp()

static int test_item_cmp ( void *  obj, void *  arg, int  flags  )

static

Definition at line 1367 of file test_config.c.

{
    struct test_item *one = obj, *two = arg;
    const char *match = (flags & OBJ_KEY) ? arg : two->name;
    return strcasecmp(one->name, match) ? 0 : (CMP_MATCH | CMP_STOP);
}

References CMP_MATCH, CMP_STOP, test_item::flags, match(), test_item::name, and OBJ_KEY.

Referenced by test_config_alloc().

test_item_destructor()

static void test_item_destructor ( void *  obj )

static

Definition at line 1373 of file test_config.c.

{
    struct test_item *item = obj;
    ast_string_field_free_memory(item);
    ao2_cleanup(item->codeccapopt);
    if (item->aclopt) {
        ast_free_ha(item->aclopt);
    }
    return;
}

References ao2_cleanup, ast_free_ha(), ast_string_field_free_memory, and item.

Referenced by test_item_alloc().

test_item_find()

static void * test_item_find ( struct ao2_container *  container, const char *  cat  )

static

Definition at line 1428 of file test_config.c.

{
    return ao2_find(container, cat, OBJ_KEY);
}

References ao2_find, container, and OBJ_KEY.

unload_module()

static int unload_module ( void  )

static

Definition at line 1975 of file test_config.c.

{
    AST_TEST_UNREGISTER(config_save);
    AST_TEST_UNREGISTER(config_basic_ops);
    AST_TEST_UNREGISTER(config_filtered_ops);
    AST_TEST_UNREGISTER(config_template_ops);
    AST_TEST_UNREGISTER(copy_config);
    AST_TEST_UNREGISTER(config_hook);
    AST_TEST_UNREGISTER(ast_parse_arg_test);
    AST_TEST_UNREGISTER(config_options_test);
    AST_TEST_UNREGISTER(config_dialplan_function);
    AST_TEST_UNREGISTER(variable_lists_match);
    AST_TEST_UNREGISTER(variable_list_join_replace);
    AST_TEST_UNREGISTER(variable_list_from_string);
    return 0;
}

References AST_TEST_UNREGISTER.

write_config_file()

static int write_config_file ( void  )

static

Write the config file to disk.

This is necessary for testing config hooks since they are only triggered when a config is read from its intended storage medium

Definition at line 825 of file test_config.c.

{
    int i;
    FILE *config_file;
    char filename[PATH_MAX];
 
    snprintf(filename, sizeof(filename), "%s/%s",
            ast_config_AST_CONFIG_DIR, CONFIG_FILE);
    config_file = fopen(filename, "w");
 
    if (!config_file) {
        return -1;
    }
 
    for (i = 0; i < ARRAY_LEN(categories); ++i) {
        int j;
        fprintf(config_file, "[%s]\n", categories[i].category);
        for (j = 0; j < ARRAY_LEN(categories[i].vars); ++j) {
            fprintf(config_file, "%s = %s\n",
                    categories[i].vars[j].name,
                    categories[i].vars[j].val);
        }
    }
 
    fclose(config_file);
    return 0;
}

References ARRAY_LEN, ast_config_AST_CONFIG_DIR, categories, config_file, CONFIG_FILE, name, and PATH_MAX.

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Config test module" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 2009 of file test_config.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2009 of file test_config.c.

cat1

const char cat1[] = "Capitals"

Definition at line 68 of file test_config.c.

cat1varname1

const char cat1varname1[] = "Germany"

Definition at line 69 of file test_config.c.

cat1varname2

const char cat1varname2[] = "China"

Definition at line 71 of file test_config.c.

cat1varname3

const char cat1varname3[] = "Canada"

Definition at line 73 of file test_config.c.

cat1varvalue1

const char cat1varvalue1[] = "Berlin"

Definition at line 70 of file test_config.c.

cat1varvalue2

const char cat1varvalue2[] = "Beijing"

Definition at line 72 of file test_config.c.

cat1varvalue3

const char cat1varvalue3[] = "Ottawa"

Definition at line 74 of file test_config.c.

cat2

const char cat2[] = "Protagonists"

Definition at line 76 of file test_config.c.

cat2varname1

const char cat2varname1[] = "1984"

Definition at line 77 of file test_config.c.

cat2varname2

const char cat2varname2[] = "Green Eggs And Ham"

Definition at line 79 of file test_config.c.

cat2varname3

const char cat2varname3[] = "The Kalevala"

Definition at line 81 of file test_config.c.

cat2varvalue1

const char cat2varvalue1[] = "Winston Smith"

Definition at line 78 of file test_config.c.

cat2varvalue2

const char cat2varvalue2[] = "Sam I Am"

Definition at line 80 of file test_config.c.

cat2varvalue3

const char cat2varvalue3[] = "Vainamoinen"

Definition at line 82 of file test_config.c.

categories

struct association categories[]

Referenced by build_cfg(), caldav_add_event(), calendar_write_exec(), config_ldap(), copy_event_data(), endelm(), ewscal_write_event(), icalendar_add_event(), internal_aco_type_category_check(), test_config_validity(), and write_config_file().

config_test_conf

struct aco_file config_test_conf

Initial value:

= {
    .filename = "config_test.conf",
    .types = ACO_TYPES(&global, &global_defaults, &item),
}

Definition at line 1472 of file test_config.c.

                                   {
    .filename = "config_test.conf",
    .types = ACO_TYPES(&global, &global_defaults, &item),
};

Referenced by AST_TEST_DEFINE().

global

struct aco_type global

static

Examples

app_skel.c.

Definition at line 1445 of file test_config.c.

                                {
    .type = ACO_GLOBAL,
    .item_offset = offsetof(struct test_config, global),
    .category_match = ACO_WHITELIST,
    .category = "^global$",
};

Referenced by custom_bitfield_handler(), custom_nameserver_handler(), general_handler(), global_bitfield_handler(), pbx_builtin_setvar(), pickup_handler(), skel_global_config_destructor(), unbound_global_config_destructor(), and xfer_handler().

global_defaults

struct aco_type global_defaults

static

Definition at line 1451 of file test_config.c.

                                         {
    .type = ACO_GLOBAL,
    .item_offset = offsetof(struct test_config, global_defaults),
    .category_match = ACO_WHITELIST_EXACT,
    .category = "global_defaults",
};

hook_config_sane

int hook_config_sane

static

Definition at line 873 of file test_config.c.

Referenced by AST_TEST_DEFINE(), and hook_cb().

hook_run

int hook_run

static

Definition at line 867 of file test_config.c.

Referenced by AST_TEST_DEFINE(), and hook_cb().

item

struct aco_type item

static

Definition at line 1463 of file test_config.c.

                              {
    .type = ACO_ITEM,
    .category_match = ACO_BLACKLIST_ARRAY,
    .category = (const char *)item_blacklist,
    .item_alloc = test_item_alloc,
    .item_find = test_item_find,
    .item_offset = offsetof(struct test_config, items),
};

Referenced by ael2_semantic_check(), agent_function_read(), application_tuple_cmp(), applicationmap_handler(), applicationmap_item_alloc(), ast_applicationmap_item_destructor(), ast_context_find(), ast_get_chan_applicationmap(), ast_get_feature(), ast_process_pending_reloads(), AST_TEST_DEFINE(), ast_variable_list_from_quoted_string(), ast_xml_doc_item_alloc(), ast_xml_doc_item_hash(), ast_xmldoc_build_documentation(), ast_xmldoc_regenerate_doc_item(), build_cli_notify(), build_config_docs(), check_break(), check_continue(), check_goto(), check_label(), check_match(), check_pval(), check_pval_item(), check_switch_expr(), cli_show_module_options(), cli_show_module_type(), cli_show_module_types(), cli_show_modules(), conf_free(), conf_run(), container_to_json_array(), contains_switch(), customopt_handler(), destroy_pval(), destroy_pval_item(), do_directory(), featuregroup_handler(), featuregroup_item_destructor(), find_context(), find_context_locked(), find_pval_goto_item(), find_pval_gotos(), find_switch_item(), get_goto_target(), handle_manager_show_event(), handle_manager_show_events(), in_context(), in_macro(), item_in_vector(), list_item_handler(), load_config(), load_config(), match_pval(), match_pval_item(), named_acl_find_realtime(), notify_option_handler(), print_applicationmap(), print_featuregroup(), print_pval(), print_pval_list(), queue_reload_request(), resource_event_handler(), search_directory_sub(), select_entry(), select_item_menu(), select_item_seq(), setup_dynamic_feature(), test_item_alloc(), test_item_destructor(), tlist_add_head(), tlist_del_item(), traverse_pval_item_template(), traverse_pval_template(), type_in_list(), xmldoc_build_documentation_item(), xmpp_client_unsubscribe_user(), xmpp_component_service_discovery_get_hook(), xmpp_component_service_discovery_items_hook(), xmpp_pubsub_build_publish_skeleton(), xmpp_pubsub_delete_node_list(), xmpp_pubsub_handle_event(), xmpp_pubsub_receive_node_list(), and xmpp_roster_hook().

item_blacklist

const char* item_blacklist[]

static

Initial value:

= {
    "global",
    "global_defaults",
    NULL,
}

Definition at line 1457 of file test_config.c.

                                      {
    "global",
    "global_defaults",
    NULL,
};