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_changed)
	AST_TEST_DEFINE (devstate_channels)
	AST_TEST_DEFINE (devstate_conversions)
	AST_TEST_DEFINE (devstate_prov_add)
	AST_TEST_DEFINE (devstate_prov_del)
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.
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.
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.
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 = 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
static int	chan_callback_called
	Whether or not the channel device state callback was called.
static unsigned int	chan_idx
	Used to assign an increasing integer to channel name.
struct ast_channel_tech	chan_test_devicestate
static ast_cond_t	channel_cb_cond
	Condition wait variable for channel tech device state cb.
static ast_mutex_t	channel_cb_lock = AST_MUTEX_INIT_VALUE
	Mutext for channel_cb_cond.
static int	combined_results []
static enum ast_device_state	current_device_state
	The current device state for our device state provider.
static int	exten_results []
struct {
size_t   current
enum ast_device_state *   elems
size_t   max
}	result_states
	The resulting device state updates caused by some function call.
static ast_cond_t	update_cond
	Condition wait variable for device state updates.
static ast_mutex_t	update_lock = AST_MUTEX_INIT_VALUE
	Mutex for update_cond.

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.

DEVSTATE_PROVIDER

#define DEVSTATE_PROVIDER   "TestDevState"

Definition at line 47 of file test_devicestate.c.

DEVSTATE_PROVIDER_LC

#define DEVSTATE_PROVIDER_LC   "testdevstate"

Definition at line 49 of file test_devicestate.c.

DEVSTATE_PROVIDER_LEN

#define DEVSTATE_PROVIDER_LEN   12

Definition at line 51 of file test_devicestate.c.

UNIT_TEST_DEVICE_IDENTIFIER

#define UNIT_TEST_DEVICE_IDENTIFIER   "unit_test_device_identifier"

Definition at line 43 of file test_devicestate.c.

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.

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

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_results, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [2/7]

AST_TEST_DEFINE

(

device_state_aggregation_test

)

Definition at line 511 of file test_devicestate.c.

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

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, 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.

AST_TEST_DEFINE() [3/7]

AST_TEST_DEFINE

(

devstate_changed

)

Definition at line 666 of file test_devicestate.c.

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

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, NULL, RAII_VAR, result_states, stasis_subscribe, stasis_unsubscribe_and_join(), sub, TEST_EXECUTE, TEST_INIT, and wait_for_device_state_updates().

AST_TEST_DEFINE() [4/7]

AST_TEST_DEFINE

(

devstate_channels

)

Definition at line 871 of file test_devicestate.c.

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

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, NULL, RAII_VAR, safe_hangup(), TEST_EXECUTE, TEST_INIT, and wait_for_channel_callback().

AST_TEST_DEFINE() [5/7]

AST_TEST_DEFINE

(

devstate_conversions

)

Definition at line 788 of file test_devicestate.c.

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

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, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [6/7]

AST_TEST_DEFINE

(

devstate_prov_add

)

Definition at line 622 of file test_devicestate.c.

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

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

AST_TEST_DEFINE() [7/7]

AST_TEST_DEFINE

(

devstate_prov_del

)

Definition at line 644 of file test_devicestate.c.

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

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

cache_cleanup()

static void cache_cleanup ( int  unused )

static

Definition at line 498 of file test_devicestate.c.

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

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

Referenced by AST_TEST_DEFINE().

chan_test_devicestate_cb()

static int chan_test_devicestate_cb ( const char *  device_number )

static

Definition at line 907 of file test_devicestate.c.

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

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

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.

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

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

Referenced by AST_TEST_DEFINE().

consumer_create()

static struct consumer * consumer_create ( void  )

static

Definition at line 400 of file test_devicestate.c.

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

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

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

consumer_dtor()

static void consumer_dtor ( void *  obj )

static

Definition at line 385 of file test_devicestate.c.

{
    struct consumer *consumer = obj;
 
    ast_cond_destroy(&consumer->out);
}

References ast_cond_destroy, and consumer::out.

Referenced by consumer_create().

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.

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

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

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.

{
    struct consumer *consumer = data;
 
    if (stasis_subscription_final_message(sub, message)) {
        ao2_cleanup(consumer);
    }
}

References ao2_cleanup, stasis_subscription_final_message(), and sub.

Referenced by AST_TEST_DEFINE().

consumer_reset()

static void consumer_reset ( struct consumer *  consumer )

static

Definition at line 392 of file test_devicestate.c.

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

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

static void consumer_wait_for ( struct consumer *  consumer )

static

Definition at line 460 of file test_devicestate.c.

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

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

Referenced by AST_TEST_DEFINE().

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.

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

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, result_states, stasis_message_data(), ast_device_state_message::state, update_cond, and update_lock.

Referenced by AST_TEST_DEFINE().

devstate_prov_cb()

static enum ast_device_state devstate_prov_cb ( const char *  data )

static

Definition at line 287 of file test_devicestate.c.

{
    return current_device_state;
}

References current_device_state.

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

load_module()

static int load_module ( void  )

