test_devicestate.c File Reference

Device State Test Module. More...

#include "asterisk.h"
#include "asterisk/utils.h"
#include "asterisk/module.h"
#include "asterisk/test.h"
#include "asterisk/devicestate.h"
#include "asterisk/pbx.h"
#include "asterisk/stasis_message_router.h"
#include "asterisk/vector.h"

Include dependency graph for test_devicestate.c:

Go to the source code of this file.

Data Structures
struct	consumer

Macros
#define	DEVICE_STATE_CHANNEL_TYPE   "TestDeviceState"
#define	DEVSTATE_PROVIDER   "TestDevState"
#define	DEVSTATE_PROVIDER_LC   "testdevstate"
#define	DEVSTATE_PROVIDER_LEN   12
#define	UNIT_TEST_DEVICE_IDENTIFIER   "unit_test_device_identifier"

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (device2extenstate_test)
	AST_TEST_DEFINE (device_state_aggregation_test)
	AST_TEST_DEFINE (devstate_prov_add)
	AST_TEST_DEFINE (devstate_prov_del)
	AST_TEST_DEFINE (devstate_changed)
	AST_TEST_DEFINE (devstate_conversions)
	AST_TEST_DEFINE (devstate_channels)
static	AST_VECTOR (, enum ast_device_state) result_states
	The resulting device state updates caused by some function call. More...
static void	cache_cleanup (int unused)
static int	chan_test_devicestate_cb (const char *device_number)
static void	clear_result_states (void)
	Clear out all recorded device states in result_states. More...
