test_message.c File Reference

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.

Macros
#define	DEFAULT_EXPECTED_EVENTS   4
	The number of user events we should get in a dialplan test. More...
#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_msg_tech_registration)
	AST_TEST_DEFINE (test_message_msg_handler_registration)
	AST_TEST_DEFINE (test_message_manipulation)
	AST_TEST_DEFINE (test_message_queue_dialplan_nominal)
	AST_TEST_DEFINE (test_message_queue_handler_nominal)
	AST_TEST_DEFINE (test_message_queue_both_nominal)
	AST_TEST_DEFINE (test_message_has_destination_dialplan)
	AST_TEST_DEFINE (test_message_has_destination_handler)
	AST_TEST_DEFINE (test_message_msg_send)
	AST_VECTOR (var_vector, struct ast_variable *)
	The expected user event fields. More...
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. More...
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. More...
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. More...

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Out-of-call text message support" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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
static int	expected_user_events
	The number of user events we expect for this test. More...
static ast_cond_t	handler_cond
	Condition wait variable for test_msg_handler receiving message. More...
static ast_mutex_t	handler_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	Mutex for handler_cond. More...
static int	handler_received_message
	Predicate for the test_message_handler receiving a message. More...
static int	message_received
static int	received_user_events
	The current number of received user events. More...
static struct ast_msg_handler	test_msg_handler
	Our test message handler. More...
static ast_cond_t	user_event_cond
	Condition wait variable for all dialplan user events being received. More...
static struct manager_custom_hook	user_event_hook
	AMI event hook that verifies whether or not we've gotten our user events. More...
static ast_mutex_t	user_event_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	Mutex for user_event_cond. More...

Detailed Description

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

Author

Matt Jordan <[email protected]> 

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.

Referenced by AST_TEST_DEFINE(), and test_init_cb().

FREE_VARIABLE_VECTOR

#define FREE_VARIABLE_VECTOR

(

vector

)

Definition at line 787 of file test_message.c.

Referenced by test_cleanup_cb().

TEST_CATEGORY

#define TEST_CATEGORY   "/main/message/"

Definition at line 44 of file test_message.c.

Referenced by AST_TEST_DEFINE(), and load_module().

TEST_CONTEXT

#define TEST_CONTEXT   "__TEST_MESSAGE_CONTEXT__"

Definition at line 46 of file test_message.c.

Referenced by AST_TEST_DEFINE(), and create_test_dialplan().

TEST_EXTENSION

#define TEST_EXTENSION   "test_message_extension"

Definition at line 47 of file test_message.c.

Referenced by AST_TEST_DEFINE(), and create_test_dialplan().

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.

References ast_msg_destroy().

Referenced by AST_TEST_DEFINE().

{
   struct ast_msg *msg = obj;

   if (msg) {
      ast_msg_destroy(msg);
   }
}

AST_TEST_DEFINE() [1/9]

AST_TEST_DEFINE

(

test_message_msg_tech_registration

)

Definition at line 299 of file test_message.c.

References ast_msg_tech_register(), ast_msg_tech_unregister(), AST_TEST_NOT_RUN, AST_TEST_PASS, sip_to_pjsip::info(), TEST_CATEGORY, TEST_EXECUTE, and TEST_INIT.

{
   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;
}

AST_TEST_DEFINE() [2/9]

AST_TEST_DEFINE

(

test_message_msg_handler_registration

)

Definition at line 332 of file test_message.c.

References ast_msg_handler_register(), ast_msg_handler_unregister(), AST_TEST_NOT_RUN, AST_TEST_PASS, sip_to_pjsip::info(), TEST_CATEGORY, TEST_EXECUTE, and TEST_INIT.

{
   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;
}

AST_TEST_DEFINE() [3/9]

AST_TEST_DEFINE

(

test_message_manipulation

)

Definition at line 374 of file test_message.c.

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, sip_to_pjsip::info(), NULL, RAII_VAR, result, TEST_CATEGORY, TEST_EXECUTE, and TEST_INIT.

{
   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;
}

AST_TEST_DEFINE() [4/9]

AST_TEST_DEFINE

(

test_message_queue_dialplan_nominal

)

Definition at line 465 of file test_message.c.

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, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_CATEGORY, TEST_CONTEXT, TEST_EXECUTE, TEST_EXTENSION, TEST_INIT, user_event_wait_for_events(), and verify_bad_headers().

{
   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;
}

