Test module for out-of-call text message module. More...

#include "asterisk.h"
#include <regex.h>
#include "asterisk/module.h"
#include "asterisk/test.h"
#include "asterisk/message.h"
#include "asterisk/pbx.h"
#include "asterisk/manager.h"
#include "asterisk/vector.h"

Include dependency graph for test_message.c:

Go to the source code of this file.

Data Structures
struct	var_vector
	The expected user event fields. More...

Macros
#define	DEFAULT_EXPECTED_EVENTS 4
	The number of user events we should get in a dialplan test.

#define	FREE_VARIABLE_VECTOR(vector)

#define	TEST_CATEGORY "/main/message/"

#define	TEST_CONTEXT "__TEST_MESSAGE_CONTEXT__"

#define	TEST_EXTENSION "test_message_extension"

Functions
static void	__reg_module (void)

static void	__unreg_module (void)

struct ast_module *	AST_MODULE_SELF_SYM (void)

static void	ast_msg_safe_destroy (void *obj)

	AST_TEST_DEFINE (test_message_has_destination_dialplan)

	AST_TEST_DEFINE (test_message_has_destination_handler)

	AST_TEST_DEFINE (test_message_manipulation)

	AST_TEST_DEFINE (test_message_msg_handler_registration)

	AST_TEST_DEFINE (test_message_msg_send)

	AST_TEST_DEFINE (test_message_msg_tech_registration)

	AST_TEST_DEFINE (test_message_queue_both_nominal)

	AST_TEST_DEFINE (test_message_queue_dialplan_nominal)

	AST_TEST_DEFINE (test_message_queue_handler_nominal)

static int	create_test_dialplan (void)

static int	handler_wait_for_message (struct ast_test *test)
	Wait for the test_msg_handler to receive the message.

static int	load_module (void)

static int	test_cleanup_cb (struct ast_test_info info, struct ast_test test)

static int	test_init_cb (struct ast_test_info info, struct ast_test test)

static int	test_msg_handle_msg_cb (struct ast_msg *msg)

static int	test_msg_has_destination_cb (const struct ast_msg *msg)

static int	test_msg_send (const struct ast_msg msg, const char to, const char *from)

static int	unload_module (void)

static int	user_event_hook_cb (int category, const char event, char body)

static int	user_event_wait_for_events (struct ast_test *test, int expected_events)
	Wait for the expected number of user events to be received.

static int	verify_bad_headers (struct ast_test *test)

static int	verify_user_event_fields (int user_event, const char header, const char value)
	Verifies a user event header/value pair.

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Out-of-call text message support" , .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

struct {

size_t current

struct ast_variable ** elems

size_t max

}	bad_headers
	If a user event fails, the bad headers that didn't match.

struct var_vector	expected_user_event_fields

static int	expected_user_events
	The number of user events we expect for this test.

static ast_cond_t	handler_cond
	Condition wait variable for test_msg_handler receiving message.

static ast_mutex_t	handler_lock = AST_MUTEX_INIT_VALUE
	Mutex for `handler_cond`.

static int	handler_received_message
	Predicate for the test_msg_handler receiving a message.

static int	message_received

static int	received_user_events
	The current number of received user events.

static struct ast_msg_handler	test_msg_handler
	Our test message handler.

static struct ast_msg_tech	test_msg_tech

static ast_cond_t	user_event_cond
	Condition wait variable for all dialplan user events being received.

static struct manager_custom_hook	user_event_hook
	AMI event hook that verifies whether or not we've gotten our user events.

static ast_mutex_t	user_event_lock = AST_MUTEX_INIT_VALUE
	Mutex for `user_event_cond`.

Detailed Description

Test module for out-of-call text message module.

Author

Matt Jordan <mjordan@digium.com>

Definition in file test_message.c.

Macro Definition Documentation

◆ DEFAULT_EXPECTED_EVENTS

#define DEFAULT_EXPECTED_EVENTS 4

The number of user events we should get in a dialplan test.

Definition at line 50 of file test_message.c.

◆ FREE_VARIABLE_VECTOR

#define FREE_VARIABLE_VECTOR ( vector )

Definition at line 787 of file test_message.c.

                                        { \
    int i; \
    for (i = 0; i < AST_VECTOR_SIZE(&(vector)); i++) { \
        struct ast_variable *headers; \
        headers = AST_VECTOR_GET(&(vector), i); \
        if (!headers) { \
            continue; \
        } \
        ast_variables_destroy(headers); \
    } \
    AST_VECTOR_FREE(&(vector)); \
    } while (0)

◆ TEST_CATEGORY

#define TEST_CATEGORY "/main/message/"

Definition at line 44 of file test_message.c.

◆ TEST_CONTEXT

#define TEST_CONTEXT "__TEST_MESSAGE_CONTEXT__"

Definition at line 46 of file test_message.c.

◆ TEST_EXTENSION

#define TEST_EXTENSION "test_message_extension"

Definition at line 47 of file test_message.c.

Function Documentation

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 881 of file test_message.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 881 of file test_message.c.

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void )

Definition at line 881 of file test_message.c.

◆ ast_msg_safe_destroy()

static void ast_msg_safe_destroy ( void * obj )

static

Definition at line 365 of file test_message.c.

{
    struct ast_msg *msg = obj;
 
    if (msg) {
        ast_msg_destroy(msg);
    }
}

References ast_msg_destroy().

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), and AST_TEST_DEFINE().

◆ AST_TEST_DEFINE() [1/9]

AST_TEST_DEFINE ( test_message_has_destination_dialplan )