static

Definition at line 944 of file test_devicestate.c.

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

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

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.

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

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

safe_hangup()

static void safe_hangup ( void *  object )

static

Definition at line 861 of file test_devicestate.c.

{
    struct ast_channel *chan = object;
 
    if (!chan) {
        return;
    }
    ast_hangup(chan);
}

References ast_hangup().

Referenced by AST_TEST_DEFINE().

unload_module()

static int unload_module ( void  )

static

Definition at line 925 of file test_devicestate.c.

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

References ast_channel_unregister(), AST_TEST_UNREGISTER, AST_VECTOR_FREE, chan_test_devicestate, and result_states.

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.

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

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

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.

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

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

Referenced by AST_TEST_DEFINE().

Variable Documentation

__mod_info

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

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

Referenced by load_module(), and unload_module().

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 = AST_MUTEX_INIT_VALUE

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.

                                {
    AST_DEVICE_UNKNOWN,
    AST_DEVICE_NOT_INUSE,
    AST_DEVICE_INUSE,
    AST_DEVICE_BUSY,
    AST_DEVICE_UNKNOWN,
    AST_DEVICE_UNAVAILABLE,
    AST_DEVICE_RINGING,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_ONHOLD,
    AST_DEVICE_NOT_INUSE,
    AST_DEVICE_NOT_INUSE,
    AST_DEVICE_INUSE,
    AST_DEVICE_BUSY,
    AST_DEVICE_NOT_INUSE,
    AST_DEVICE_NOT_INUSE,
    AST_DEVICE_RINGING,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_ONHOLD,
    AST_DEVICE_INUSE,
    AST_DEVICE_INUSE,
    AST_DEVICE_INUSE,
    AST_DEVICE_BUSY,
    AST_DEVICE_INUSE,
    AST_DEVICE_INUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_INUSE,
    AST_DEVICE_BUSY,
    AST_DEVICE_BUSY,
    AST_DEVICE_BUSY,
    AST_DEVICE_BUSY,
    AST_DEVICE_BUSY,
    AST_DEVICE_BUSY,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_BUSY,
    AST_DEVICE_UNKNOWN,
    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,
    AST_DEVICE_UNAVAILABLE,
    AST_DEVICE_NOT_INUSE,
    AST_DEVICE_INUSE,
    AST_DEVICE_BUSY,
    AST_DEVICE_UNAVAILABLE,
    AST_DEVICE_UNAVAILABLE,
    AST_DEVICE_RINGING,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_ONHOLD,
    AST_DEVICE_RINGING,
    AST_DEVICE_RINGING,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGING,
    AST_DEVICE_RINGING,
    AST_DEVICE_RINGING,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_ONHOLD,
    AST_DEVICE_ONHOLD,
    AST_DEVICE_INUSE,
    AST_DEVICE_BUSY,
    AST_DEVICE_ONHOLD,
    AST_DEVICE_ONHOLD,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_RINGINUSE,
    AST_DEVICE_ONHOLD,
};

Referenced by AST_TEST_DEFINE().

current

size_t current

Definition at line 238 of file test_devicestate.c.

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

elems

enum ast_device_state* elems

Definition at line 238 of file test_devicestate.c.

exten_results

int exten_results[]

static

Definition at line 141 of file test_devicestate.c.

                             {
    AST_EXTENSION_NOT_INUSE,
    AST_EXTENSION_NOT_INUSE,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_NOT_INUSE,
    AST_EXTENSION_UNAVAILABLE,
    AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_ONHOLD,
    AST_EXTENSION_NOT_INUSE,
    AST_EXTENSION_NOT_INUSE,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_NOT_INUSE,
    AST_EXTENSION_NOT_INUSE,
    AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_ONHOLD,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_NOT_INUSE,
    AST_EXTENSION_NOT_INUSE,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_UNAVAILABLE,
    AST_EXTENSION_UNAVAILABLE,
    AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_ONHOLD,
    AST_EXTENSION_UNAVAILABLE,
    AST_EXTENSION_NOT_INUSE,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_UNAVAILABLE,
    AST_EXTENSION_UNAVAILABLE,
    AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_ONHOLD,
    AST_EXTENSION_RINGING,
    AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_RINGING,
    AST_EXTENSION_RINGING,
    AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_ONHOLD,
    AST_EXTENSION_ONHOLD,
    AST_EXTENSION_INUSE,
    AST_EXTENSION_BUSY,
    AST_EXTENSION_ONHOLD,
    AST_EXTENSION_ONHOLD,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_INUSE | AST_EXTENSION_RINGING,
    AST_EXTENSION_ONHOLD,
};

Referenced by AST_TEST_DEFINE().

max

size_t max

Definition at line 238 of file test_devicestate.c.

[struct]

struct { ... } result_states

The resulting device state updates caused by some function call.

Referenced by AST_TEST_DEFINE(), clear_result_states(), device_state_cb(), load_module(), unload_module(), and wait_for_device_state_updates().

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 = AST_MUTEX_INIT_VALUE

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