AST_TEST_DEFINE() [5/9]

AST_TEST_DEFINE

(

test_message_queue_handler_nominal

)

Definition at line 537 of file test_message.c.

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(), sip_to_pjsip::info(), NULL, RAII_VAR, result, TEST_CATEGORY, TEST_EXECUTE, and TEST_INIT.

{
   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;
}

AST_TEST_DEFINE() [6/9]

AST_TEST_DEFINE

(

test_message_queue_both_nominal

)

Definition at line 577 of file test_message.c.

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_set_result(), ast_test_status_update, ast_variable_list_append, ast_variable_new, AST_VECTOR_REPLACE, DEFAULT_EXPECTED_EVENTS, handler_wait_for_message(), sip_to_pjsip::info(), NULL, RAII_VAR, result, TEST_CATEGORY, TEST_CONTEXT, TEST_EXECUTE, TEST_EXTENSION, TEST_INIT, user_event_wait_for_events(), and verify_bad_headers().

{
   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;
}

AST_TEST_DEFINE() [7/9]

AST_TEST_DEFINE

(

test_message_has_destination_dialplan

)

Definition at line 652 of file test_message.c.

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, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_CATEGORY, TEST_CONTEXT, TEST_EXECUTE, TEST_EXTENSION, and TEST_INIT.

{
   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, NULL);
   ast_test_validate(test, ast_msg_has_destination(msg) == 0);

   ast_msg_set_context(msg, NULL);
   ast_msg_set_exten(msg, TEST_EXTENSION);
   ast_test_validate(test, ast_msg_has_destination(msg) == 0);

   return AST_TEST_PASS;
}

AST_TEST_DEFINE() [8/9]

AST_TEST_DEFINE

(

test_message_has_destination_handler

)

Definition at line 693 of file test_message.c.

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, sip_to_pjsip::info(), NULL, RAII_VAR, result, TEST_CATEGORY, TEST_CONTEXT, TEST_EXECUTE, and TEST_INIT.

{
   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, NULL);
   ast_test_validate(test, ast_msg_has_destination(msg) == 1);

   ast_msg_set_context(msg, NULL);
   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;
}

AST_TEST_DEFINE() [9/9]

AST_TEST_DEFINE

(

test_message_msg_send

)

Definition at line 734 of file test_message.c.

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_set_result(), ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_CATEGORY, TEST_CONTEXT, TEST_EXECUTE, and TEST_INIT.

{
   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, NULL);
   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;
}

AST_VECTOR()

AST_VECTOR	(	var_vector	,
		struct ast_variable *
	)

The expected user event fields.

Definition at line 74 of file test_message.c.

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

create_test_dialplan()

static int create_test_dialplan ( void  )

static

Definition at line 828 of file test_message.c.

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

Referenced by load_module().

{
   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;
}

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.

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

Referenced by AST_TEST_DEFINE().

{
   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);
}

load_module()

static int load_module ( void  )

static

Definition at line 860 of file test_message.c.

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

{
   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;
}

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.

References FREE_VARIABLE_VECTOR.

Referenced by load_module().

{
   FREE_VARIABLE_VECTOR(expected_user_event_fields);
   FREE_VARIABLE_VECTOR(bad_headers);

   return 0;
}

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.

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

Referenced by load_module().

{
   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;
}

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.

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

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

   return 0;
}

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.

References ast_msg_get_to(), and ast_strlen_zero.

{
   /* 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);
}

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.

References message_received.

{
   message_received = 1;

   return 0;
}

unload_module()

static int unload_module ( void  )

static

Definition at line 809 of file test_message.c.

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

{
   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;
}

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.

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

{
   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;
}

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.

References ast_cond_timedwait, ast_mutex_lock, ast_mutex_unlock, AST_TEST_FAIL, ast_test_set_result(), 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().

{
   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);
}

verify_bad_headers()

static int verify_bad_headers ( struct ast_test *  test )

static

Definition at line 274 of file test_message.c.

References AST_TEST_FAIL, ast_test_set_result(), ast_test_status_update, AST_VECTOR_GET, AST_VECTOR_SIZE, ast_variable::name, ast_variable::next, and ast_variable::value.

Referenced by AST_TEST_DEFINE().

{
   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;
}

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.

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

Referenced by user_event_hook_cb().

{
   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;
}

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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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.

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 = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

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_message_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().

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.

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.

user_event_lock

ast_mutex_t user_event_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

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().