static struct consumer *	consumer_create (void)
static void	consumer_dtor (void *obj)
static void	consumer_exec (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	consumer_finalize (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	consumer_reset (struct consumer *consumer)
static void	consumer_wait_for (struct consumer *consumer)
static void	device_state_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
	Stasis subscription callback for device state updates. More...
static enum ast_device_state	devstate_prov_cb (const char *data)
static int	load_module (void)
static int	remove_device_states_cb (void *obj, void *arg, int flags)
static void	safe_hangup (void *object)
static int	unload_module (void)
static int	wait_for_channel_callback (struct ast_test *test)
	Wait until the test channel driver's devicestate callback is called. More...
static int	wait_for_device_state_updates (struct ast_test *test, int expected_updates)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Device State Test" , .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	chan_callback_called
	Whether or not the channel device state callback was called. More...
static unsigned int	chan_idx
	Used to assign an increasing integer to channel name. More...
struct ast_channel_tech	chan_test_devicestate
static ast_cond_t	channel_cb_cond
	Condition wait variable for channel tech device state cb. More...
static ast_mutex_t	channel_cb_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	Mutext for channel_cb_cond. More...
static int	combined_results []
static enum ast_device_state	current_device_state
	The current device state for our device state provider. More...
static int	exten_results []
static ast_cond_t	update_cond
	Condition wait variable for device state updates. More...
static ast_mutex_t	update_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	Mutex for update_cond. More...

Detailed Description

Device State Test Module.

Author

David Vossel dvoss.nosp@m.el@d.nosp@m.igium.nosp@m..com

Definition in file test_devicestate.c.

Macro Definition Documentation

DEVICE_STATE_CHANNEL_TYPE

#define DEVICE_STATE_CHANNEL_TYPE   "TestDeviceState"

Definition at line 45 of file test_devicestate.c.

Referenced by AST_TEST_DEFINE().

DEVSTATE_PROVIDER

#define DEVSTATE_PROVIDER   "TestDevState"

Definition at line 47 of file test_devicestate.c.

Referenced by AST_TEST_DEFINE(), and device_state_cb().

DEVSTATE_PROVIDER_LC

#define DEVSTATE_PROVIDER_LC   "testdevstate"

Definition at line 49 of file test_devicestate.c.

Referenced by AST_TEST_DEFINE().

DEVSTATE_PROVIDER_LEN

#define DEVSTATE_PROVIDER_LEN   12

Definition at line 51 of file test_devicestate.c.

Referenced by device_state_cb().

UNIT_TEST_DEVICE_IDENTIFIER

#define UNIT_TEST_DEVICE_IDENTIFIER   "unit_test_device_identifier"

Definition at line 43 of file test_devicestate.c.

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

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 969 of file test_devicestate.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 969 of file test_devicestate.c.

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 969 of file test_devicestate.c.

AST_TEST_DEFINE() [1/7]

AST_TEST_DEFINE

(

device2extenstate_test

)

Definition at line 312 of file test_devicestate.c.

References ARRAY_LEN, AST_DEVICE_TOTAL, ast_devstate2str(), ast_devstate_aggregate_add(), ast_devstate_aggregate_init(), ast_devstate_aggregate_result(), ast_devstate_to_extenstate(), ast_extension_state2str(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, combined_results, exten, exten_results, sip_to_pjsip::info(), TEST_EXECUTE, and TEST_INIT.

{
   int res = AST_TEST_PASS;
   struct ast_devstate_aggregate agg;
   enum ast_device_state i, j, combined;
   enum ast_extension_states exten;
   int k = 0;

   switch (cmd) {
   case TEST_INIT:
      info->name = "device2extenstate_test";
      info->category = "/main/devicestate/";
      info->summary = "Tests combined devstate mapping and device to extension state mapping.";
      info->description =
         "Verifies device state aggregate results match the expected combined "
         "devstate.  Then verifies the combined devstate maps to the expected "
         "extension state.";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   if (ARRAY_LEN(exten_results) != (AST_DEVICE_TOTAL * AST_DEVICE_TOTAL)) {
      ast_test_status_update(test, "Result array is %d long when it should be %d. "
         "Something has changed, this test must be updated.\n",
         (int) ARRAY_LEN(exten_results), (AST_DEVICE_TOTAL * AST_DEVICE_TOTAL));
      return AST_TEST_FAIL;
   }

   if (ARRAY_LEN(combined_results) != ARRAY_LEN(exten_results)) {
      ast_test_status_update(test, "combined_results and exten_results arrays do not match in length.\n");
      return AST_TEST_FAIL;
   }

   for (i = 0; i < AST_DEVICE_TOTAL; i++) {
      for (j = 0; j < AST_DEVICE_TOTAL; j++) {
         ast_devstate_aggregate_init(&agg);
         ast_devstate_aggregate_add(&agg, i);
         ast_devstate_aggregate_add(&agg, j);
         combined = ast_devstate_aggregate_result(&agg);
         if (combined_results[k] != combined) {
            ast_test_status_update(test, "Expected combined dev state %s "
               "does not match %s at combined_result[%d].\n",
               ast_devstate2str(combined_results[k]),
               ast_devstate2str(combined), k);
            res = AST_TEST_FAIL;
         }

         exten = ast_devstate_to_extenstate(combined);

         if (exten_results[k] != exten) {
            ast_test_status_update(test, "Expected exten state %s "
               "does not match %s at exten_result[%d]\n",
               ast_extension_state2str(exten_results[k]),
               ast_extension_state2str(exten), k);
            res = AST_TEST_FAIL;
         }
         k++;
      }
   }

   return res;
}

AST_TEST_DEFINE() [2/7]

AST_TEST_DEFINE

(

device_state_aggregation_test

)

Definition at line 511 of file test_devicestate.c.

References consumer::aggregate_state, ao2_cleanup, ao2_ref, AST_DEVICE_INUSE, AST_DEVICE_NOT_INUSE, AST_DEVICE_RINGING, AST_DEVICE_RINGINUSE, ast_device_state_cache(), ast_device_state_message_type(), ast_device_state_topic_cached(), AST_DEVICE_TOTAL, AST_DEVSTATE_CACHABLE, ast_free, ast_malloc, ast_publish_device_state, ast_publish_device_state_full(), AST_TEST_NOT_RUN, AST_TEST_PASS, cache_cleanup(), consumer_create(), consumer_exec(), consumer_finalize(), consumer_reset(), consumer_wait_for(), consumer::event_count, sip_to_pjsip::info(), NULL, RAII_VAR, consumer::sig_on_non_aggregate_state, stasis_cache_get_by_eid(), stasis_cache_update_type(), stasis_message_data(), stasis_message_router_add(), stasis_message_router_create, stasis_message_router_unsubscribe(), stasis_subscription_change_type(), ast_device_state_message::state, consumer::state, TEST_EXECUTE, TEST_INIT, and UNIT_TEST_DEVICE_IDENTIFIER.

{
   RAII_VAR(struct consumer *, consumer, NULL, ao2_cleanup);
   RAII_VAR(struct stasis_message_router *, device_msg_router, NULL, stasis_message_router_unsubscribe);
   RAII_VAR(struct ast_eid *, foreign_eid, NULL, ast_free);
   RAII_VAR(int, cleanup_cache, 0, cache_cleanup);
   RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
   int res;
   struct ast_device_state_message *device_state;

   switch (cmd) {
   case TEST_INIT:
      info->name = "device_state_aggregation_test";
      info->category = "/main/devicestate/";
      info->summary = "Tests message routing and aggregation through the Stasis device state system.";
      info->description =
         "Verifies that the device state system passes "
         "messages appropriately, that the aggregator is "
         "working properly, that the aggregate results match "
         "the expected combined devstate, and that the cached "
         "aggregate devstate is correct.";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   foreign_eid = ast_malloc(sizeof(*foreign_eid));
   ast_test_validate(test, NULL != foreign_eid);
   memset(foreign_eid, 0xFF, sizeof(*foreign_eid));

   consumer = consumer_create();
   ast_test_validate(test, NULL != consumer);

   device_msg_router = stasis_message_router_create(ast_device_state_topic_cached());
   ast_test_validate(test, NULL != device_msg_router);

   ao2_ref(consumer, +1);
   res = stasis_message_router_add(device_msg_router, stasis_cache_update_type(), consumer_exec, consumer);
   ast_test_validate(test, !res);

   res = stasis_message_router_add(device_msg_router, stasis_subscription_change_type(), consumer_finalize, consumer);
   ast_test_validate(test, !res);

   /* push local state */
   ast_publish_device_state(UNIT_TEST_DEVICE_IDENTIFIER, AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE);

   /* Check cache aggregate state immediately */
   ao2_cleanup(msg);
   msg = stasis_cache_get_by_eid(ast_device_state_cache(), ast_device_state_message_type(), UNIT_TEST_DEVICE_IDENTIFIER, NULL);
   device_state = stasis_message_data(msg);
   ast_test_validate(test, AST_DEVICE_NOT_INUSE == device_state->state);

   consumer_wait_for(consumer);
   ast_test_validate(test, AST_DEVICE_NOT_INUSE == consumer->state);
   ast_test_validate(test, AST_DEVICE_NOT_INUSE == consumer->aggregate_state);
   ast_test_validate(test, 2 == consumer->event_count);
   consumer_reset(consumer);

   /* push remote state */
   /* this will not produce a new aggregate state message since the aggregate state does not change */
   consumer->sig_on_non_aggregate_state = 1;
   ast_publish_device_state_full(UNIT_TEST_DEVICE_IDENTIFIER, AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, foreign_eid);

   /* Check cache aggregate state immediately */
   ao2_cleanup(msg);
   msg = stasis_cache_get_by_eid(ast_device_state_cache(), ast_device_state_message_type(), UNIT_TEST_DEVICE_IDENTIFIER, NULL);
   device_state = stasis_message_data(msg);
   ast_test_validate(test, AST_DEVICE_NOT_INUSE == device_state->state);

   /* Check for expected events. */
   consumer_wait_for(consumer);
   ast_test_validate(test, AST_DEVICE_NOT_INUSE == consumer->state);
   ast_test_validate(test, AST_DEVICE_TOTAL == consumer->aggregate_state);
   ast_test_validate(test, 1 == consumer->event_count);
   consumer_reset(consumer);

   /* push remote state different from local state */
   ast_publish_device_state_full(UNIT_TEST_DEVICE_IDENTIFIER, AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, foreign_eid);

   /* Check cache aggregate state immediately */
   ao2_cleanup(msg);
   msg = stasis_cache_get_by_eid(ast_device_state_cache(), ast_device_state_message_type(), UNIT_TEST_DEVICE_IDENTIFIER, NULL);
   device_state = stasis_message_data(msg);
   ast_test_validate(test, AST_DEVICE_INUSE == device_state->state);

   /* Check for expected events. */
   consumer_wait_for(consumer);
   ast_test_validate(test, AST_DEVICE_INUSE == consumer->state);
   ast_test_validate(test, AST_DEVICE_INUSE == consumer->aggregate_state);
   ast_test_validate(test, 2 == consumer->event_count);
   consumer_reset(consumer);

   /* push local state that will cause aggregated state different from local non-aggregate state */
   ast_publish_device_state(UNIT_TEST_DEVICE_IDENTIFIER, AST_DEVICE_RINGING, AST_DEVSTATE_CACHABLE);

   /* Check cache aggregate state immediately */
   ao2_cleanup(msg);
   msg = stasis_cache_get_by_eid(ast_device_state_cache(), ast_device_state_message_type(), UNIT_TEST_DEVICE_IDENTIFIER, NULL);
   device_state = stasis_message_data(msg);
   ast_test_validate(test, AST_DEVICE_RINGINUSE == device_state->state);

   /* Check for expected events. */
   consumer_wait_for(consumer);
   ast_test_validate(test, AST_DEVICE_RINGING == consumer->state);
   ast_test_validate(test, AST_DEVICE_RINGINUSE == consumer->aggregate_state);
   ast_test_validate(test, 2 == consumer->event_count);
   consumer_reset(consumer);

   return AST_TEST_PASS;
}

AST_TEST_DEFINE() [3/7]

AST_TEST_DEFINE

(

devstate_prov_add

)

Definition at line 622 of file test_devicestate.c.

References ast_devstate_prov_add(), ast_devstate_prov_del(), AST_TEST_NOT_RUN, AST_TEST_PASS, devstate_prov_cb(), DEVSTATE_PROVIDER, sip_to_pjsip::info(), TEST_EXECUTE, and TEST_INIT.

{
   switch (cmd) {
   case TEST_INIT:
      info->name = __func__;
      info->category = "/main/devicestate/";
      info->summary = "Test adding a device state provider";
      info->description =
         "Test that a custom device state provider can be added, and that\n"
         "it cannot be added if already added.";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   ast_test_validate(test, ast_devstate_prov_add(DEVSTATE_PROVIDER, devstate_prov_cb) == 0);
   ast_test_validate(test, ast_devstate_prov_add(DEVSTATE_PROVIDER, devstate_prov_cb) != 0);
   ast_test_validate(test, ast_devstate_prov_del(DEVSTATE_PROVIDER) == 0);

   return AST_TEST_PASS;
}

AST_TEST_DEFINE() [4/7]

AST_TEST_DEFINE

(

devstate_prov_del

)

Definition at line 644 of file test_devicestate.c.

References ast_devstate_prov_add(), ast_devstate_prov_del(), AST_TEST_NOT_RUN, AST_TEST_PASS, devstate_prov_cb(), DEVSTATE_PROVIDER, sip_to_pjsip::info(), TEST_EXECUTE, and TEST_INIT.

{
   switch (cmd) {
   case TEST_INIT:
      info->name = __func__;
      info->category = "/main/devicestate/";
      info->summary = "Test removing a device state provider";
      info->description =
         "Test that a custom device state provider can be removed, and that\n"
         "it cannot be removed if already removed.";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   ast_test_validate(test, ast_devstate_prov_add(DEVSTATE_PROVIDER, devstate_prov_cb) == 0);
   ast_test_validate(test, ast_devstate_prov_del(DEVSTATE_PROVIDER) == 0);
   ast_test_validate(test, ast_devstate_prov_del(DEVSTATE_PROVIDER) != 0);

   return AST_TEST_PASS;
}

AST_TEST_DEFINE() [5/7]

AST_TEST_DEFINE

(

devstate_changed

)

Definition at line 666 of file test_devicestate.c.

References ao2_cleanup, AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_ONHOLD, AST_DEVICE_RINGING, AST_DEVICE_RINGINUSE, ast_device_state_topic_all(), AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, ast_devstate_changed_literal(), AST_DEVSTATE_NOT_CACHABLE, ast_devstate_prov_add(), ast_devstate_prov_del(), AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, AST_VECTOR_GET, AST_VECTOR_SIZE, clear_result_states(), current_device_state, device_state_cb(), devstate_prov_cb(), DEVSTATE_PROVIDER, DEVSTATE_PROVIDER_LC, sip_to_pjsip::info(), NULL, RAII_VAR, stasis_subscribe, stasis_unsubscribe_and_join(), sub, TEST_EXECUTE, TEST_INIT, and wait_for_device_state_updates().

{
   RAII_VAR(struct stasis_subscription *, sub, NULL, ao2_cleanup);
   int i;
   enum ast_device_state expected_results[] = {
      AST_DEVICE_NOT_INUSE,
      AST_DEVICE_INUSE,
      AST_DEVICE_BUSY,
      AST_DEVICE_INVALID,
      AST_DEVICE_UNAVAILABLE,
      AST_DEVICE_RINGING,
      AST_DEVICE_RINGINUSE,
      AST_DEVICE_ONHOLD,
   };

   switch (cmd) {
   case TEST_INIT:
      info->name = __func__;
      info->category = "/main/devicestate/";
      info->summary = "Test updates coming from a device state provider";
      info->description =
         "This unit test checks that a custom device state provider can\n"
         "have updates published for it. This includes both cacheable and\n"
         "non-cacheable events. In the case of non-cacheable events, the\n"
         "device state provider's callback function is queried for the\n"
         "device state when AST_DEVICE_UNKNOWN is published.";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   ast_test_validate(test, (sub = stasis_subscribe(ast_device_state_topic_all(), device_state_cb, NULL)) != NULL);

   clear_result_states();
   current_device_state = AST_DEVICE_BUSY;

   ast_test_validate(test, ast_devstate_prov_add(DEVSTATE_PROVIDER, devstate_prov_cb) == 0);

   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_NOT_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_INUSE, AST_DEVSTATE_NOT_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_BUSY, AST_DEVSTATE_NOT_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_INVALID, AST_DEVSTATE_NOT_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_NOT_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_RINGING, AST_DEVSTATE_NOT_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_RINGINUSE, AST_DEVSTATE_NOT_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_ONHOLD, AST_DEVSTATE_NOT_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);

   ast_test_validate(test, wait_for_device_state_updates(test, 8) == 0);

   for (i = 0; i < AST_VECTOR_SIZE(&result_states); i++) {
      ast_test_status_update(test, "Testing update %d: actual is %d; expected is %d\n",
         i,
         AST_VECTOR_GET(&result_states, i),
         expected_results[i]);
      ast_test_validate(test, AST_VECTOR_GET(&result_states, i) == expected_results[i]);
   }

   sub = stasis_unsubscribe_and_join(sub);
   clear_result_states();

   /*
    * Since an update of AST_DEVICE_UNKNOWN will cause a different thread to retrieve
    * the update from the custom device state provider, check it separately from the
    * updates above.
    */
   ast_test_validate(test, (sub = stasis_subscribe(ast_device_state_topic_all(), device_state_cb, NULL)) != NULL);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_UNKNOWN, AST_DEVSTATE_NOT_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, wait_for_device_state_updates(test, 1) == 0);

   ast_test_validate(test, AST_VECTOR_GET(&result_states, 0) == AST_DEVICE_BUSY);
   ast_test_validate(test, ast_device_state(DEVSTATE_PROVIDER ":foo") == AST_DEVICE_BUSY);
   ast_test_validate(test, ast_device_state(DEVSTATE_PROVIDER_LC ":foo") == AST_DEVICE_BUSY);

   sub = stasis_unsubscribe_and_join(sub);
   clear_result_states();

   ast_test_validate(test, (sub = stasis_subscribe(ast_device_state_topic_all(), device_state_cb, NULL)) != NULL);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_BUSY, AST_DEVSTATE_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_INVALID, AST_DEVSTATE_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_UNAVAILABLE, AST_DEVSTATE_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_RINGING, AST_DEVSTATE_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_RINGINUSE, AST_DEVSTATE_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);
   ast_test_validate(test, ast_devstate_changed_literal(AST_DEVICE_ONHOLD, AST_DEVSTATE_CACHABLE, DEVSTATE_PROVIDER ":foo") == 0);

   ast_test_validate(test, wait_for_device_state_updates(test, 8) == 0);
   for (i = 0; i < AST_VECTOR_SIZE(&result_states); i++) {
      ast_test_status_update(test, "Testing update %d: actual is %d; expected is %d\n",
         i,
         AST_VECTOR_GET(&result_states, i),
         expected_results[i]);
      ast_test_validate(test, AST_VECTOR_GET(&result_states, i) == expected_results[i]);
   }

   /*
    * Check the last value in the cache. Note that this should not hit
    * the value of current_device_state.
    */
   ast_test_validate(test, ast_device_state(DEVSTATE_PROVIDER ":foo") == AST_DEVICE_ONHOLD);
   /*
    * This will miss on the cache, as it is case sensitive. It should go
    * hit our device state callback however.
    */
   ast_test_validate(test, ast_device_state(DEVSTATE_PROVIDER_LC ":foo") == AST_DEVICE_BUSY);

   /* Generally, this test can't be run twice in a row, as you can't remove an
    * item from the cache. Hence, subsequent runs won't hit the device state provider,
    * and will merely return the cached value.
    *
    * To avoid annoying errors, set the last state to BUSY here.
    */
   ast_devstate_changed_literal(AST_DEVICE_BUSY, AST_DEVSTATE_CACHABLE, DEVSTATE_PROVIDER ":foo");

   ast_test_validate(test, ast_devstate_prov_del(DEVSTATE_PROVIDER) == 0);

   sub = stasis_unsubscribe_and_join(sub);
   clear_result_states();

   return AST_TEST_PASS;
}

AST_TEST_DEFINE() [6/7]

AST_TEST_DEFINE

(

devstate_conversions

)

Definition at line 788 of file test_devicestate.c.

References AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_ONHOLD, AST_DEVICE_RINGING, AST_DEVICE_RINGINUSE, AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, ast_devstate_str(), ast_devstate_val(), AST_STATE_BUSY, ast_state_chan2dev(), AST_STATE_DIALING, AST_STATE_DIALING_OFFHOOK, AST_STATE_DOWN, AST_STATE_OFFHOOK, AST_STATE_PRERING, AST_STATE_RESERVED, AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, AST_TEST_NOT_RUN, AST_TEST_PASS, sip_to_pjsip::info(), TEST_EXECUTE, and TEST_INIT.

{
   switch (cmd) {
   case TEST_INIT:
      info->name = __func__;
      info->category = "/main/devicestate/";
      info->summary = "Test ast_device_state conversions";
      info->description =
         "Test various transformations of ast_device_state values.";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   ast_test_validate(test, !strcmp(ast_devstate_str(AST_DEVICE_UNKNOWN), "UNKNOWN"));
   ast_test_validate(test, !strcmp(ast_devstate_str(AST_DEVICE_NOT_INUSE), "NOT_INUSE"));
   ast_test_validate(test, !strcmp(ast_devstate_str(AST_DEVICE_INUSE), "INUSE"));
   ast_test_validate(test, !strcmp(ast_devstate_str(AST_DEVICE_BUSY), "BUSY"));
   ast_test_validate(test, !strcmp(ast_devstate_str(AST_DEVICE_INVALID), "INVALID"));
   ast_test_validate(test, !strcmp(ast_devstate_str(AST_DEVICE_UNAVAILABLE), "UNAVAILABLE"));
   ast_test_validate(test, !strcmp(ast_devstate_str(AST_DEVICE_RINGING), "RINGING"));
   ast_test_validate(test, !strcmp(ast_devstate_str(AST_DEVICE_RINGINUSE), "RINGINUSE"));
   ast_test_validate(test, !strcmp(ast_devstate_str(AST_DEVICE_ONHOLD), "ONHOLD"));

   ast_test_validate(test, ast_devstate_val("UNKNOWN") == AST_DEVICE_UNKNOWN);
   ast_test_validate(test, ast_devstate_val("NOT_INUSE") == AST_DEVICE_NOT_INUSE);
   ast_test_validate(test, ast_devstate_val("INUSE") == AST_DEVICE_INUSE);
   ast_test_validate(test, ast_devstate_val("BUSY") == AST_DEVICE_BUSY);
   ast_test_validate(test, ast_devstate_val("INVALID") == AST_DEVICE_INVALID);
   ast_test_validate(test, ast_devstate_val("UNAVAILABLE") == AST_DEVICE_UNAVAILABLE);
   ast_test_validate(test, ast_devstate_val("RINGING") == AST_DEVICE_RINGING);
   ast_test_validate(test, ast_devstate_val("RINGINUSE") == AST_DEVICE_RINGINUSE);
   ast_test_validate(test, ast_devstate_val("ONHOLD") == AST_DEVICE_ONHOLD);
   ast_test_validate(test, ast_devstate_val("onhold") == AST_DEVICE_ONHOLD);
   ast_test_validate(test, ast_devstate_val("FOO") == AST_DEVICE_UNKNOWN);

   ast_test_validate(test, ast_state_chan2dev(AST_STATE_DOWN) == AST_DEVICE_NOT_INUSE);
   ast_test_validate(test, ast_state_chan2dev(AST_STATE_RESERVED) == AST_DEVICE_INUSE);
   ast_test_validate(test, ast_state_chan2dev(AST_STATE_OFFHOOK) == AST_DEVICE_INUSE);
   ast_test_validate(test, ast_state_chan2dev(AST_STATE_DIALING) == AST_DEVICE_INUSE);
   ast_test_validate(test, ast_state_chan2dev(AST_STATE_RING) == AST_DEVICE_INUSE);
   ast_test_validate(test, ast_state_chan2dev(AST_STATE_RINGING) == AST_DEVICE_RINGING);
   ast_test_validate(test, ast_state_chan2dev(AST_STATE_UP) == AST_DEVICE_INUSE);
   ast_test_validate(test, ast_state_chan2dev(AST_STATE_BUSY) == AST_DEVICE_BUSY);
   ast_test_validate(test, ast_state_chan2dev(AST_STATE_DIALING_OFFHOOK) == AST_DEVICE_INUSE);
   ast_test_validate(test, ast_state_chan2dev(AST_STATE_PRERING) == AST_DEVICE_RINGING);

   return AST_TEST_PASS;
}

AST_TEST_DEFINE() [7/7]

AST_TEST_DEFINE

(

devstate_channels

)

Definition at line 871 of file test_devicestate.c.

References ast_atomic_fetchadd_int(), ast_channel_alloc, AST_DEVICE_INUSE, AST_DEVICE_RINGING, AST_DEVICE_UNKNOWN, ast_parse_device_state(), ast_setstate(), AST_STATE_RINGING, AST_STATE_UP, AST_TEST_NOT_RUN, AST_TEST_PASS, chan_callback_called, chan_idx, DEVICE_STATE_CHANNEL_TYPE, sip_to_pjsip::info(), NULL, RAII_VAR, safe_hangup(), TEST_EXECUTE, TEST_INIT, and wait_for_channel_callback().

{
   RAII_VAR(struct ast_channel *, chan, NULL, safe_hangup);

   switch (cmd) {
   case TEST_INIT:
      info->name = __func__;
      info->category = "/main/devicestate/";
      info->summary = "Test deriving device state from a channel's state";
      info->description =
         "Test querying a channel's state to derive a device state.";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   chan_callback_called = 0;

   chan = ast_channel_alloc(0, AST_STATE_RINGING, "", "", "", "s", "default",
      NULL, NULL, 0, DEVICE_STATE_CHANNEL_TYPE "/foo-%08x",
      (unsigned) ast_atomic_fetchadd_int((int *) &chan_idx, +1));
   ast_test_validate(test, chan != NULL);

   ast_test_validate(test, ast_parse_device_state(DEVICE_STATE_CHANNEL_TYPE "/foo") == AST_DEVICE_RINGING);
   ast_test_validate(test, ast_parse_device_state(DEVICE_STATE_CHANNEL_TYPE "/bad") == AST_DEVICE_UNKNOWN);

   ast_setstate(chan, AST_STATE_UP);

   ast_test_validate(test, wait_for_channel_callback(test) == 1);
   ast_test_validate(test, ast_parse_device_state(DEVICE_STATE_CHANNEL_TYPE "/foo") == AST_DEVICE_INUSE);

   chan_callback_called = 0;

   return AST_TEST_PASS;
}

AST_VECTOR()

static AST_VECTOR ( enum  ast_device_state )

static

The resulting device state updates caused by some function call.

cache_cleanup()

static void cache_cleanup ( int  unused )

static

Definition at line 498 of file test_devicestate.c.

References ao2_callback, ao2_cleanup, ast_device_state_cache(), NULL, remove_device_states_cb(), and stasis_cache_dump_all().

Referenced by AST_TEST_DEFINE().

{
   struct ao2_container *cache_dump;

   /* remove all device states created during this test */
   cache_dump = stasis_cache_dump_all(ast_device_state_cache(), NULL);
   if (!cache_dump) {
      return;
   }
   ao2_callback(cache_dump, 0, remove_device_states_cb, NULL);
   ao2_cleanup(cache_dump);
}

chan_test_devicestate_cb()

static int chan_test_devicestate_cb ( const char *  device_number )

static

Definition at line 907 of file test_devicestate.c.

References ast_cond_signal, AST_DEVICE_INUSE, ast_mutex_lock, ast_mutex_unlock, chan_callback_called, channel_cb_cond, and channel_cb_lock.

{
   /* Simply record that we were called when expected */
   chan_callback_called = 1;

   ast_mutex_lock(&channel_cb_lock);
   ast_cond_signal(&channel_cb_cond);
   ast_mutex_unlock(&channel_cb_lock);

   return AST_DEVICE_INUSE;
}

clear_result_states()

static void clear_result_states ( void  )

static

Clear out all recorded device states in result_states.

Definition at line 244 of file test_devicestate.c.

References ast_mutex_lock, ast_mutex_unlock, AST_VECTOR_REMOVE_UNORDERED, AST_VECTOR_SIZE, and update_lock.

Referenced by AST_TEST_DEFINE().

{
   ast_mutex_lock(&update_lock);
   while (AST_VECTOR_SIZE(&result_states) > 0) {
      AST_VECTOR_REMOVE_UNORDERED(&result_states, 0);
   }
   ast_mutex_unlock(&update_lock);
}

consumer_create()

static struct consumer* consumer_create ( void  )

static

Definition at line 400 of file test_devicestate.c.

References ao2_alloc, ast_cond_init, consumer_dtor(), consumer_reset(), NULL, and consumer::out.

Referenced by AST_TEST_DEFINE().

{
   struct consumer *consumer;

   consumer = ao2_alloc(sizeof(*consumer), consumer_dtor);
   if (!consumer) {
      return NULL;
   }

   ast_cond_init(&consumer->out, NULL);
   consumer_reset(consumer);

   return consumer;
}

consumer_dtor()

static void consumer_dtor ( void *  obj )

static

Definition at line 385 of file test_devicestate.c.

References ast_cond_destroy, and consumer::out.

Referenced by consumer_create().

{
   struct consumer *consumer = obj;

   ast_cond_destroy(&consumer->out);
}

consumer_exec()

static void consumer_exec ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 415 of file test_devicestate.c.

References consumer::aggregate_state, consumer::already_out, ast_cond_signal, cache_update(), ast_device_state_message::device, ast_device_state_message::eid, consumer::event_count, lock, stasis_cache_update::new_snapshot, consumer::out, SCOPED_AO2LOCK, consumer::sig_on_non_aggregate_state, stasis_message_data(), ast_device_state_message::state, consumer::state, and UNIT_TEST_DEVICE_IDENTIFIER.

Referenced by AST_TEST_DEFINE().

{
   struct consumer *consumer = data;
   struct stasis_cache_update *cache_update = stasis_message_data(message);
   struct ast_device_state_message *device_state;

   if (!cache_update->new_snapshot) {
      return;
   }

   device_state = stasis_message_data(cache_update->new_snapshot);

   if (strcmp(device_state->device, UNIT_TEST_DEVICE_IDENTIFIER)) {
      /* not a device state we're interested in */
      return;
   }

   {
      SCOPED_AO2LOCK(lock, consumer);

      ++consumer->event_count;
      if (device_state->eid) {
         consumer->state = device_state->state;
         if (consumer->sig_on_non_aggregate_state) {
            consumer->sig_on_non_aggregate_state = 0;
            consumer->already_out = 1;
            ast_cond_signal(&consumer->out);
         }
      } else {
         consumer->aggregate_state = device_state->state;
         consumer->already_out = 1;
         ast_cond_signal(&consumer->out);
      }
   }
}

consumer_finalize()

static void consumer_finalize ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 451 of file test_devicestate.c.

References ao2_cleanup, and stasis_subscription_final_message().

Referenced by AST_TEST_DEFINE().

{
   struct consumer *consumer = data;

   if (stasis_subscription_final_message(sub, message)) {
      ao2_cleanup(consumer);
   }
}

consumer_reset()

static void consumer_reset ( struct consumer *  consumer )

static

Definition at line 392 of file test_devicestate.c.

References consumer::aggregate_state, consumer::already_out, AST_DEVICE_TOTAL, consumer::event_count, and consumer::state.

Referenced by AST_TEST_DEFINE(), and consumer_create().

{
   consumer->already_out = 0;
   consumer->event_count = 0;
   consumer->state = AST_DEVICE_TOTAL;
   consumer->aggregate_state = AST_DEVICE_TOTAL;
}

consumer_wait_for()

static void consumer_wait_for ( struct consumer *  consumer )

static

Definition at line 460 of file test_devicestate.c.

References consumer::already_out, ao2_object_get_lockaddr(), ast_cond_timedwait, ast_tvnow(), lock, consumer::out, and SCOPED_AO2LOCK.

Referenced by AST_TEST_DEFINE().

{
   int res;
   struct timeval start = ast_tvnow();
   struct timespec end = {
      .tv_sec = start.tv_sec + 10,
      .tv_nsec = start.tv_usec * 1000
   };

   SCOPED_AO2LOCK(lock, consumer);

   while (!consumer->already_out) {
      res = ast_cond_timedwait(&consumer->out, ao2_object_get_lockaddr(consumer), &end);
      if (!res || res == ETIMEDOUT) {
         break;
      }
   }
}

device_state_cb()

static void device_state_cb ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Stasis subscription callback for device state updates.

Definition at line 254 of file test_devicestate.c.

References ast_cond_signal, ast_device_state_message_type(), ast_mutex_lock, ast_mutex_unlock, ast_strlen_zero, AST_VECTOR_APPEND, ast_device_state_message::device, DEVSTATE_PROVIDER, DEVSTATE_PROVIDER_LEN, ast_device_state_message::eid, stasis_message_data(), stasis_message_type(), ast_device_state_message::state, state, update_cond, and update_lock.

Referenced by AST_TEST_DEFINE().

{
   struct ast_device_state_message *payload;
   enum ast_device_state state;
   const char *device;

   if (stasis_message_type(message) != ast_device_state_message_type()) {
      return;
   }

   payload = stasis_message_data(message);
   state = payload->state;
   device = payload->device;

   if (ast_strlen_zero(device)) {
      return;
   }

   /* Ignore aggregate events */
   if (!payload->eid) {
      return;
   }

   if (strncasecmp(device, DEVSTATE_PROVIDER, DEVSTATE_PROVIDER_LEN)) {
      return;
   }

   ast_mutex_lock(&update_lock);
   AST_VECTOR_APPEND(&result_states, state);
   ast_cond_signal(&update_cond);
   ast_mutex_unlock(&update_lock);
}

devstate_prov_cb()

static enum ast_device_state devstate_prov_cb ( const char *  data )

static

Definition at line 287 of file test_devicestate.c.

References current_device_state.

Referenced by AST_TEST_DEFINE().

{
   return current_device_state;
}

load_module()

static int load_module ( void  )

static

Definition at line 944 of file test_devicestate.c.

References ast_channel_register(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, AST_TEST_REGISTER, AST_VECTOR_FREE, and AST_VECTOR_INIT.

{
   if (AST_VECTOR_INIT(&result_states, 8) == -1) {
      return AST_MODULE_LOAD_DECLINE;
   }

   if (ast_channel_register(&chan_test_devicestate)) {
      AST_VECTOR_FREE(&result_states);
      return AST_MODULE_LOAD_DECLINE;
   }

   AST_TEST_REGISTER(device_state_aggregation_test);
   AST_TEST_REGISTER(device2extenstate_test);

   AST_TEST_REGISTER(devstate_prov_add);
   AST_TEST_REGISTER(devstate_prov_del);

   AST_TEST_REGISTER(devstate_changed);
   AST_TEST_REGISTER(devstate_conversions);

   AST_TEST_REGISTER(devstate_channels);

   return AST_MODULE_LOAD_SUCCESS;
}

remove_device_states_cb()

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

static

Definition at line 479 of file test_devicestate.c.

References ao2_cleanup, ast_device_state_topic(), ast_device_state_message::device, stasis_cache_clear_create(), stasis_message_data(), stasis_publish(), and UNIT_TEST_DEVICE_IDENTIFIER.

Referenced by cache_cleanup().

{
   struct stasis_message *msg = obj;
   struct ast_device_state_message *device_state = stasis_message_data(msg);

   if (strcmp(UNIT_TEST_DEVICE_IDENTIFIER, device_state->device)) {
      /* Not a unit test device */
      return 0;
   }

   msg = stasis_cache_clear_create(msg);
   if (msg) {
      /* topic guaranteed to have been created by this point */
      stasis_publish(ast_device_state_topic(device_state->device), msg);
   }
   ao2_cleanup(msg);
   return 0;
}

safe_hangup()

static void safe_hangup ( void *  object )

static

Definition at line 861 of file test_devicestate.c.

References ast_hangup().

Referenced by AST_TEST_DEFINE().

{
   struct ast_channel *chan = object;

   if (!chan) {
      return;
   }
   ast_hangup(chan);
}

unload_module()

static int unload_module ( void  )

static

Definition at line 925 of file test_devicestate.c.

References ast_channel_unregister(), AST_TEST_UNREGISTER, and AST_VECTOR_FREE.

{
   AST_VECTOR_FREE(&result_states);
   ast_channel_unregister(&chan_test_devicestate);

   AST_TEST_UNREGISTER(device2extenstate_test);
   AST_TEST_UNREGISTER(device_state_aggregation_test);

   AST_TEST_UNREGISTER(devstate_prov_add);
   AST_TEST_UNREGISTER(devstate_prov_del);

   AST_TEST_UNREGISTER(devstate_changed);
   AST_TEST_UNREGISTER(devstate_conversions);

   AST_TEST_UNREGISTER(devstate_channels);

   return 0;
}

wait_for_channel_callback()

static int wait_for_channel_callback ( struct ast_test *  test )

static

Wait until the test channel driver's devicestate callback is called.

Definition at line 842 of file test_devicestate.c.

References ast_cond_timedwait, ast_mutex_lock, ast_mutex_unlock, ast_test_status_update, ast_tvnow(), chan_callback_called, channel_cb_cond, channel_cb_lock, and error().

Referenced by AST_TEST_DEFINE().

{
   int error;
   struct timeval wait_now = ast_tvnow();
   struct timespec wait_time = { .tv_sec = wait_now.tv_sec + 1, .tv_nsec = wait_now.tv_usec * 1000 };

   ast_mutex_lock(&channel_cb_lock);
   while (!chan_callback_called) {
      error = ast_cond_timedwait(&channel_cb_cond, &channel_cb_lock, &wait_time);
      if (error == ETIMEDOUT) {
         ast_test_status_update(test, "Test timed out while waiting channel callback\n");
         break;
      }
   }
   ast_mutex_unlock(&channel_cb_lock);

   return chan_callback_called;
}

wait_for_device_state_updates()

static int wait_for_device_state_updates ( struct ast_test *  test, int  expected_updates  )

static

Definition at line 292 of file test_devicestate.c.

References ast_cond_timedwait, ast_mutex_lock, ast_mutex_unlock, ast_test_status_update, ast_tvnow(), AST_VECTOR_SIZE, error(), update_cond, and update_lock.

Referenced by AST_TEST_DEFINE().

{
   int error;
   struct timeval wait_now = ast_tvnow();
   struct timespec wait_time = { .tv_sec = wait_now.tv_sec + 1, .tv_nsec = wait_now.tv_usec * 1000 };

   ast_mutex_lock(&update_lock);
   while (AST_VECTOR_SIZE(&result_states) != expected_updates) {
      error = ast_cond_timedwait(&update_cond, &update_lock, &wait_time);
      if (error == ETIMEDOUT) {
         ast_test_status_update(test, "Test timed out while waiting for %d expected updates\n", expected_updates);
         break;
      }
   }
   ast_mutex_unlock(&update_lock);

   ast_test_status_update(test, "Received %zu of %d updates\n", AST_VECTOR_SIZE(&result_states), expected_updates);
   return !(AST_VECTOR_SIZE(&result_states) == expected_updates);
}

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Device State Test" , .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 969 of file test_devicestate.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 969 of file test_devicestate.c.

chan_callback_called

int chan_callback_called

static

Whether or not the channel device state callback was called.

Definition at line 839 of file test_devicestate.c.

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

chan_idx

unsigned int chan_idx

static

Used to assign an increasing integer to channel name.

Definition at line 54 of file test_devicestate.c.

Referenced by AST_TEST_DEFINE().

chan_test_devicestate

struct ast_channel_tech chan_test_devicestate

Initial value:

= {
   .type = DEVICE_STATE_CHANNEL_TYPE,
   .description = "Device State Unit Test Channel Driver",
   .devicestate = chan_test_devicestate_cb,
}

Definition at line 919 of file test_devicestate.c.

channel_cb_cond

ast_cond_t channel_cb_cond

static

Condition wait variable for channel tech device state cb.

Definition at line 235 of file test_devicestate.c.

Referenced by chan_test_devicestate_cb(), and wait_for_channel_callback().

channel_cb_lock

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

static

Mutext for channel_cb_cond.

Definition at line 232 of file test_devicestate.c.

Referenced by chan_test_devicestate_cb(), and wait_for_channel_callback().

combined_results

int combined_results[]

static

Definition at line 57 of file test_devicestate.c.

Referenced by AST_TEST_DEFINE().

current_device_state

enum ast_device_state current_device_state

static

The current device state for our device state provider.

Definition at line 241 of file test_devicestate.c.

Referenced by AST_TEST_DEFINE(), and devstate_prov_cb().

exten_results

int exten_results[]

static

Definition at line 141 of file test_devicestate.c.

Referenced by AST_TEST_DEFINE().

update_cond

ast_cond_t update_cond

static

Condition wait variable for device state updates.

Definition at line 229 of file test_devicestate.c.

Referenced by device_state_cb(), and wait_for_device_state_updates().

update_lock

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

static

Mutex for update_cond.

Definition at line 226 of file test_devicestate.c.

Referenced by clear_result_states(), device_state_cb(), and wait_for_device_state_updates().