Definition at line 652 of file test_message.c.

{
    RAII_VAR(struct ast_msg *, msg, NULL, ast_msg_safe_destroy);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test checking for a dialplan destination";
        info->description =
            "Test that a message's destination is verified via the\n"
            "dialplan";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    msg = ast_msg_alloc();
    ast_test_validate(test, msg != NULL);
 
    ast_msg_set_context(msg, TEST_CONTEXT);
    ast_msg_set_exten(msg, TEST_EXTENSION);
    ast_test_validate(test, ast_msg_has_destination(msg) == 1);
 
    ast_msg_set_context(msg, "__I_SHOULD_NOT_EXIST_PLZ__");
    ast_test_validate(test, ast_msg_has_destination(msg) == 0);
 
    ast_msg_set_context(msg, TEST_CONTEXT);
    ast_msg_set_exten(msg, "__I_SHOULD_NOT_EXIST_PLZ__");
    ast_test_validate(test, ast_msg_has_destination(msg) == 0);
 
    ast_msg_set_exten(msg, "%s", "");
    ast_test_validate(test, ast_msg_has_destination(msg) == 0);
 
    ast_msg_set_context(msg, "%s", "");
    ast_msg_set_exten(msg, TEST_EXTENSION);
    ast_test_validate(test, ast_msg_has_destination(msg) == 0);
 
    return AST_TEST_PASS;
}

References ast_msg_alloc(), ast_msg_has_destination(), ast_msg_safe_destroy(), ast_msg_set_context(), ast_msg_set_exten(), AST_TEST_NOT_RUN, AST_TEST_PASS, NULL, RAII_VAR, TEST_CATEGORY, TEST_CONTEXT, TEST_EXECUTE, TEST_EXTENSION, and TEST_INIT.

◆ AST_TEST_DEFINE() [2/9]

AST_TEST_DEFINE ( test_message_has_destination_handler )

Definition at line 693 of file test_message.c.

{
    RAII_VAR(struct ast_msg *, msg, NULL, ast_msg_safe_destroy);
    int result;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test checking for a handler destination";
        info->description =
            "Test that a message's destination is verified via a\n"
            "handler";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    result = ast_msg_handler_register(&test_msg_handler);
    ast_test_validate(test, result == 0);
 
    msg = ast_msg_alloc();
    ast_test_validate(test, msg != NULL);
 
    ast_msg_set_to(msg, "foo");
    ast_msg_set_context(msg, TEST_CONTEXT);
    ast_msg_set_exten(msg, "%s", "");
    ast_test_validate(test, ast_msg_has_destination(msg) == 1);
 
    ast_msg_set_context(msg, "%s", "");
    ast_test_validate(test, ast_msg_has_destination(msg) == 1);
 
    ast_msg_set_to(msg, "__I_SHOULD_NOT_EXIST_PLZ__");
    ast_test_validate(test, ast_msg_has_destination(msg) == 0);
 
    result = ast_msg_handler_unregister(&test_msg_handler);
    ast_test_validate(test, result == 0);
 
    return AST_TEST_PASS;
}

References ast_msg_alloc(), ast_msg_handler_register(), ast_msg_handler_unregister(), ast_msg_has_destination(), ast_msg_safe_destroy(), ast_msg_set_context(), ast_msg_set_exten(), ast_msg_set_to(), AST_TEST_NOT_RUN, AST_TEST_PASS, NULL, RAII_VAR, result, TEST_CATEGORY, TEST_CONTEXT, TEST_EXECUTE, TEST_INIT, and test_msg_handler.

◆ AST_TEST_DEFINE() [3/9]

AST_TEST_DEFINE ( test_message_manipulation )

Definition at line 374 of file test_message.c.

{
    RAII_VAR(struct ast_msg *, msg, NULL, ast_msg_safe_destroy);
    RAII_VAR(struct ast_msg_var_iterator *, it_vars, NULL, ast_msg_var_iterator_destroy);
    int result;
    const char *actual;
    const char *out_name;
    const char *out_value;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test manipulating properties of a message";
        info->description =
            "This test covers the following:\n"
            "\tSetting/getting the body\n"
            "\tSetting/getting inbound/outbound variables\n"
            "\tIterating over variables";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    msg = ast_msg_alloc();
    ast_test_validate(test, msg != NULL);
 
    /* Test setting/getting to */
    result = ast_msg_set_to(msg, "testmsg:%s", "foo");
    ast_test_validate(test, result == 0);
    actual = ast_msg_get_to(msg);
    ast_test_validate(test, !strcmp(actual, "testmsg:foo"));
 
    /* Test setting/getting from */
    result = ast_msg_set_from(msg, "testmsg:%s", "bar");
    ast_test_validate(test, result == 0);
    actual = ast_msg_get_from(msg);
    ast_test_validate(test, !strcmp(actual, "testmsg:bar"));
 
    /* Test setting/getting body */
    result = ast_msg_set_body(msg, "BodyTest: %s", "foo");
    ast_test_validate(test, result == 0);
    actual = ast_msg_get_body(msg);
    ast_test_validate(test, !strcmp(actual, "BodyTest: foo"));
 
    /* Test setting/getting technology */
    result = ast_msg_set_tech(msg, "%s", "my_tech");
    ast_test_validate(test, result == 0);
    actual = ast_msg_get_tech(msg);
    ast_test_validate(test, !strcmp(actual, "my_tech"));
 
    /* Test setting/getting endpoint */
    result = ast_msg_set_endpoint(msg, "%s", "terminus");
    ast_test_validate(test, result == 0);
    actual = ast_msg_get_endpoint(msg);
    ast_test_validate(test, !strcmp(actual, "terminus"));
 
    /* Test setting/getting non-outbound variable */
    result = ast_msg_set_var(msg, "foo", "bar");
    ast_test_validate(test, result == 0);
    actual = ast_msg_get_var(msg, "foo");
    ast_test_validate(test, !strcmp(actual, "bar"));
 
    /* Test updating existing variable */
    result = ast_msg_set_var(msg, "foo", "new_bar");
    ast_test_validate(test, result == 0);
    actual = ast_msg_get_var(msg, "foo");
    ast_test_validate(test, !strcmp(actual, "new_bar"));
 
    /* Verify a non-outbound variable is not iterable */
    it_vars = ast_msg_var_iterator_init(msg);
    ast_test_validate(test, it_vars != NULL);
    ast_test_validate(test, ast_msg_var_iterator_next(msg, it_vars, &out_name, &out_value) == 0);
    ast_msg_var_iterator_destroy(it_vars);
 
    /* Test updating an existing variable as an outbound variable */
    result = ast_msg_set_var_outbound(msg, "foo", "outbound_bar");
    ast_test_validate(test, result == 0);
    it_vars = ast_msg_var_iterator_init(msg);
    ast_test_validate(test, it_vars != NULL);
    result = ast_msg_var_iterator_next(msg, it_vars, &out_name, &out_value);
    ast_test_validate(test, result == 1);
    ast_test_validate(test, !strcmp(out_name, "foo"));
    ast_test_validate(test, !strcmp(out_value, "outbound_bar"));
    ast_msg_var_unref_current(it_vars);
    result = ast_msg_var_iterator_next(msg, it_vars, &out_name, &out_value);
    ast_test_validate(test, result == 0);
 
    return AST_TEST_PASS;
}

References ast_msg_alloc(), ast_msg_get_body(), ast_msg_get_endpoint(), ast_msg_get_from(), ast_msg_get_tech(), ast_msg_get_to(), ast_msg_get_var(), ast_msg_safe_destroy(), ast_msg_set_body(), ast_msg_set_endpoint(), ast_msg_set_from(), ast_msg_set_tech(), ast_msg_set_to(), ast_msg_set_var(), ast_msg_set_var_outbound(), ast_msg_var_iterator_destroy(), ast_msg_var_iterator_init(), ast_msg_var_iterator_next(), ast_msg_var_unref_current(), AST_TEST_NOT_RUN, AST_TEST_PASS, NULL, RAII_VAR, result, TEST_CATEGORY, TEST_EXECUTE, and TEST_INIT.

◆ AST_TEST_DEFINE() [4/9]

AST_TEST_DEFINE ( test_message_msg_handler_registration )

Definition at line 332 of file test_message.c.

{
    int reg_result;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test register/unregister of a message handler";
        info->description =
            "Test that:\n"
            "\tA message handler can be registered once only\n"
            "\tA registered message handler can be unregistered once only";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    reg_result = ast_msg_handler_register(&test_msg_handler);
    ast_test_validate(test, reg_result == 0);
 
    reg_result = ast_msg_handler_register(&test_msg_handler);
    ast_test_validate(test, reg_result == -1);
 
    reg_result = ast_msg_handler_unregister(&test_msg_handler);
    ast_test_validate(test, reg_result == 0);
 
    reg_result = ast_msg_handler_unregister(&test_msg_handler);
    ast_test_validate(test, reg_result == -1);
 
    return AST_TEST_PASS;
}

References ast_msg_handler_register(), ast_msg_handler_unregister(), AST_TEST_NOT_RUN, AST_TEST_PASS, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, and test_msg_handler.

◆ AST_TEST_DEFINE() [5/9]

AST_TEST_DEFINE ( test_message_msg_send )

Definition at line 734 of file test_message.c.

{
    RAII_VAR(struct ast_msg *, msg, NULL, ast_msg_safe_destroy);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test message routing";
        info->description =
            "Test that a message can be routed if it has\n"
            "a valid handler";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_test_validate(test, ast_msg_tech_register(&test_msg_tech) == 0);
    ast_test_validate(test, ast_msg_handler_register(&test_msg_handler) == 0);
 
    msg = ast_msg_alloc();
    ast_test_validate(test, msg != NULL);
 
    ast_msg_set_to(msg, "foo");
    ast_msg_set_context(msg, TEST_CONTEXT);
    ast_msg_set_exten(msg, "%s", "");
    ast_test_validate(test, ast_msg_has_destination(msg) == 1);
 
    if (!ast_msg_send(msg, "testmsg:foo", "blah")) {
        msg = NULL;
    } else {
        ast_test_status_update(test, "Failed to send message\n");
        ast_test_set_result(test, AST_TEST_FAIL);
    }
 
    ast_test_validate(test, ast_msg_handler_unregister(&test_msg_handler) == 0);
    ast_test_validate(test, ast_msg_tech_unregister(&test_msg_tech) == 0);
 
    return AST_TEST_PASS;
}

References ast_msg_alloc(), ast_msg_handler_register(), ast_msg_handler_unregister(), ast_msg_has_destination(), ast_msg_safe_destroy(), ast_msg_send(), ast_msg_set_context(), ast_msg_set_exten(), ast_msg_set_to(), ast_msg_tech_register(), ast_msg_tech_unregister(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_CATEGORY, TEST_CONTEXT, TEST_EXECUTE, TEST_INIT, test_msg_handler, and test_msg_tech.

◆ AST_TEST_DEFINE() [6/9]

AST_TEST_DEFINE ( test_message_msg_tech_registration )

Definition at line 299 of file test_message.c.

{
    int reg_result;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test register/unregister of a message tech";
        info->description =
            "Test that:\n"
            "\tA message technology can be registered once only\n"
            "\tA registered message technology can be unregistered once only";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    reg_result = ast_msg_tech_register(&test_msg_tech);
    ast_test_validate(test, reg_result == 0);
 
    reg_result = ast_msg_tech_register(&test_msg_tech);
    ast_test_validate(test, reg_result == -1);
 
    reg_result = ast_msg_tech_unregister(&test_msg_tech);
    ast_test_validate(test, reg_result == 0);
 
    reg_result = ast_msg_tech_unregister(&test_msg_tech);
    ast_test_validate(test, reg_result == -1);
 
    return AST_TEST_PASS;
}

References ast_msg_tech_register(), ast_msg_tech_unregister(), AST_TEST_NOT_RUN, AST_TEST_PASS, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, and test_msg_tech.

◆ AST_TEST_DEFINE() [7/9]

AST_TEST_DEFINE ( test_message_queue_both_nominal )

Definition at line 577 of file test_message.c.

{
    RAII_VAR(struct ast_msg *, msg, NULL, ast_msg_safe_destroy);
    struct ast_variable *expected;
    struct ast_variable *expected_response = NULL;
    int result;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test enqueueing messages to a dialplan and custom handler";
        info->description =
            "Test that a message enqueued is passed to all\n"
            "handlers that can process it, dialplan as well as\n"
            "a custom handler";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    msg = ast_msg_alloc();
    ast_test_validate(test, msg != NULL);
 
    result = ast_msg_handler_register(&test_msg_handler);
    ast_test_validate(test, result == 0);
 
    expected = ast_variable_new("Verify","^To$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    expected = ast_variable_new("Value","^foo$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    AST_VECTOR_REPLACE(&expected_user_event_fields, 0, expected_response);
 
    expected_response = NULL;
    expected = ast_variable_new("Verify", "^From$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    expected = ast_variable_new("Value","^bar$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    AST_VECTOR_REPLACE(&expected_user_event_fields, 1, expected_response);
 
    expected_response = NULL;
    expected = ast_variable_new("Verify", "^Body$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    expected = ast_variable_new("Value", "^a body$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    AST_VECTOR_REPLACE(&expected_user_event_fields, 2, expected_response);
 
    ast_msg_set_to(msg, "foo");
    ast_msg_set_from(msg, "bar");
    ast_msg_set_body(msg, "a body");
 
    ast_msg_set_context(msg, TEST_CONTEXT);
    ast_msg_set_exten(msg, TEST_EXTENSION);
 
    ast_msg_queue(msg);
    msg = NULL;
 
    if (user_event_wait_for_events(test, DEFAULT_EXPECTED_EVENTS)) {
        ast_test_status_update(test, "Failed to received %d expected user events\n", DEFAULT_EXPECTED_EVENTS);
        ast_test_set_result(test, AST_TEST_FAIL);
    }
 
    /* This will automatically fail the test if we don't get the message */
    handler_wait_for_message(test);
 
    result = ast_msg_handler_unregister(&test_msg_handler);
    ast_test_validate(test, result == 0);
 
    if (verify_bad_headers(test)) {
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ast_msg_alloc(), ast_msg_handler_register(), ast_msg_handler_unregister(), ast_msg_queue(), ast_msg_safe_destroy(), ast_msg_set_body(), ast_msg_set_context(), ast_msg_set_exten(), ast_msg_set_from(), ast_msg_set_to(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_variable_list_append, ast_variable_new, AST_VECTOR_REPLACE, DEFAULT_EXPECTED_EVENTS, expected_user_event_fields, handler_wait_for_message(), NULL, RAII_VAR, result, TEST_CATEGORY, TEST_CONTEXT, TEST_EXECUTE, TEST_EXTENSION, TEST_INIT, test_msg_handler, user_event_wait_for_events(), and verify_bad_headers().

◆ AST_TEST_DEFINE() [8/9]

AST_TEST_DEFINE ( test_message_queue_dialplan_nominal )

Definition at line 465 of file test_message.c.

{
    RAII_VAR(struct ast_msg *, msg, NULL, ast_msg_safe_destroy);
    struct ast_variable *expected;
    struct ast_variable *expected_response = NULL;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test enqueueing messages to the dialplan";
        info->description =
            "Test that a message enqueued for the dialplan is\n"
            "passed to that particular extension";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    msg = ast_msg_alloc();
    ast_test_validate(test, msg != NULL);
 
    expected = ast_variable_new("Verify","^To$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    expected = ast_variable_new("Value","^foo$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    AST_VECTOR_REPLACE(&expected_user_event_fields, 0, expected_response);
 
    expected_response = NULL;
    expected = ast_variable_new("Verify", "^From$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    expected = ast_variable_new("Value","^bar$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    AST_VECTOR_REPLACE(&expected_user_event_fields, 1, expected_response);
 
    expected_response = NULL;
    expected = ast_variable_new("Verify", "^Body$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    expected = ast_variable_new("Value", "^a body$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    AST_VECTOR_REPLACE(&expected_user_event_fields, 2, expected_response);
 
    expected_response = NULL;
    expected = ast_variable_new("Verify", "^Custom$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    expected = ast_variable_new("Value", "^field$", __FILE__);
    ast_variable_list_append(&expected_response, expected);
    AST_VECTOR_REPLACE(&expected_user_event_fields, 3, expected_response);
 
    ast_msg_set_to(msg, "foo");
    ast_msg_set_from(msg, "bar");
    ast_msg_set_body(msg, "a body");
    ast_msg_set_var_outbound(msg, "custom_data", "field");
 
    ast_msg_set_context(msg, TEST_CONTEXT);
    ast_msg_set_exten(msg, TEST_EXTENSION);
 
    ast_msg_queue(msg);
    msg = NULL;
 
    if (user_event_wait_for_events(test, DEFAULT_EXPECTED_EVENTS)) {
        ast_test_status_update(test, "Failed to received %d expected user events\n", DEFAULT_EXPECTED_EVENTS);
        return AST_TEST_FAIL;
    }
 
    if (verify_bad_headers(test)) {
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ast_msg_alloc(), ast_msg_queue(), ast_msg_safe_destroy(), ast_msg_set_body(), ast_msg_set_context(), ast_msg_set_exten(), ast_msg_set_from(), ast_msg_set_to(), ast_msg_set_var_outbound(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_variable_list_append, ast_variable_new, AST_VECTOR_REPLACE, DEFAULT_EXPECTED_EVENTS, expected_user_event_fields, NULL, RAII_VAR, TEST_CATEGORY, TEST_CONTEXT, TEST_EXECUTE, TEST_EXTENSION, TEST_INIT, user_event_wait_for_events(), and verify_bad_headers().

◆ AST_TEST_DEFINE() [9/9]

AST_TEST_DEFINE ( test_message_queue_handler_nominal )

Definition at line 537 of file test_message.c.

{
    RAII_VAR(struct ast_msg *, msg, NULL, ast_msg_safe_destroy);
    int result;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test enqueueing messages to a handler";
        info->description =
            "Test that a message enqueued can be handled by a\n"
            "non-dialplan handler";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    msg = ast_msg_alloc();
    ast_test_validate(test, msg != NULL);
 
    result = ast_msg_handler_register(&test_msg_handler);
    ast_test_validate(test, result == 0);
 
    ast_msg_set_to(msg, "foo");
    ast_msg_set_from(msg, "bar");
    ast_msg_set_body(msg, "a body");
 
    ast_msg_queue(msg);
    msg = NULL;
 
    /* This will automatically fail the test if we don't get the message */
    handler_wait_for_message(test);
 
    result = ast_msg_handler_unregister(&test_msg_handler);
    ast_test_validate(test, result == 0);
 
    return AST_TEST_PASS;
}

References ast_msg_alloc(), ast_msg_handler_register(), ast_msg_handler_unregister(), ast_msg_queue(), ast_msg_safe_destroy(), ast_msg_set_body(), ast_msg_set_from(), ast_msg_set_to(), AST_TEST_NOT_RUN, AST_TEST_PASS, handler_wait_for_message(), NULL, RAII_VAR, result, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, and test_msg_handler.

◆ create_test_dialplan()

static int create_test_dialplan ( void )

static

Definition at line 828 of file test_message.c.

{
    int res = 0;
 
    if (!ast_context_find_or_create(NULL, NULL, TEST_CONTEXT, AST_MODULE)) {
        return -1;
    }
 
    res |= ast_add_extension(TEST_CONTEXT, 0, TEST_EXTENSION, 1, NULL, NULL,
                             "UserEvent", "TestMessageUnitTest,Verify:To,Value:${MESSAGE(to)}",
                             NULL, AST_MODULE);
    res |= ast_add_extension(TEST_CONTEXT, 0, TEST_EXTENSION, 2, NULL, NULL,
                             "UserEvent", "TestMessageUnitTest,Verify:From,Value:${MESSAGE(from)}",
                             NULL, AST_MODULE);
    res |= ast_add_extension(TEST_CONTEXT, 0, TEST_EXTENSION, 3, NULL, NULL,
                             "UserEvent", "TestMessageUnitTest,Verify:Body,Value:${MESSAGE(body)}",
                             NULL, AST_MODULE);
    res |= ast_add_extension(TEST_CONTEXT, 0, TEST_EXTENSION, 4, NULL, NULL,
                             "UserEvent", "TestMessageUnitTest,Verify:Custom,Value:${MESSAGE_DATA(custom_data)}",
                             NULL, AST_MODULE);
    res |= ast_add_extension(TEST_CONTEXT, 0, TEST_EXTENSION, 5, NULL, NULL,
                             "Set", "MESSAGE_DATA(custom_data)=${MESSAGE_DATA(custom_data)}",
                             NULL, AST_MODULE);
    res |= ast_add_extension(TEST_CONTEXT, 0, TEST_EXTENSION, 6, NULL, NULL,
                             "MessageSend", "testmsg:${MESSAGE(from)},testmsg:${MESSAGE(to)}",
                             NULL, AST_MODULE);
 
    ast_manager_register_hook(&user_event_hook);
 
    return res;
}

References ast_add_extension(), ast_context_find_or_create(), ast_manager_register_hook(), AST_MODULE, NULL, TEST_CONTEXT, TEST_EXTENSION, and user_event_hook.

Referenced by load_module().

◆ handler_wait_for_message()

static int handler_wait_for_message ( struct ast_test * test )

static

Wait for the test_msg_handler to receive the message.

Definition at line 230 of file test_message.c.

{
    int error = 0;
    struct timeval wait = ast_tvadd(ast_tvnow(), ast_tv(5 /* seconds */, 0));
    struct timespec wait_time = { .tv_sec = wait.tv_sec, .tv_nsec = wait.tv_usec * 1000 };
 
    ast_mutex_lock(&handler_lock);
    while (!handler_received_message) {
        error = ast_cond_timedwait(&handler_cond, &handler_lock, &wait_time);
        if (error == ETIMEDOUT) {
            ast_test_status_update(test, "Test timed out while waiting for handler to get message\n");
            ast_test_set_result(test, AST_TEST_FAIL);
            break;
        }
    }
    ast_mutex_unlock(&handler_lock);
 
    return (error != ETIMEDOUT);
}

References ast_cond_timedwait, ast_mutex_lock, ast_mutex_unlock, AST_TEST_FAIL, ast_test_status_update, ast_tv(), ast_tvadd(), ast_tvnow(), error(), handler_cond, handler_lock, and handler_received_message.

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

◆ load_module()

static int load_module ( void )

static

Definition at line 860 of file test_message.c.

{
    AST_TEST_REGISTER(test_message_msg_tech_registration);
    AST_TEST_REGISTER(test_message_msg_handler_registration);
    AST_TEST_REGISTER(test_message_manipulation);
    AST_TEST_REGISTER(test_message_queue_dialplan_nominal);
    AST_TEST_REGISTER(test_message_queue_handler_nominal);
    AST_TEST_REGISTER(test_message_queue_both_nominal);
    AST_TEST_REGISTER(test_message_has_destination_dialplan);
    AST_TEST_REGISTER(test_message_has_destination_handler);
    AST_TEST_REGISTER(test_message_msg_send);
 
    create_test_dialplan();
 
    ast_test_register_init(TEST_CATEGORY, test_init_cb);
    ast_test_register_cleanup(TEST_CATEGORY, test_cleanup_cb);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS, AST_TEST_REGISTER, create_test_dialplan(), TEST_CATEGORY, test_cleanup_cb(), and test_init_cb().

◆ test_cleanup_cb()

static int test_cleanup_cb	(	struct ast_test_info *	info,
		struct ast_test *	test
	)

static

Definition at line 801 of file test_message.c.

{
    FREE_VARIABLE_VECTOR(expected_user_event_fields);
    FREE_VARIABLE_VECTOR(bad_headers);
 
    return 0;
}

References bad_headers, expected_user_event_fields, and FREE_VARIABLE_VECTOR.

Referenced by load_module().

◆ test_init_cb()

static int test_init_cb	(	struct ast_test_info *	info,
		struct ast_test *	test
	)

static

Definition at line 775 of file test_message.c.

{
    received_user_events = 0;
    handler_received_message = 0;
    message_received = 0;
 
    AST_VECTOR_INIT(&expected_user_event_fields, DEFAULT_EXPECTED_EVENTS);
    AST_VECTOR_INIT(&bad_headers, DEFAULT_EXPECTED_EVENTS);
 
    return 0;
}

References AST_VECTOR_INIT, bad_headers, DEFAULT_EXPECTED_EVENTS, expected_user_event_fields, handler_received_message, message_received, and received_user_events.

Referenced by load_module().

◆ test_msg_handle_msg_cb()

static int test_msg_handle_msg_cb ( struct ast_msg * msg )

static

Definition at line 177 of file test_message.c.

{
    ast_mutex_lock(&handler_lock);
    handler_received_message = 1;
    ast_cond_signal(&handler_cond);
    ast_mutex_unlock(&handler_lock);
 
    return 0;
}

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, handler_cond, handler_lock, and handler_received_message.

◆ test_msg_has_destination_cb()

static int test_msg_has_destination_cb ( const struct ast_msg * msg )

static

Definition at line 187 of file test_message.c.

{
    /* We only care about one destination: foo! */
    if (ast_strlen_zero(ast_msg_get_to(msg))) {
        return 0;
    }
    return (!strcmp(ast_msg_get_to(msg), "foo") ? 1 : 0);
}

References ast_msg_get_to(), and ast_strlen_zero().

◆ test_msg_send()

static int test_msg_send	(	const struct ast_msg *	msg,
		const char *	to,
		const char *	from
	)

static

Definition at line 170 of file test_message.c.

{
    message_received = 1;
 
    return 0;
}

References message_received.

◆ unload_module()

static int unload_module ( void )

static

Definition at line 809 of file test_message.c.

{
    AST_TEST_UNREGISTER(test_message_msg_tech_registration);
    AST_TEST_UNREGISTER(test_message_msg_handler_registration);
    AST_TEST_UNREGISTER(test_message_manipulation);
    AST_TEST_UNREGISTER(test_message_queue_dialplan_nominal);
    AST_TEST_UNREGISTER(test_message_queue_handler_nominal);
    AST_TEST_UNREGISTER(test_message_queue_both_nominal);
    AST_TEST_UNREGISTER(test_message_has_destination_dialplan);
    AST_TEST_UNREGISTER(test_message_has_destination_handler);
    AST_TEST_UNREGISTER(test_message_msg_send);
 
    ast_context_destroy(NULL, AST_MODULE);
 
    ast_manager_unregister_hook(&user_event_hook);
 
    return 0;
}

References ast_context_destroy(), ast_manager_unregister_hook(), AST_MODULE, AST_TEST_UNREGISTER, NULL, and user_event_hook.

◆ user_event_hook_cb()

static int user_event_hook_cb	(	int	category,
		const char *	event,
		char *	body
	)

static

Definition at line 196 of file test_message.c.

{
    char *parse;
    char *kvp;
 
    if (strcmp(event, "UserEvent")) {
        return -1;
    }
 
    parse = ast_strdupa(body);
    while ((kvp = strsep(&parse, "\r\n"))) {
        char *key, *value;
 
        kvp = ast_trim_blanks(kvp);
        if (ast_strlen_zero(kvp)) {
            continue;
        }
        key = strsep(&kvp, ":");
        value = ast_skip_blanks(kvp);
        verify_user_event_fields(received_user_events, key, value);
    }
 
    received_user_events++;
 
    ast_mutex_lock(&user_event_lock);
    if (received_user_events == expected_user_events) {
        ast_cond_signal(&user_event_cond);
    }
    ast_mutex_unlock(&user_event_lock);
 
    return 0;
}

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_skip_blanks(), ast_strdupa, ast_strlen_zero(), ast_trim_blanks(), expected_user_events, received_user_events, strsep(), user_event_cond, user_event_lock, value, and verify_user_event_fields().

◆ user_event_wait_for_events()

static int user_event_wait_for_events	(	struct ast_test *	test,
		int	expected_events
	)

static

Wait for the expected number of user events to be received.

Definition at line 251 of file test_message.c.

{
    int error;
    struct timeval wait = ast_tvadd(ast_tvnow(), ast_tv(5 /* seconds */, 0));
    struct timespec wait_time = { .tv_sec = wait.tv_sec, .tv_nsec = wait.tv_usec * 1000 };
 
    expected_user_events = expected_events;
 
    ast_mutex_lock(&user_event_lock);
    while (received_user_events != expected_user_events) {
        error = ast_cond_timedwait(&user_event_cond, &user_event_lock, &wait_time);
        if (error == ETIMEDOUT) {
            ast_test_status_update(test, "Test timed out while waiting for %d expected user events\n", expected_events);
            ast_test_set_result(test, AST_TEST_FAIL);
            break;
        }
    }
    ast_mutex_unlock(&user_event_lock);
 
    ast_test_status_update(test, "Received %d of %d user events\n", received_user_events, expected_events);
    return !(received_user_events == expected_events);
}

References ast_cond_timedwait, ast_mutex_lock, ast_mutex_unlock, AST_TEST_FAIL, ast_test_status_update, ast_tv(), ast_tvadd(), ast_tvnow(), error(), expected_user_events, received_user_events, user_event_cond, and user_event_lock.

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

◆ verify_bad_headers()

static int verify_bad_headers ( struct ast_test * test )

static

Definition at line 274 of file test_message.c.

{
    int res = 0;
    int i;
 
    for (i = 0; i < AST_VECTOR_SIZE(&bad_headers); i++) {
        struct ast_variable *headers;
        struct ast_variable *current;
 
        headers = AST_VECTOR_GET(&bad_headers, i);
        if (!headers) {
            continue;
        }
 
        res = -1;
        for (current = headers; current; current = current->next) {
            ast_test_status_update(test, "Expected UserEvent %d: Failed to match %s: %s\n",
                i, current->name, current->value);
            ast_test_set_result(test, AST_TEST_FAIL);
        }
    }
 
    return res;
}

References AST_TEST_FAIL, ast_test_status_update, AST_VECTOR_GET, AST_VECTOR_SIZE, bad_headers, current, test::name, and ast_variable::next.

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

◆ verify_user_event_fields()

static int verify_user_event_fields	(	int	user_event,
		const char *	header,
		const char *	value
	)

static

Verifies a user event header/value pair.

Parameters

user_event	which user event to check
header	The header to verify
value	The value read from the event

Return values

-1	on error or evaluation failure
0	if match not needed or success

Definition at line 114 of file test_message.c.

{
    struct ast_variable *current;
    struct ast_variable *expected;
    regex_t regexbuf;
    int error;
 
    if (user_event >= AST_VECTOR_SIZE(&expected_user_event_fields)) {
        return -1;
    }
 
    expected = AST_VECTOR_GET(&expected_user_event_fields, user_event);
    if (!expected) {
        return -1;
    }
 
    for (current = expected; current; current = current->next) {
        struct ast_variable *bad_header;
 
        if (strcmp(current->name, header)) {
            continue;
        }
 
        error = regcomp(&regexbuf, current->value, REG_EXTENDED | REG_NOSUB);
        if (error) {
            char error_buf[128];
            regerror(error, &regexbuf, error_buf, sizeof(error_buf));
            ast_log(LOG_ERROR, "Failed to compile regex '%s' for header check '%s': %s\n",
                current->value, current->name, error_buf);
            return -1;
        }
 
        if (!regexec(&regexbuf, value, 0, NULL, 0)) {
            regfree(&regexbuf);
            return 0;
        }
 
        bad_header = ast_variable_new(header, value, __FILE__);
        if (bad_header) {
            struct ast_variable *bad_headers_head = NULL;
 
            if (user_event < AST_VECTOR_SIZE(&bad_headers)) {
                bad_headers_head = AST_VECTOR_GET(&bad_headers, user_event);
            }
            ast_variable_list_append(&bad_headers_head, bad_header);
            AST_VECTOR_REPLACE(&bad_headers, user_event, bad_headers_head);
        }
        regfree(&regexbuf);
        return -1;
    }
 
    return 0;
}

References ast_log, ast_variable_list_append, ast_variable_new, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, bad_headers, current, error(), expected_user_event_fields, LOG_ERROR, ast_variable::next, NULL, and value.

Referenced by user_event_hook_cb().

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Out-of-call text message support" , .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 881 of file test_message.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 881 of file test_message.c.

◆ [struct]

struct { ... } bad_headers

If a user event fails, the bad headers that didn't match.

Referenced by test_cleanup_cb(), test_init_cb(), verify_bad_headers(), and verify_user_event_fields().

◆ current

size_t current

Definition at line 77 of file test_message.c.

Referenced by verify_bad_headers(), and verify_user_event_fields().

◆ elems

struct ast_variable* * elems

Definition at line 77 of file test_message.c.

◆ expected_user_event_fields

struct var_vector expected_user_event_fields

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), test_cleanup_cb(), test_init_cb(), and verify_user_event_fields().

◆ expected_user_events

int expected_user_events

static

The number of user events we expect for this test.

Definition at line 56 of file test_message.c.

Referenced by user_event_hook_cb(), and user_event_wait_for_events().

◆ handler_cond

ast_cond_t handler_cond

static

Condition wait variable for test_msg_handler receiving message.

Definition at line 68 of file test_message.c.

Referenced by handler_wait_for_message(), and test_msg_handle_msg_cb().

◆ handler_lock

ast_mutex_t handler_lock = AST_MUTEX_INIT_VALUE

static

Mutex for handler_cond.

Definition at line 71 of file test_message.c.

Referenced by handler_wait_for_message(), and test_msg_handle_msg_cb().

◆ handler_received_message

int handler_received_message

static

Predicate for the test_msg_handler receiving a message.

Definition at line 59 of file test_message.c.

Referenced by handler_wait_for_message(), test_init_cb(), and test_msg_handle_msg_cb().

◆ max

size_t max

Definition at line 77 of file test_message.c.

◆ message_received

int message_received

static

Definition at line 168 of file test_message.c.

Referenced by test_init_cb(), and test_msg_send().

◆ received_user_events

int received_user_events

static

The current number of received user events.

Definition at line 53 of file test_message.c.

Referenced by test_init_cb(), user_event_hook_cb(), and user_event_wait_for_events().

◆ test_msg_handler

struct ast_msg_handler test_msg_handler

static

Initial value:

= {
    .name = "testmsg",
    .handle_msg = test_msg_handle_msg_cb,
    .has_destination = test_msg_has_destination_cb,
}

Our test message handler.

Definition at line 90 of file test_message.c.

                                                 {
    .name = "testmsg",
    .handle_msg = test_msg_handle_msg_cb,
    .has_destination = test_msg_has_destination_cb,
};

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), and AST_TEST_DEFINE().

◆ test_msg_tech

struct ast_msg_tech test_msg_tech

static

Initial value:

= {
    .name = "testmsg",
    .msg_send = test_msg_send,
}

Definition at line 81 of file test_message.c.

                                           {
    .name = "testmsg",
    .msg_send = test_msg_send,
};

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

◆ user_event_cond

ast_cond_t user_event_cond

static

Condition wait variable for all dialplan user events being received.

Definition at line 62 of file test_message.c.

Referenced by user_event_hook_cb(), and user_event_wait_for_events().

◆ user_event_hook

struct manager_custom_hook user_event_hook

static

Initial value:

= {
    .file = AST_MODULE,
    .helper = user_event_hook_cb,
}

AMI event hook that verifies whether or not we've gotten our user events.

Definition at line 99 of file test_message.c.

                                                    {
    .file = AST_MODULE,
    .helper = user_event_hook_cb,
};

Referenced by create_test_dialplan(), and unload_module().

◆ user_event_lock

ast_mutex_t user_event_lock = AST_MUTEX_INIT_VALUE

static

Mutex for user_event_cond.

Definition at line 65 of file test_message.c.

Referenced by user_event_hook_cb(), and user_event_wait_for_events().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ DEFAULT_EXPECTED_EVENTS

◆ FREE_VARIABLE_VECTOR

◆ TEST_CATEGORY

◆ TEST_CONTEXT

◆ TEST_EXTENSION

Function Documentation

◆ __reg_module()

◆ __unreg_module()

◆ AST_MODULE_SELF_SYM()

◆ ast_msg_safe_destroy()

◆ AST_TEST_DEFINE() [1/9]

◆ AST_TEST_DEFINE() [2/9]

◆ AST_TEST_DEFINE() [3/9]

◆ AST_TEST_DEFINE() [4/9]

◆ AST_TEST_DEFINE() [5/9]

◆ AST_TEST_DEFINE() [6/9]

◆ AST_TEST_DEFINE() [7/9]

◆ AST_TEST_DEFINE() [8/9]

◆ AST_TEST_DEFINE() [9/9]

◆ create_test_dialplan()

◆ handler_wait_for_message()

◆ load_module()

◆ test_cleanup_cb()

◆ test_init_cb()

◆ test_msg_handle_msg_cb()

◆ test_msg_has_destination_cb()

◆ test_msg_send()

◆ unload_module()

◆ user_event_hook_cb()

◆ user_event_wait_for_events()

◆ verify_bad_headers()

◆ verify_user_event_fields()

Variable Documentation

◆ __mod_info

◆ ast_module_info

◆ [struct]

◆ current

◆ elems

◆ expected_user_event_fields

◆ expected_user_events

◆ handler_cond

◆ handler_lock

◆ handler_received_message

◆ max

◆ message_received

◆ received_user_events

◆ test_msg_handler

◆ test_msg_tech

◆ user_event_cond

◆ user_event_hook

◆ user_event_lock