test_cdr.c File Reference

CDR unit tests. More...

#include "asterisk.h"
#include <math.h>
#include "asterisk/module.h"
#include "asterisk/test.h"
#include "asterisk/cdr.h"
#include "asterisk/linkedlists.h"
#include "asterisk/chanvars.h"
#include "asterisk/utils.h"
#include "asterisk/causes.h"
#include "asterisk/time.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_basic.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/format_cache.h"

Include dependency graph for test_cdr.c:

Go to the source code of this file.

Data Structures
struct	test_cdr_entry

Macros
#define	ALICE_CALLERID   { .id.name.str = "Alice", .id.name.valid = 1, .id.number.str = "100", .id.number.valid = 1, }
	Alice's Caller ID.
#define	BOB_CALLERID   { .id.name.str = "Bob", .id.name.valid = 1, .id.number.str = "200", .id.number.valid = 1, }
	Bob's Caller ID.
#define	CHANNEL_TECH_NAME   "CDRTestChannel"
#define	CHARLIE_CALLERID   { .id.name.str = "Charlie", .id.name.valid = 1, .id.number.str = "300", .id.number.valid = 1, }
	Charlie's Caller ID.
#define	COPY_IDS(channel_var, expected_record)
	Copy the linkedid and uniqueid from a channel to an expected CDR.
#define	CREATE_ALICE_CHANNEL(channel_var, caller_id, expected_record)
	Create a test_cdr_chan_tech for Alice, and set the expected CDR records' linkedid and uniqueid.
#define	CREATE_BOB_CHANNEL(channel_var, caller_id, expected_record)
	Create a test_cdr_chan_tech for Bob, and set the expected CDR records' linkedid and uniqueid.
#define	CREATE_CHARLIE_CHANNEL(channel_var, caller_id, expected_record)
	Create a test_cdr_chan_tech for Charlie, and set the expected CDR records' linkedid and uniqueid.
#define	CREATE_DAVID_CHANNEL(channel_var, caller_id, expected_record)
	Create a test_cdr_chan_tech for Charlie, and set the expected CDR records' linkedid and uniqueid.
#define	DAVID_CALLERID   { .id.name.str = "David", .id.name.valid = 1, .id.number.str = "400", .id.number.valid = 1, }
	David's Caller ID.
#define	EMULATE_APP_DATA(channel, priority, application, data)
	Emulate a channel entering into an application.
#define	EPSILON   0.001
#define	HANGUP_CHANNEL(channel, cause)
	Hang up a test channel safely.
#define	MOCK_CDR_BACKEND   "mock_cdr_backend"
#define	SET_FORMATS(chan)
	Set ulaw format on channel.
#define	SWAP_CONFIG(ao2_config, template)
	Macro to swap a configuration out from the CDR engine. This should be used at the beginning of each test to set the needed configuration for that test.
#define	TEST_CATEGORY   "/main/cdr/"
#define	VERIFY_NUMERIC_FIELD(field, actual, expected)
	Verify a numeric field. This will set the test status result to fail; as such, it assumes that (a) test is the test object variable, and (b) that a return variable res exists.
#define	VERIFY_STRING_FIELD(field, actual, expected)
	Verify a string field. This will set the test status result to fail; as such, it assumes that (a) test is the test object variable, and (b) that a return variable res exists.
#define	VERIFY_TIME_VALUE(field, actual)
	Verify a time field. This will set the test status result to fail; as such, it assumes that (a) test is the test object variable, and (b) that a return variable res exists.

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (test_cdr_channel_creation)
	AST_TEST_DEFINE (test_cdr_dial_answer_multiparty)
	AST_TEST_DEFINE (test_cdr_dial_answer_no_bridge)
	AST_TEST_DEFINE (test_cdr_dial_answer_twoparty_bridge_a)
	AST_TEST_DEFINE (test_cdr_dial_answer_twoparty_bridge_b)
	AST_TEST_DEFINE (test_cdr_dial_busy)
	AST_TEST_DEFINE (test_cdr_dial_caller_cancel)
	AST_TEST_DEFINE (test_cdr_dial_congestion)
	AST_TEST_DEFINE (test_cdr_dial_parallel_failed)
	AST_TEST_DEFINE (test_cdr_dial_unanswered)
	AST_TEST_DEFINE (test_cdr_dial_unavailable)
	AST_TEST_DEFINE (test_cdr_fields)
	AST_TEST_DEFINE (test_cdr_fork_cdr)
	AST_TEST_DEFINE (test_cdr_no_reset_cdr)
	AST_TEST_DEFINE (test_cdr_outbound_bridged_call)
	AST_TEST_DEFINE (test_cdr_park)
	AST_TEST_DEFINE (test_cdr_single_bridge)
	AST_TEST_DEFINE (test_cdr_single_bridge_continue)
	AST_TEST_DEFINE (test_cdr_single_multiparty_bridge)
	AST_TEST_DEFINE (test_cdr_single_party)
	AST_TEST_DEFINE (test_cdr_single_twoparty_bridge_a)
	AST_TEST_DEFINE (test_cdr_single_twoparty_bridge_b)
	AST_TEST_DEFINE (test_cdr_unanswered_inbound_call)
	AST_TEST_DEFINE (test_cdr_unanswered_outbound_call)
static void	clear_mock_cdr_backend (void)
static void	do_sleep (struct timespec *to_sleep)
static int	load_module (void)
static int	mock_cdr_backend_cb (struct ast_cdr *cdr)
static void	safe_bridge_destroy (struct ast_bridge *bridge)
static void	safe_channel_release (struct ast_channel *chan)
static int	test_cdr_cleanup_cb (struct ast_test_info *info, struct ast_test *test)
static int	test_cdr_init_cb (struct ast_test_info *info, struct ast_test *test)
static int	unload_module (void)
static enum ast_test_result_state	verify_mock_cdr_record (struct ast_test *test, struct ast_cdr *expected, int record)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "CDR unit tests" , .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, }
struct {
struct test_cdr_entry *   first
struct test_cdr_entry *   last
ast_mutex_t   lock
}	actual_cdr_entries = AST_LIST_HEAD_INIT_VALUE
	A linked list of received CDR entries from the engine.
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cdr_config	congestion_cdr_config
	A configuration suitable for CDRs with congestion enabled.
static struct ast_cdr_config	debug_cdr_config
	A configuration suitable for 'normal' CDRs.
static int	global_mock_cdr_count
	The number of CDRs the mock backend has received.
static ast_cond_t	mock_cdr_cond
	The Mock CDR backend condition wait.
static struct ast_cdr_config *	saved_config
	A placeholder for Asterisk's 'real' CDR configuration.
static struct ast_channel_tech	test_cdr_chan_tech
	A channel technology used for the unit tests.
static struct ast_cdr_config	unanswered_cdr_config
	A configuration suitable for CDRs with unanswered records.

Detailed Description

CDR unit tests.

Author

Matt Jordan mjord.nosp@m.an@d.nosp@m.igium.nosp@m..com

Definition in file test_cdr.c.

Macro Definition Documentation

ALICE_CALLERID

#define ALICE_CALLERID   { .id.name.str = "Alice", .id.name.valid = 1, .id.number.str = "100", .id.number.valid = 1, }

Alice's Caller ID.

Definition at line 216 of file test_cdr.c.

BOB_CALLERID

#define BOB_CALLERID   { .id.name.str = "Bob", .id.name.valid = 1, .id.number.str = "200", .id.number.valid = 1, }

Bob's Caller ID.

Definition at line 219 of file test_cdr.c.

CHANNEL_TECH_NAME

#define CHANNEL_TECH_NAME   "CDRTestChannel"

Definition at line 55 of file test_cdr.c.

CHARLIE_CALLERID

#define CHARLIE_CALLERID   { .id.name.str = "Charlie", .id.name.valid = 1, .id.number.str = "300", .id.number.valid = 1, }

Charlie's Caller ID.

Definition at line 222 of file test_cdr.c.

COPY_IDS

#define COPY_IDS	(		channel_var,
			expected_record
	)

Value:

    do { \
    ast_copy_string((expected_record)->uniqueid, ast_channel_uniqueid((channel_var)), sizeof((expected_record)->uniqueid)); \
    ast_copy_string((expected_record)->linkedid, ast_channel_linkedid((channel_var)), sizeof((expected_record)->linkedid)); \
    } while (0)

Copy the linkedid and uniqueid from a channel to an expected CDR.

Definition at line 228 of file test_cdr.c.

                                                  { \
    ast_copy_string((expected_record)->uniqueid, ast_channel_uniqueid((channel_var)), sizeof((expected_record)->uniqueid)); \
    ast_copy_string((expected_record)->linkedid, ast_channel_linkedid((channel_var)), sizeof((expected_record)->linkedid)); \
    } while (0)

CREATE_ALICE_CHANNEL

#define CREATE_ALICE_CHANNEL	(		channel_var,
			caller_id,
			expected_record
	)

Create a test_cdr_chan_tech for Alice, and set the expected CDR records' linkedid and uniqueid.

Definition at line 248 of file test_cdr.c.

                                                                         { \
    (channel_var) = ast_channel_alloc(0, AST_STATE_DOWN, "100", "Alice", "100", "100", "default", NULL, NULL, 0, CHANNEL_TECH_NAME "/Alice"); \
    SET_FORMATS((channel_var));\
    ast_channel_set_caller((channel_var), (caller_id), NULL); \
    ast_copy_string((expected_record)->uniqueid, ast_channel_uniqueid((channel_var)), sizeof((expected_record)->uniqueid)); \
    ast_copy_string((expected_record)->linkedid, ast_channel_linkedid((channel_var)), sizeof((expected_record)->linkedid)); \
    ast_channel_unlock((channel_var)); \
    } while (0)

CREATE_BOB_CHANNEL

#define CREATE_BOB_CHANNEL	(		channel_var,
			caller_id,
			expected_record
	)

Create a test_cdr_chan_tech for Bob, and set the expected CDR records' linkedid and uniqueid.

Definition at line 259 of file test_cdr.c.

                                                                       { \
    (channel_var) = ast_channel_alloc(0, AST_STATE_DOWN, "200", "Bob", "200", "200", "default", NULL, NULL, 0, CHANNEL_TECH_NAME "/Bob"); \
    SET_FORMATS((channel_var));\
    ast_channel_set_caller((channel_var), (caller_id), NULL); \
    ast_copy_string((expected_record)->uniqueid, ast_channel_uniqueid((channel_var)), sizeof((expected_record)->uniqueid)); \
    ast_copy_string((expected_record)->linkedid, ast_channel_linkedid((channel_var)), sizeof((expected_record)->linkedid)); \
    ast_channel_unlock((channel_var)); \
    } while (0)

CREATE_CHARLIE_CHANNEL

#define CREATE_CHARLIE_CHANNEL	(		channel_var,
			caller_id,
			expected_record
	)

Create a test_cdr_chan_tech for Charlie, and set the expected CDR records' linkedid and uniqueid.

Definition at line 270 of file test_cdr.c.

                                                                           { \
    (channel_var) = ast_channel_alloc(0, AST_STATE_DOWN, "300", "Charlie", "300", "300", "default", NULL, NULL, 0, CHANNEL_TECH_NAME "/Charlie"); \
    SET_FORMATS((channel_var));\
    ast_channel_set_caller((channel_var), (caller_id), NULL); \
    ast_copy_string((expected_record)->uniqueid, ast_channel_uniqueid((channel_var)), sizeof((expected_record)->uniqueid)); \
    ast_copy_string((expected_record)->linkedid, ast_channel_linkedid((channel_var)), sizeof((expected_record)->linkedid)); \
    ast_channel_unlock((channel_var)); \
    } while (0)

CREATE_DAVID_CHANNEL

#define CREATE_DAVID_CHANNEL	(		channel_var,
			caller_id,
			expected_record
	)

Create a test_cdr_chan_tech for Charlie, and set the expected CDR records' linkedid and uniqueid.

Definition at line 281 of file test_cdr.c.

                                                                         { \
    (channel_var) = ast_channel_alloc(0, AST_STATE_DOWN, "400", "David", "400", "400", "default", NULL, NULL, 0, CHANNEL_TECH_NAME "/David"); \
    SET_FORMATS((channel_var));\
    ast_channel_set_caller((channel_var), (caller_id), NULL); \
    ast_copy_string((expected_record)->uniqueid, ast_channel_uniqueid((channel_var)), sizeof((expected_record)->uniqueid)); \
    ast_copy_string((expected_record)->linkedid, ast_channel_linkedid((channel_var)), sizeof((expected_record)->linkedid)); \
    ast_channel_unlock((channel_var)); \
    } while (0)

DAVID_CALLERID

#define DAVID_CALLERID   { .id.name.str = "David", .id.name.valid = 1, .id.number.str = "400", .id.number.valid = 1, }

David's Caller ID.

Definition at line 225 of file test_cdr.c.

EMULATE_APP_DATA

#define EMULATE_APP_DATA	(		channel,
			priority,
			application,
			data
	)

Emulate a channel entering into an application.

Definition at line 291 of file test_cdr.c.

                                                                  { \
    if ((priority) > 0) { \
        ast_channel_priority_set((channel), (priority)); \
    } \
    ast_channel_lock((channel)); \
    ast_channel_appl_set((channel), (application)); \
    ast_channel_data_set((channel), (data)); \
    ast_channel_publish_snapshot((channel)); \
    ast_channel_unlock((channel)); \
    } while (0)

EPSILON

#define EPSILON   0.001

Definition at line 49 of file test_cdr.c.

HANGUP_CHANNEL

#define HANGUP_CHANNEL	(		channel,
			cause
	)

Value:

    do { \
        ast_channel_hangupcause_set((channel), (cause)); \
        ast_hangup(channel); \
        channel = NULL; \
    } while (0)

Hang up a test channel safely.

Definition at line 303 of file test_cdr.c.

       { \
        ast_channel_hangupcause_set((channel), (cause)); \
        ast_hangup(channel); \
        channel = NULL; \
    } while (0)

MOCK_CDR_BACKEND

#define MOCK_CDR_BACKEND   "mock_cdr_backend"

Definition at line 53 of file test_cdr.c.

SET_FORMATS

#define SET_FORMATS

(

chan

)

Set ulaw format on channel.

Definition at line 234 of file test_cdr.c.

                             {\
    struct ast_format_cap *caps;\
    caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);\
    ast_format_cap_append(caps, ast_format_ulaw, 0);\
    ast_channel_nativeformats_set((chan), caps);\
    ast_channel_set_writeformat((chan), ast_format_ulaw);\
    ast_channel_set_rawwriteformat((chan), ast_format_ulaw);\
    ast_channel_set_readformat((chan), ast_format_ulaw);\
    ast_channel_set_rawreadformat((chan), ast_format_ulaw);\
    ao2_ref(caps, -1);\
} while (0)

SWAP_CONFIG

#define SWAP_CONFIG	(		ao2_config,
			template
	)

Value:

    do { \
    *(ao2_config) = (template); \
    ast_cdr_set_config((ao2_config)); \
    } while (0)

Macro to swap a configuration out from the CDR engine. This should be used at the beginning of each test to set the needed configuration for that test.

Definition at line 79 of file test_cdr.c.

                                             { \
    *(ao2_config) = (template); \
    ast_cdr_set_config((ao2_config)); \
    } while (0)

TEST_CATEGORY

#define TEST_CATEGORY   "/main/cdr/"

Definition at line 51 of file test_cdr.c.

VERIFY_NUMERIC_FIELD

#define VERIFY_NUMERIC_FIELD	(		field,
			actual,
			expected
	)

Verify a numeric field. This will set the test status result to fail; as such, it assumes that (a) test is the test object variable, and (b) that a return variable res exists.

Definition at line 197 of file test_cdr.c.

                                                         { \
    if ((actual)->field != (expected)->field) { \
        ast_test_status_update(test, "Field %s failed: actual %ld, expected %ld\n", #field, (long)(actual)->field, (long)(expected)->field); \
        ast_test_set_result(test, AST_TEST_FAIL); \
        res = AST_TEST_FAIL; \
    } } while (0)

VERIFY_STRING_FIELD

#define VERIFY_STRING_FIELD	(		field,
			actual,
			expected
	)

Verify a string field. This will set the test status result to fail; as such, it assumes that (a) test is the test object variable, and (b) that a return variable res exists.

Definition at line 186 of file test_cdr.c.

                                                        { \
    if (strcmp((actual)->field, (expected)->field)) { \
        ast_test_status_update(test, "Field %s failed: actual %s, expected %s\n", #field, (actual)->field, (expected)->field); \
        ast_test_set_result(test, AST_TEST_FAIL); \
        res = AST_TEST_FAIL; \
    } } while (0)

VERIFY_TIME_VALUE

#define VERIFY_TIME_VALUE	(		field,
			actual
	)

Verify a time field. This will set the test status result to fail; as such, it assumes that (a) test is the test object variable, and (b) that a return variable res exists.

Definition at line 208 of file test_cdr.c.

                                            { \
    if (ast_tvzero((actual)->field)) { \
        ast_test_status_update(test, "Field %s failed: should not be 0\n", #field); \
        ast_test_set_result(test, AST_TEST_FAIL); \
        res = AST_TEST_FAIL; \
    } } while (0)

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2628 of file test_cdr.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 2628 of file test_cdr.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 2628 of file test_cdr.c.

AST_TEST_DEFINE() [1/24]

AST_TEST_DEFINE

(

test_cdr_channel_creation

)

Definition at line 393 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_NOANSWER,
        .accountcode = "100",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test that a CDR is created when a channel is created";
        info->description =
            "Test that a CDR is created when a channel is created";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, unanswered_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan, (&caller), &expected);
 
    HANGUP_CHANNEL(chan, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_NORMAL, AST_CDR_NOANSWER, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, unanswered_cdr_config, and verify_mock_cdr_record().

AST_TEST_DEFINE() [2/24]

AST_TEST_DEFINE

(

test_cdr_dial_answer_multiparty

)

Definition at line 1840 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_alice, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_bob, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_charlie, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_david, NULL, safe_channel_release);
    RAII_VAR(struct ast_bridge *, bridge, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct timespec to_sleep = {1, 0};
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    struct ast_party_caller alice_caller = ALICE_CALLERID;
    struct ast_party_caller charlie_caller = CHARLIE_CALLERID;
    struct ast_cdr charlie_expected_two = {
        .clid = "\"Charlie\" <300>",
        .src = "300",
        .dst = "300",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Charlie",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/David",
        .amaflags = AST_AMA_DOCUMENTATION,
        .billsec = 1,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "300",
        .peeraccount = "200",
    };
    struct ast_cdr charlie_expected_one = {
        .clid = "\"Charlie\" <300>",
        .src = "300",
        .dst = "300",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Charlie",
        .dstchannel = CHANNEL_TECH_NAME "/David",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/David",
        .amaflags = AST_AMA_DOCUMENTATION,
        .billsec = 1,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "300",
        .peeraccount = "400",
        .next = &charlie_expected_two,
    };
    struct ast_cdr bob_expected_one = {
        .clid = "\"Bob\" <200>",
        .src = "200",
        .dst = "200",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Bob",
        .dstchannel = CHANNEL_TECH_NAME "/David",
        .lastapp = "AppDial",
        .lastdata = "(Outgoing Line)",
        .amaflags = AST_AMA_DOCUMENTATION,
        .billsec = 1,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "200",
        .peeraccount = "400",
        .next = &charlie_expected_one,
    };
    struct ast_cdr alice_expected_three = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/David",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .amaflags = AST_AMA_DOCUMENTATION,
        .billsec = 1,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "400",
        .next = &bob_expected_one,
    };
    struct ast_cdr alice_expected_two = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Charlie",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .amaflags = AST_AMA_DOCUMENTATION,
        .billsec = 1,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "300",
        .next = &alice_expected_three,
    };
    struct ast_cdr alice_expected_one = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .amaflags = AST_AMA_DOCUMENTATION,
        .billsec = 1,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "200",
        .next = &alice_expected_two,
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test dialing, answering, and going into a multi-party bridge";
        info->description =
            "A little tricky to get to do, but possible with some redirects.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, debug_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_alice, &alice_caller, &alice_expected_one);
    COPY_IDS(chan_alice, &alice_expected_two);
    COPY_IDS(chan_alice, &alice_expected_three);
 
    EMULATE_APP_DATA(chan_alice, 1, "Dial", CHANNEL_TECH_NAME "/Bob");
 
    chan_bob = ast_channel_alloc(0, AST_STATE_DOWN, "200", "Bob", "200", "200", "default", NULL, NULL, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_bob);
    ast_channel_unlock(chan_bob);
    ast_set_flag(ast_channel_flags(chan_bob), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_bob, 0, "AppDial", "(Outgoing Line)");
    ast_copy_string(bob_expected_one.uniqueid, ast_channel_uniqueid(chan_bob), sizeof(bob_expected_one.uniqueid));
    ast_copy_string(bob_expected_one.linkedid, ast_channel_linkedid(chan_alice), sizeof(bob_expected_one.linkedid));
 
    CREATE_CHARLIE_CHANNEL(chan_charlie, &charlie_caller, &charlie_expected_one);
    EMULATE_APP_DATA(chan_charlie, 1, "Dial", CHANNEL_TECH_NAME "/David");
    ast_copy_string(charlie_expected_one.uniqueid, ast_channel_uniqueid(chan_charlie), sizeof(charlie_expected_one.uniqueid));
    ast_copy_string(charlie_expected_one.linkedid, ast_channel_linkedid(chan_alice), sizeof(charlie_expected_one.linkedid));
    ast_copy_string(charlie_expected_two.uniqueid, ast_channel_uniqueid(chan_charlie), sizeof(charlie_expected_two.uniqueid));
    ast_copy_string(charlie_expected_two.linkedid, ast_channel_linkedid(chan_alice), sizeof(charlie_expected_two.linkedid));
 
    chan_david = ast_channel_alloc(0, AST_STATE_DOWN, "400", "David", "400", "400", "default", NULL, NULL, 0, CHANNEL_TECH_NAME "/David");
    SET_FORMATS(chan_david);
    ast_channel_unlock(chan_david);
    ast_set_flag(ast_channel_flags(chan_david), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_david, 0, "AppDial", "(Outgoing Line)");
 
    ast_channel_publish_dial(chan_alice, chan_bob, "Bob", NULL);
    ast_channel_state_set(chan_alice, AST_STATE_RINGING);
    ast_channel_publish_dial(chan_charlie, chan_david, "David", NULL);
    ast_channel_state_set(chan_charlie, AST_STATE_RINGING);
    ast_channel_publish_dial(chan_alice, chan_bob, NULL, "ANSWER");
    ast_channel_publish_dial(chan_charlie, chan_david, NULL, "ANSWER");
 
    ast_channel_state_set(chan_alice, AST_STATE_UP);
    ast_channel_state_set(chan_bob, AST_STATE_UP);
    ast_channel_state_set(chan_charlie, AST_STATE_UP);
    ast_channel_state_set(chan_david, AST_STATE_UP);
 
    bridge = ast_bridge_basic_new();
    ast_test_validate(test, bridge != NULL);
 
    do_sleep(&to_sleep);
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_charlie, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_david, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_bob, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_alice, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
    ast_test_validate(test, !ast_bridge_depart(chan_alice));
    ast_test_validate(test, !ast_bridge_depart(chan_bob));
    ast_test_validate(test, !ast_bridge_depart(chan_charlie));
    ast_test_validate(test, !ast_bridge_depart(chan_david));
 
    HANGUP_CHANNEL(chan_alice, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_bob, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_charlie, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_david, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &alice_expected_one, 6);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, ast_bridge_basic_new(), ast_bridge_depart(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_alloc, ast_channel_flags(), ast_channel_linkedid(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_uniqueid(), ast_channel_unlock, ast_copy_string(), AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_STATE_UP, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, CHARLIE_CALLERID, ast_cdr::clid, config, COPY_IDS, CREATE_ALICE_CHANNEL, CREATE_CHARLIE_CHANNEL, debug_cdr_config, do_sleep(), EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_bridge_destroy(), safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [3/24]

AST_TEST_DEFINE

(

test_cdr_dial_answer_no_bridge

)

Definition at line 1589 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_caller, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_callee, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr bob_expected_one = {
        .clid = "\"\" <>",
        .src = "",
        .dst = "s",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Wait",
        .lastdata = "1",
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "200",
    };
    struct ast_cdr alice_expected_two = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .lastapp = "Wait",
        .lastdata = "1",
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .next = &bob_expected_one,
    };
    struct ast_cdr alice_expected_one = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "200",
        .next = &alice_expected_two,
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test dialing, answering, and not going into a bridge.";
        info->description =
            "This is a weird one, but theoretically possible. You can perform\n"
            "a dial, then bounce both channels to different priorities and\n"
            "never have them enter a bridge together. Ew. This makes sure that\n"
            "when we answer, we get a CDR, it gets ended at that point, and\n"
            "that it gets finalized appropriately. We should get three CDRs in\n"
            "the end - one for the dial, and one for each CDR as they continued\n"
            "on.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, debug_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_caller, &caller, &alice_expected_one);
    COPY_IDS(chan_caller, &alice_expected_two);
 
    EMULATE_APP_DATA(chan_caller, 1, "Dial", CHANNEL_TECH_NAME "/Bob");
 
    chan_callee = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "200", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_callee);
    ast_channel_unlock(chan_callee);
    ast_set_flag(ast_channel_flags(chan_callee), AST_FLAG_OUTGOING);
    COPY_IDS(chan_callee, &bob_expected_one);
 
    ast_channel_publish_dial(chan_caller, chan_callee, "Bob", NULL);
    ast_channel_state_set(chan_caller, AST_STATE_RINGING);
    ast_channel_publish_dial(chan_caller, chan_callee, NULL, "ANSWER");
 
    ast_channel_state_set(chan_caller, AST_STATE_UP);
    ast_clear_flag(ast_channel_flags(chan_callee), AST_FLAG_OUTGOING);
    ast_channel_state_set(chan_callee, AST_STATE_UP);
 
    EMULATE_APP_DATA(chan_caller, 2, "Wait", "1");
    EMULATE_APP_DATA(chan_callee, 1, "Wait", "1");
 
    HANGUP_CHANNEL(chan_caller, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_callee, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &alice_expected_one, 3);
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_alloc, ast_channel_flags(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_unlock, ast_clear_flag, AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_STATE_UP, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, COPY_IDS, CREATE_ALICE_CHANNEL, debug_cdr_config, EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, and verify_mock_cdr_record().

AST_TEST_DEFINE() [4/24]

AST_TEST_DEFINE

(

test_cdr_dial_answer_twoparty_bridge_a

)

Definition at line 1688 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_caller, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_callee, NULL, safe_channel_release);
    RAII_VAR(struct ast_bridge *, bridge, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct timespec to_sleep = {1, 0};
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .amaflags = AST_AMA_DOCUMENTATION,
        .billsec = 1,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "200",
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test dialing, answering, and going into a 2-party bridge";
        info->description =
            "The most 'basic' of scenarios";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, debug_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_caller, &caller, &expected);
 
    EMULATE_APP_DATA(chan_caller, 1, "Dial", CHANNEL_TECH_NAME "/Bob");
 
    chan_callee = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "200", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_callee);
    ast_channel_unlock(chan_callee);
    ast_set_flag(ast_channel_flags(chan_callee), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_callee, 0, "AppDial", "(Outgoing Line)");
 
    ast_channel_publish_dial(chan_caller, chan_callee, "Bob", NULL);
    ast_channel_state_set(chan_caller, AST_STATE_RINGING);
    ast_channel_publish_dial(chan_caller, chan_callee, NULL, "ANSWER");
 
    ast_channel_state_set(chan_caller, AST_STATE_UP);
    ast_channel_state_set(chan_callee, AST_STATE_UP);
 
    bridge = ast_bridge_basic_new();
    ast_test_validate(test, bridge != NULL);
    do_sleep(&to_sleep);
 
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_caller, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_callee, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
 
    do_sleep(&to_sleep);
 
    ast_bridge_depart(chan_caller);
    ast_bridge_depart(chan_callee);
 
    HANGUP_CHANNEL(chan_caller, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_callee, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &expected, 1);
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, ast_bridge_basic_new(), ast_bridge_depart(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_alloc, ast_channel_flags(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_unlock, AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_STATE_UP, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, debug_cdr_config, do_sleep(), EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_bridge_destroy(), safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [5/24]

AST_TEST_DEFINE

(

test_cdr_dial_answer_twoparty_bridge_b

)

Definition at line 1765 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_caller, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_callee, NULL, safe_channel_release);
    RAII_VAR(struct ast_bridge *, bridge, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct timespec to_sleep = {1, 0};
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .amaflags = AST_AMA_DOCUMENTATION,
        .billsec = 1,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "200",
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test dialing, answering, and going into a 2-party bridge";
        info->description =
            "The most 'basic' of scenarios";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, debug_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_caller, &caller, &expected);
 
    EMULATE_APP_DATA(chan_caller, 1, "Dial", CHANNEL_TECH_NAME "/Bob");
 
    chan_callee = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "200", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_callee);
    ast_channel_unlock(chan_callee);
    ast_set_flag(ast_channel_flags(chan_callee), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_callee, 0, "AppDial", "(Outgoing Line)");
 
    ast_channel_publish_dial(chan_caller, chan_callee, "Bob", NULL);
    ast_channel_state_set(chan_caller, AST_STATE_RINGING);
    ast_channel_publish_dial(chan_caller, chan_callee, NULL, "ANSWER");
 
    ast_channel_state_set(chan_caller, AST_STATE_UP);
    ast_channel_state_set(chan_callee, AST_STATE_UP);
 
    bridge = ast_bridge_basic_new();
    ast_test_validate(test, bridge != NULL);
    do_sleep(&to_sleep);
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_callee, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_caller, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
    ast_bridge_depart(chan_caller);
    ast_bridge_depart(chan_callee);
 
    HANGUP_CHANNEL(chan_caller, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_callee, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &expected, 1);
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, ast_bridge_basic_new(), ast_bridge_depart(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_alloc, ast_channel_flags(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_unlock, AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_STATE_UP, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, debug_cdr_config, do_sleep(), EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_bridge_destroy(), safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [6/24]

AST_TEST_DEFINE

(

test_cdr_dial_busy

)

Definition at line 1211 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_caller, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_callee, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .billsec = 0,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_BUSY,
        .accountcode = "100",
        .peeraccount = "200",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test CDRs for a dial that results in a busy";
        info->description =
            "Test the properties of a CDR for a channel that\n"
            "performs a dial operation to an endpoint that's busy";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, unanswered_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_caller, &caller, &expected);
 
    EMULATE_APP_DATA(chan_caller, 1, "Dial", CHANNEL_TECH_NAME "/Bob");
 
    chan_callee = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "200", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_callee);
    ast_channel_unlock(chan_callee);
    ast_set_flag(ast_channel_flags(chan_callee), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_callee, 0, "AppDial", "(Outgoing Line)");
 
    ast_channel_publish_dial(chan_caller, chan_callee, "Bob", NULL);
    ast_channel_state_set(chan_caller, AST_STATE_RINGING);
    ast_channel_publish_dial(chan_caller, chan_callee, NULL, "BUSY");
 
    HANGUP_CHANNEL(chan_caller, AST_CAUSE_BUSY);
    HANGUP_CHANNEL(chan_callee, AST_CAUSE_BUSY);
 
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_BUSY, AST_CDR_BUSY, ast_channel_alloc, ast_channel_flags(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_unlock, AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, unanswered_cdr_config, and verify_mock_cdr_record().

AST_TEST_DEFINE() [7/24]

AST_TEST_DEFINE

(

test_cdr_dial_caller_cancel

)

Definition at line 1397 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_caller, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_callee, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .billsec = 0,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_NOANSWER,
        .accountcode = "100",
        .peeraccount = "200",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test CDRs for a dial where the caller cancels";
        info->description =
            "Test the properties of a CDR for a channel that\n"
            "performs a dial operation to an endpoint but then decides\n"
            "to hang up, cancelling the dial";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, unanswered_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_caller, &caller, &expected);
 
    EMULATE_APP_DATA(chan_caller, 1, "Dial", CHANNEL_TECH_NAME "/Bob");
 
    chan_callee = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "200", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_callee);
    ast_channel_unlock(chan_callee);
    ast_set_flag(ast_channel_flags(chan_callee), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_callee, 0, "AppDial", "(Outgoing Line)");
 
    ast_channel_publish_dial(chan_caller, chan_callee, "Bob", NULL);
    ast_channel_state_set(chan_caller, AST_STATE_RINGING);
    ast_channel_publish_dial(chan_caller, chan_callee, NULL, "CANCEL");
 
    HANGUP_CHANNEL(chan_callee, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_caller, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_NORMAL, AST_CDR_NOANSWER, ast_channel_alloc, ast_channel_flags(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_unlock, AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, unanswered_cdr_config, and verify_mock_cdr_record().

AST_TEST_DEFINE() [8/24]

AST_TEST_DEFINE

(

test_cdr_dial_congestion

)

Definition at line 1273 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_caller, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_callee, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .billsec = 0,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_CONGESTION,
        .accountcode = "100",
        .peeraccount = "200",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test CDRs for a dial that results in congestion";
        info->description =
            "Test the properties of a CDR for a channel that\n"
            "performs a dial operation to an endpoint that's congested";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, congestion_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_caller, &caller, &expected);
 
    EMULATE_APP_DATA(chan_caller, 1, "Dial", CHANNEL_TECH_NAME "/Bob");
 
    chan_callee = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "200", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_callee);
    ast_channel_unlock(chan_callee);
    ast_set_flag(ast_channel_flags(chan_callee), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_callee, 0, "AppDial", "(Outgoing Line)");
 
    ast_channel_publish_dial(chan_caller, chan_callee, "Bob", NULL);
    ast_channel_state_set(chan_caller, AST_STATE_RINGING);
    ast_channel_publish_dial(chan_caller, chan_callee, NULL, "CONGESTION");
 
    HANGUP_CHANNEL(chan_caller, AST_CAUSE_CONGESTION);
    HANGUP_CHANNEL(chan_callee, AST_CAUSE_CONGESTION);
 
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_CONGESTION, AST_CDR_CONGESTION, ast_channel_alloc, ast_channel_flags(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_unlock, AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, congestion_cdr_config, CREATE_ALICE_CHANNEL, EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, and verify_mock_cdr_record().

AST_TEST_DEFINE() [9/24]

AST_TEST_DEFINE

(

test_cdr_dial_parallel_failed

)

Definition at line 1460 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_caller, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_bob, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_charlie, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_david, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr bob_expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob&" CHANNEL_TECH_NAME "/Charlie&" CHANNEL_TECH_NAME "/David",
        .billsec = 0,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_NOANSWER,
        .accountcode = "100",
        .peeraccount = "200",
    };
    struct ast_cdr charlie_expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Charlie",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob&" CHANNEL_TECH_NAME "/Charlie&" CHANNEL_TECH_NAME "/David",
        .billsec = 0,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_BUSY,
        .accountcode = "100",
        .peeraccount = "300",
    };
    struct ast_cdr david_expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/David",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob&" CHANNEL_TECH_NAME "/Charlie&" CHANNEL_TECH_NAME "/David",
        .billsec = 0,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_CONGESTION,
        .accountcode = "100",
        .peeraccount = "400",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    struct ast_cdr *expected = &bob_expected;
    bob_expected.next = &charlie_expected;
    charlie_expected.next = &david_expected;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test a parallel dial where all channels fail to answer";
        info->description =
            "This tests dialing three parties: Bob, Charlie, David. Charlie\n"
            "returns BUSY; David returns CONGESTION; Bob fails to answer and\n"
            "Alice hangs up. Three records are created for Alice as a result.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, congestion_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_caller, &caller, &bob_expected);
    COPY_IDS(chan_caller, &charlie_expected);
    COPY_IDS(chan_caller, &david_expected);
 
    /* Channel enters Dial app */
    EMULATE_APP_DATA(chan_caller, 1, "Dial", CHANNEL_TECH_NAME "/Bob&" CHANNEL_TECH_NAME "/Charlie&" CHANNEL_TECH_NAME "/David");
 
    /* Outbound channels are created */
    chan_bob = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "200", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_bob);
    ast_channel_unlock(chan_bob);
    ast_set_flag(ast_channel_flags(chan_bob), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_bob, 0, "AppDial", "(Outgoing Line)");
 
    chan_charlie = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "300", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/Charlie");
    SET_FORMATS(chan_charlie);
    ast_channel_unlock(chan_charlie);
    ast_set_flag(ast_channel_flags(chan_charlie), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_charlie, 0, "AppDial", "(Outgoing Line)");
 
    chan_david = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "400", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/David");
    SET_FORMATS(chan_charlie);
    ast_channel_unlock(chan_david);
    ast_set_flag(ast_channel_flags(chan_david), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_david, 0, "AppDial", "(Outgoing Line)");
 
    /* Dial starts */
    ast_channel_publish_dial(chan_caller, chan_bob, "Bob", NULL);
    ast_channel_publish_dial(chan_caller, chan_charlie, "Charlie", NULL);
    ast_channel_publish_dial(chan_caller, chan_david, "David", NULL);
    ast_channel_state_set(chan_caller, AST_STATE_RINGING);
 
    /* Charlie is busy */
    ast_channel_publish_dial(chan_caller, chan_charlie, NULL, "BUSY");
    HANGUP_CHANNEL(chan_charlie, AST_CAUSE_BUSY);
 
    /* David is congested */
    ast_channel_publish_dial(chan_caller, chan_david, NULL, "CONGESTION");
    HANGUP_CHANNEL(chan_david, AST_CAUSE_CONGESTION);
 
    /* Bob is canceled */
    ast_channel_publish_dial(chan_caller, chan_bob, NULL, "CANCEL");
    HANGUP_CHANNEL(chan_bob, AST_CAUSE_NORMAL);
 
    /* Alice hangs up */
    HANGUP_CHANNEL(chan_caller, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, expected, 3);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_BUSY, AST_CAUSE_CONGESTION, AST_CAUSE_NORMAL, AST_CDR_BUSY, AST_CDR_CONGESTION, AST_CDR_NOANSWER, ast_channel_alloc, ast_channel_flags(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_unlock, AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, congestion_cdr_config, COPY_IDS, CREATE_ALICE_CHANNEL, EMULATE_APP_DATA, HANGUP_CHANNEL, ast_cdr::next, NULL, RAII_VAR, result, safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, and verify_mock_cdr_record().

AST_TEST_DEFINE() [10/24]

AST_TEST_DEFINE

(

test_cdr_dial_unanswered

)

Definition at line 1148 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_caller, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_callee, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .billsec = 0,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_NOANSWER,
        .accountcode = "100",
        .peeraccount = "200",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test CDRs for a dial that isn't answered";
        info->description =
            "Test the properties of a CDR for a channel that\n"
            "performs a dial operation that isn't answered";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, unanswered_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_caller, &caller, &expected);
 
    EMULATE_APP_DATA(chan_caller, 1, "Dial", "CDRTestChannel/Bob");
 
    chan_callee = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "200", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_callee);
    ast_channel_unlock(chan_callee);
    ast_set_flag(ast_channel_flags(chan_callee), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_callee, 0, "AppDial", "(Outgoing Line)");
 
    ast_channel_publish_dial(chan_caller, chan_callee, "Bob", NULL);
    ast_channel_state_set(chan_caller, AST_STATE_RINGING);
    ast_channel_publish_dial(chan_caller, chan_callee, NULL, "NOANSWER");
 
    HANGUP_CHANNEL(chan_caller, AST_CAUSE_NO_ANSWER);
    HANGUP_CHANNEL(chan_callee, AST_CAUSE_NO_ANSWER);
 
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_NO_ANSWER, AST_CDR_NOANSWER, ast_channel_alloc, ast_channel_flags(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_unlock, AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, unanswered_cdr_config, and verify_mock_cdr_record().

AST_TEST_DEFINE() [11/24]

AST_TEST_DEFINE

(

test_cdr_dial_unavailable

)

Definition at line 1335 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_caller, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_callee, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Dial",
        .lastdata = CHANNEL_TECH_NAME "/Bob",
        .billsec = 0,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_FAILED,
        .accountcode = "100",
        .peeraccount = "200",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test CDRs for a dial that results in unavailable";
        info->description =
            "Test the properties of a CDR for a channel that\n"
            "performs a dial operation to an endpoint that's unavailable";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, unanswered_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_caller, &caller, &expected);
 
    EMULATE_APP_DATA(chan_caller, 1, "Dial", CHANNEL_TECH_NAME "/Bob");
 
    chan_callee = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "200", NULL, NULL, NULL, chan_caller, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_callee);
    ast_channel_unlock(chan_callee);
    ast_set_flag(ast_channel_flags(chan_callee), AST_FLAG_OUTGOING);
    EMULATE_APP_DATA(chan_callee, 0, "AppDial", "(Outgoing Line)");
 
    ast_channel_publish_dial(chan_caller, chan_callee, "Bob", NULL);
    ast_channel_state_set(chan_caller, AST_STATE_RINGING);
    ast_channel_publish_dial(chan_caller, chan_callee, NULL, "CHANUNAVAIL");
 
    HANGUP_CHANNEL(chan_caller, AST_CAUSE_NO_ROUTE_DESTINATION);
    HANGUP_CHANNEL(chan_callee, AST_CAUSE_NO_ROUTE_DESTINATION);
 
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_NO_ROUTE_DESTINATION, AST_CDR_FAILED, ast_channel_alloc, ast_channel_flags(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_unlock, AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, unanswered_cdr_config, and verify_mock_cdr_record().

AST_TEST_DEFINE() [12/24]

AST_TEST_DEFINE

(

test_cdr_fields

)

Definition at line 2120 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    char varbuffer[128];
    int int_buffer;
    double db_buffer;
    struct timespec to_sleep = {2, 0};
    struct ast_flags fork_options = { 0, };
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr original = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .lastapp = "Wait",
        .lastdata = "10",
        .billsec = 0,
        .amaflags = AST_AMA_OMIT,
        .disposition = AST_CDR_FAILED,
        .accountcode = "XXX",
        .userfield = "yackity",
    };
    struct ast_cdr fork_expected_one = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .lastapp = "Wait",
        .lastdata = "10",
        .billsec = 0,
        .amaflags = AST_AMA_OMIT,
        .disposition = AST_CDR_FAILED,
        .accountcode = "XXX",
        .userfield = "yackity",
    };
    struct ast_cdr fork_expected_two = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .lastapp = "Answer",
        .billsec = 0,
        .amaflags = AST_AMA_OMIT,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "ZZZ",
        .userfield = "schmackity",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    struct ast_cdr *expected = &original;
    original.next = &fork_expected_one;
    fork_expected_one.next = &fork_expected_two;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test field access CDRs";
        info->description =
            "This tests setting/retrieving data on CDR records.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, unanswered_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan, &caller, &original);
    ast_copy_string(fork_expected_one.uniqueid, ast_channel_uniqueid(chan), sizeof(fork_expected_one.uniqueid));
    ast_copy_string(fork_expected_one.linkedid, ast_channel_linkedid(chan), sizeof(fork_expected_one.linkedid));
    ast_copy_string(fork_expected_two.uniqueid, ast_channel_uniqueid(chan), sizeof(fork_expected_two.uniqueid));
    ast_copy_string(fork_expected_two.linkedid, ast_channel_linkedid(chan), sizeof(fork_expected_two.linkedid));
 
    /* Channel enters Wait app */
    ast_channel_lock(chan);
    ast_channel_appl_set(chan, "Wait");
    ast_channel_data_set(chan, "10");
    ast_channel_priority_set(chan, 1);
    ast_channel_publish_snapshot(chan);
 
    /* Set properties on the channel that propagate to the CDR */
    ast_channel_amaflags_set(chan, AST_AMA_OMIT);
    ast_channel_accountcode_set(chan, "XXX");
    ast_channel_unlock(chan);
 
    /* Wait one second so we get a duration. */
    do_sleep(&to_sleep);
 
    ast_cdr_setuserfield(ast_channel_name(chan), "foobar");
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "test_variable", "record_1") == 0);
 
    /* Verify that we can't set read-only fields or other fields directly */
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "clid", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "src", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "dst", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "dcontext", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "channel", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "dstchannel", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "lastapp", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "lastdata", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "start", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "answer", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "end", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "duration", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "billsec", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "disposition", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "amaflags", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "accountcode", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "uniqueid", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "linkedid", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "userfield", "junk") != 0);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "sequence", "junk") != 0);
 
    /* Verify the values */
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "userfield", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "foobar") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "test_variable", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "record_1") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "amaflags", varbuffer, sizeof(varbuffer)) == 0);
    sscanf(varbuffer, "%d", &int_buffer);
    ast_test_validate(test, int_buffer == AST_AMA_OMIT);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "accountcode", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "XXX") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "clid", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "\"Alice\" <100>") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "src", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "100") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "dst", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "100") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "dcontext", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "default") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "channel", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, CHANNEL_TECH_NAME "/Alice") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "dstchannel", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "lastapp", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "Wait") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "lastdata", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "10") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "start", varbuffer, sizeof(varbuffer)) == 0);
    sscanf(varbuffer, "%lf", &db_buffer);
    ast_test_validate(test, fabs(db_buffer) > 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "answer", varbuffer, sizeof(varbuffer)) == 0);
    sscanf(varbuffer, "%lf", &db_buffer);
    ast_test_validate(test, fabs(db_buffer) < EPSILON);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "end", varbuffer, sizeof(varbuffer)) == 0);
    sscanf(varbuffer, "%lf", &db_buffer);
    ast_test_validate(test, fabs(db_buffer) < EPSILON);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "duration", varbuffer, sizeof(varbuffer)) == 0);
    sscanf(varbuffer, "%lf", &db_buffer);
    ast_test_validate(test, fabs(db_buffer) > 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "billsec", varbuffer, sizeof(varbuffer)) == 0);
    sscanf(varbuffer, "%lf", &db_buffer);
    ast_test_validate(test, fabs(db_buffer) < EPSILON);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "disposition", varbuffer, sizeof(varbuffer)) == 0);
    sscanf(varbuffer, "%d", &int_buffer);
    ast_test_validate(test, int_buffer == AST_CDR_NULL);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "uniqueid", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, ast_channel_uniqueid(chan)) == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "linkedid", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, ast_channel_linkedid(chan)) == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "sequence", varbuffer, sizeof(varbuffer)) == 0);
 
    /* Fork the CDR, and check that we change the properties on both CDRs. */
    ast_set_flag(&fork_options, AST_CDR_FLAG_KEEP_VARS);
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
 
    /* Change some properties */
    ast_cdr_setuserfield(ast_channel_name(chan), "yackity");
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "test_variable", "record_1b") == 0);
 
    /* Fork the CDR again, finalizing all current CDRs */
    ast_set_flag(&fork_options, AST_CDR_FLAG_KEEP_VARS | AST_CDR_FLAG_FINALIZE);
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
 
    /* Channel enters Answer app */
    ast_channel_lock(chan);
    ast_channel_appl_set(chan, "Answer");
    ast_channel_data_set(chan, "");
    ast_channel_priority_set(chan, 1);
    ast_channel_publish_snapshot(chan);
    ast_setstate(chan, AST_STATE_UP);
 
    /* Set properties on the last record */
    ast_channel_accountcode_set(chan, "ZZZ");
    ast_channel_unlock(chan);
    ast_cdr_setuserfield(ast_channel_name(chan), "schmackity");
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "test_variable", "record_2") == 0);
 
    /* Hang up and verify */
    ast_channel_hangupcause_set(chan, AST_CAUSE_NORMAL);
    ast_hangup(chan);
    chan = NULL;
    result = verify_mock_cdr_record(test, expected, 3);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_OMIT, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, AST_CDR_FAILED, AST_CDR_FLAG_FINALIZE, AST_CDR_FLAG_KEEP_VARS, ast_cdr_fork(), ast_cdr_getvar(), AST_CDR_NULL, ast_cdr_setuserfield(), ast_cdr_setvar(), ast_channel_amaflags_set(), ast_channel_appl_set(), ast_channel_data_set(), ast_channel_hangupcause_set(), ast_channel_linkedid(), ast_channel_lock, ast_channel_name(), ast_channel_priority_set(), ast_channel_publish_snapshot(), ast_channel_uniqueid(), ast_channel_unlock, ast_copy_string(), ast_hangup(), ast_set_flag, ast_setstate(), AST_STATE_UP, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, do_sleep(), EPSILON, ast_cdr::next, NULL, RAII_VAR, result, safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, unanswered_cdr_config, and verify_mock_cdr_record().

AST_TEST_DEFINE() [13/24]

AST_TEST_DEFINE

(

test_cdr_fork_cdr

)

Definition at line 2394 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    char varbuffer[128];
    char fork_varbuffer[128];
    char answer_time[128];
    char fork_answer_time[128];
    char start_time[128];
    char fork_start_time[128];
    struct ast_flags fork_options = { 0, };
    struct timespec to_sleep = {1, 10000};
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr original = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
    };
    struct ast_cdr fork_expected_one = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
    };
    struct ast_cdr fork_expected_two = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
    struct ast_cdr *expected = &original;
    original.next = &fork_expected_one;
    fork_expected_one.next = &fork_expected_two;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test field access CDRs";
        info->description =
            "This tests setting/retrieving data on CDR records.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, debug_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan, &caller, &original);
    ast_copy_string(fork_expected_one.uniqueid, ast_channel_uniqueid(chan), sizeof(fork_expected_one.uniqueid));
    ast_copy_string(fork_expected_one.linkedid, ast_channel_linkedid(chan), sizeof(fork_expected_one.linkedid));
    ast_copy_string(fork_expected_two.uniqueid, ast_channel_uniqueid(chan), sizeof(fork_expected_two.uniqueid));
    ast_copy_string(fork_expected_two.linkedid, ast_channel_linkedid(chan), sizeof(fork_expected_two.linkedid));
 
    do_sleep(&to_sleep);
 
    /* Test blowing away variables */
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "test_variable", "record_1") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "test_variable", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "record_1") == 0);
    ast_copy_string(varbuffer, "", sizeof(varbuffer));
 
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "test_variable", fork_varbuffer, sizeof(fork_varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "record_1") != 0);
 
    /* Test finalizing previous CDRs */
    ast_set_flag(&fork_options, AST_CDR_FLAG_FINALIZE);
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
 
    /* Test keep variables; setting a new answer time */
    ast_channel_lock(chan);
    ast_setstate(chan, AST_STATE_UP);
    ast_channel_unlock(chan);
    do_sleep(&to_sleep);
    ast_test_validate(test, ast_cdr_setvar(ast_channel_name(chan), "test_variable", "record_2") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "test_variable", varbuffer, sizeof(varbuffer)) == 0);
    ast_test_validate(test, strcmp(varbuffer, "record_2") == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "answer", answer_time, sizeof(answer_time)) == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "start", start_time, sizeof(start_time)) == 0);
 
    ast_set_flag(&fork_options, AST_CDR_FLAG_FINALIZE);
    ast_set_flag(&fork_options, AST_CDR_FLAG_KEEP_VARS);
    ast_set_flag(&fork_options, AST_CDR_FLAG_SET_ANSWER);
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "answer", fork_answer_time, sizeof(fork_answer_time)) == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "start", fork_start_time, sizeof(fork_start_time)) == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "test_variable", fork_varbuffer, sizeof(fork_varbuffer)) == 0);
    ast_test_validate(test, strcmp(fork_varbuffer, varbuffer) == 0);
    ast_test_validate(test, strcmp(fork_start_time, start_time) == 0);
    ast_test_validate(test, strcmp(fork_answer_time, answer_time) != 0);
 
    ast_clear_flag(&fork_options, AST_CDR_FLAG_SET_ANSWER);
    ast_set_flag(&fork_options, AST_CDR_FLAG_RESET);
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "answer", fork_answer_time, sizeof(fork_answer_time)) == 0);
    ast_test_validate(test, ast_cdr_getvar(ast_channel_name(chan), "start", fork_start_time, sizeof(fork_start_time)) == 0);
    ast_test_validate(test, strcmp(fork_start_time, start_time) != 0);
    ast_test_validate(test, strcmp(fork_answer_time, answer_time) != 0);
 
    ast_channel_hangupcause_set(chan, AST_CAUSE_NORMAL);
    ast_hangup(chan);
    chan = NULL;
    result = verify_mock_cdr_record(test, expected, 3);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, AST_CDR_FLAG_FINALIZE, AST_CDR_FLAG_KEEP_VARS, AST_CDR_FLAG_RESET, AST_CDR_FLAG_SET_ANSWER, ast_cdr_fork(), ast_cdr_getvar(), ast_cdr_setvar(), ast_channel_hangupcause_set(), ast_channel_linkedid(), ast_channel_lock, ast_channel_name(), ast_channel_uniqueid(), ast_channel_unlock, ast_clear_flag, ast_copy_string(), ast_hangup(), ast_set_flag, ast_setstate(), AST_STATE_UP, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, debug_cdr_config, do_sleep(), ast_cdr::next, NULL, RAII_VAR, result, safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [14/24]

AST_TEST_DEFINE

(

test_cdr_no_reset_cdr

)

Definition at line 2324 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct ast_flags fork_options = { 0, };
    struct timespec to_sleep = {1, 0};
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .billsec = 0,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_FAILED,
        .accountcode = "100",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test field access CDRs";
        info->description =
            "This tests setting/retrieving data on CDR records.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, unanswered_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan, &caller, &expected);
 
    do_sleep(&to_sleep);
 
    /* Disable the CDR */
    ast_test_validate(test, ast_cdr_set_property(ast_channel_name(chan), AST_CDR_FLAG_DISABLE) == 0);
 
    /* Fork the CDR. This should be enabled */
    ast_set_flag(&fork_options, AST_CDR_FLAG_FINALIZE);
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
 
    /* Disable and enable the forked CDR */
    ast_test_validate(test, ast_cdr_set_property(ast_channel_name(chan), AST_CDR_FLAG_DISABLE) == 0);
    ast_test_validate(test, ast_cdr_clear_property(ast_channel_name(chan), AST_CDR_FLAG_DISABLE) == 0);
 
    /* Fork and finalize again. This CDR should be propagated */
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
 
    /* Disable all future CDRs */
    ast_test_validate(test, ast_cdr_set_property(ast_channel_name(chan), AST_CDR_FLAG_DISABLE_ALL) == 0);
 
    /* Fork a few more */
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
    ast_test_validate(test, ast_cdr_fork(ast_channel_name(chan), &fork_options) == 0);
 
    ast_channel_hangupcause_set(chan, AST_CAUSE_NORMAL);
    ast_hangup(chan);
    chan = NULL;
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_NORMAL, ast_cdr_clear_property(), AST_CDR_FAILED, AST_CDR_FLAG_DISABLE, AST_CDR_FLAG_DISABLE_ALL, AST_CDR_FLAG_FINALIZE, ast_cdr_fork(), ast_cdr_set_property(), ast_channel_hangupcause_set(), ast_channel_name(), ast_hangup(), ast_set_flag, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, do_sleep(), NULL, RAII_VAR, result, safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, unanswered_cdr_config, and verify_mock_cdr_record().

AST_TEST_DEFINE() [15/24]

AST_TEST_DEFINE

(

test_cdr_outbound_bridged_call

)

Definition at line 535 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_alice, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_bob, NULL, safe_channel_release);
    RAII_VAR(struct ast_bridge *, bridge, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct timespec to_sleep = {1, 0};
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr alice_expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "",
        .lastdata = "",
        .amaflags = AST_AMA_DOCUMENTATION,
        .billsec = 1,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "200",
    };
    struct ast_cdr bob_expected = {
        .clid = "\"\" <>",
        .src = "",
        .dst = "s",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Bob",
        .dstchannel = "",
        .lastapp = "AppDial",
        .lastdata = "(Outgoing Line)",
        .amaflags = AST_AMA_DOCUMENTATION,
        .billsec = 1,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "200",
        .peeraccount = "",
        .next = &alice_expected,
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test dialing, answering, and going into a 2-party bridge";
        info->description =
            "The most 'basic' of scenarios";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, debug_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan_alice, &caller, &alice_expected);
    ast_channel_state_set(chan_alice, AST_STATE_UP);
 
    bridge = ast_bridge_basic_new();
    ast_test_validate(test, bridge != NULL);
    do_sleep(&to_sleep);
 
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_alice, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
 
    chan_bob = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, "200", NULL, NULL, NULL, chan_alice, 0, CHANNEL_TECH_NAME "/Bob");
    SET_FORMATS(chan_bob);
    ast_channel_unlock(chan_bob);
    ast_copy_string(bob_expected.linkedid, ast_channel_linkedid(chan_bob), sizeof(bob_expected.linkedid));
    ast_copy_string(bob_expected.uniqueid, ast_channel_uniqueid(chan_bob), sizeof(bob_expected.uniqueid));
    ast_set_flag(ast_channel_flags(chan_bob), AST_FLAG_OUTGOING);
    ast_set_flag(ast_channel_flags(chan_bob), AST_FLAG_ORIGINATED);
    EMULATE_APP_DATA(chan_bob, 0, "AppDial", "(Outgoing Line)");
 
    ast_channel_publish_dial(NULL, chan_bob, "Bob", NULL);
    ast_channel_state_set(chan_bob, AST_STATE_RINGING);
    ast_channel_publish_dial(NULL, chan_bob, NULL, "ANSWER");
 
    ast_channel_state_set(chan_bob, AST_STATE_UP);
 
    do_sleep(&to_sleep);
 
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_bob, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
 
    do_sleep(&to_sleep);
 
    ast_bridge_depart(chan_bob);
    ast_bridge_depart(chan_alice);
 
    HANGUP_CHANNEL(chan_bob, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_alice, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &bob_expected, 2);
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, ast_bridge_basic_new(), ast_bridge_depart(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_alloc, ast_channel_flags(), ast_channel_linkedid(), ast_channel_publish_dial(), ast_channel_state_set(), ast_channel_uniqueid(), ast_channel_unlock, ast_copy_string(), AST_FLAG_ORIGINATED, AST_FLAG_OUTGOING, ast_set_flag, AST_STATE_DOWN, AST_STATE_RINGING, AST_STATE_UP, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, debug_cdr_config, do_sleep(), EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_bridge_destroy(), safe_channel_release(), SET_FORMATS, ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [16/24]

AST_TEST_DEFINE

(

test_cdr_park

)

Definition at line 2030 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_alice, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_bob, NULL, safe_channel_release);
    RAII_VAR(struct ast_bridge *, bridge, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct timespec to_sleep = {1, 0};
 
    struct ast_party_caller bob_caller = BOB_CALLERID;
    struct ast_party_caller alice_caller = ALICE_CALLERID;
    struct ast_cdr bob_expected = {
        .clid = "\"Bob\" <200>",
        .src = "200",
        .dst = "200",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Park",
        .lastdata = "701",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "200",
    };
    struct ast_cdr alice_expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .lastapp = "Park",
        .lastdata = "700",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .next = &bob_expected,
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test cdrs for a single party entering Park";
        info->description =
            "Test the properties of a CDR for calls that are\n"
            "answered, enters Park, and leaves it.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
    SWAP_CONFIG(config, debug_cdr_config);
    CREATE_ALICE_CHANNEL(chan_alice, &alice_caller, &alice_expected);
    CREATE_BOB_CHANNEL(chan_bob, &bob_caller, &bob_expected);
 
    ast_channel_lock(chan_alice);
    EMULATE_APP_DATA(chan_alice, 1, "Park", "700");
    ast_setstate(chan_alice, AST_STATE_UP);
    ast_channel_unlock(chan_alice);
 
    ast_channel_lock(chan_bob);
    EMULATE_APP_DATA(chan_bob, 1, "Park", "701");
    ast_setstate(chan_bob, AST_STATE_UP);
    ast_channel_unlock(chan_bob);
 
    bridge = ast_bridge_base_new(AST_BRIDGE_CAPABILITY_HOLDING,
        AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM
            | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_TRANSFER_PROHIBITED,
        "test_cdr", "test_cdr_park", NULL);
    ast_test_validate(test, bridge != NULL);
 
    do_sleep(&to_sleep);
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_alice, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_bob, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
    ast_bridge_depart(chan_alice);
    ast_bridge_depart(chan_bob);
 
    /* And then it hangs up */
    HANGUP_CHANNEL(chan_alice, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_bob, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &alice_expected, 2);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, ast_bridge_base_new(), AST_BRIDGE_CAPABILITY_HOLDING, ast_bridge_depart(), AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM, AST_BRIDGE_FLAG_TRANSFER_PROHIBITED, ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_lock, ast_channel_unlock, ast_setstate(), AST_STATE_UP, AST_TEST_NOT_RUN, BOB_CALLERID, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, CREATE_BOB_CHANNEL, debug_cdr_config, do_sleep(), EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_bridge_destroy(), safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [17/24]

AST_TEST_DEFINE

(

test_cdr_single_bridge

)

Definition at line 684 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, safe_channel_release);
    RAII_VAR(struct ast_bridge *, bridge, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct timespec to_sleep = {1, 0};
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .lastapp = "Bridge",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test cdrs for a single party entering/leaving a bridge";
        info->description =
            "Test the properties of a CDR for a call that is\n"
            "answered, enters a bridge, and leaves it.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
    SWAP_CONFIG(config, debug_cdr_config);
    CREATE_ALICE_CHANNEL(chan, &caller, &expected);
 
    ast_channel_lock(chan);
    EMULATE_APP_DATA(chan, 1, "Answer", "");
    ast_setstate(chan, AST_STATE_UP);
    EMULATE_APP_DATA(chan, 2, "Bridge", "");
    ast_channel_unlock(chan);
 
    bridge = ast_bridge_basic_new();
    ast_test_validate(test, bridge != NULL);
 
    do_sleep(&to_sleep);
    ast_test_validate(test, !ast_bridge_impart(bridge, chan, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
 
    do_sleep(&to_sleep);
 
    ast_bridge_depart(chan);
 
    HANGUP_CHANNEL(chan, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, ast_bridge_basic_new(), ast_bridge_depart(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_lock, ast_channel_unlock, ast_setstate(), AST_STATE_UP, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, debug_cdr_config, do_sleep(), EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_bridge_destroy(), safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [18/24]

AST_TEST_DEFINE

(

test_cdr_single_bridge_continue

)

Definition at line 745 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, safe_channel_release);
    RAII_VAR(struct ast_bridge *, bridge, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct timespec to_sleep = {1, 0};
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected_two = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .lastapp = "Wait",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
    };
    struct ast_cdr expected_one = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .lastapp = "Bridge",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .next = &expected_two,
    };
 
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test cdrs for a single party entering/leaving a bridge";
        info->description =
            "Test the properties of a CDR for a call that is\n"
            "answered, enters a bridge, and leaves it.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
    SWAP_CONFIG(config, debug_cdr_config);
    CREATE_ALICE_CHANNEL(chan, &caller, &expected_one);
    COPY_IDS(chan, &expected_two);
 
    ast_channel_lock(chan);
    EMULATE_APP_DATA(chan, 1, "Answer", "");
    ast_setstate(chan, AST_STATE_UP);
    EMULATE_APP_DATA(chan, 2, "Bridge", "");
    ast_channel_unlock(chan);
 
    bridge = ast_bridge_basic_new();
    ast_test_validate(test, bridge != NULL);
    do_sleep(&to_sleep);
 
    ast_test_validate(test, !ast_bridge_impart(bridge, chan, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
 
    do_sleep(&to_sleep);
 
    ast_bridge_depart(chan);
 
    EMULATE_APP_DATA(chan, 3, "Wait", "");
 
    /* And then it hangs up */
    HANGUP_CHANNEL(chan, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &expected_one, 2);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, ast_bridge_basic_new(), ast_bridge_depart(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_lock, ast_channel_unlock, ast_setstate(), AST_STATE_UP, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, COPY_IDS, CREATE_ALICE_CHANNEL, debug_cdr_config, do_sleep(), EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_bridge_destroy(), safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [19/24]

AST_TEST_DEFINE

(

test_cdr_single_multiparty_bridge

)

Definition at line 1009 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_alice, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_bob, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_charlie, NULL, safe_channel_release);
    RAII_VAR(struct ast_bridge *, bridge, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct timespec to_sleep = {1, 0};
 
    struct ast_party_caller caller_alice = ALICE_CALLERID;
    struct ast_party_caller caller_bob = BOB_CALLERID;
    struct ast_party_caller caller_charlie = CHARLIE_CALLERID;
    struct ast_cdr charlie_expected = {
        .clid = "\"Charlie\" <300>",
        .src = "300",
        .dst = "300",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Charlie",
        .lastapp = "Bridge",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "300",
    };
    struct ast_cdr bob_expected = {
        .clid = "\"Bob\" <200>",
        .src = "200",
        .dst = "200",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Bob",
        .dstchannel = CHANNEL_TECH_NAME "/Charlie",
        .lastapp = "Bridge",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "200",
        .peeraccount = "300",
        .next = &charlie_expected,
    };
    struct ast_cdr alice_expected_two = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Charlie",
        .lastapp = "Bridge",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "300",
        .next = &bob_expected,
    };
    struct ast_cdr alice_expected_one = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Bridge",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "200",
        .next = &alice_expected_two,
    };
 
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test cdrs for a single party entering/leaving a multi-party bridge";
        info->description =
            "Test the properties of a CDR for a call that is\n"
            "answered, enters a bridge, and leaves it. A total of three\n"
            "parties perform this action.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
    SWAP_CONFIG(config, debug_cdr_config);
    CREATE_ALICE_CHANNEL(chan_alice, &caller_alice, &alice_expected_one);
    COPY_IDS(chan_alice, &alice_expected_two);
    CREATE_BOB_CHANNEL(chan_bob, &caller_bob, &bob_expected);
    ast_copy_string(bob_expected.linkedid, ast_channel_linkedid(chan_alice), sizeof(bob_expected.linkedid));
    CREATE_CHARLIE_CHANNEL(chan_charlie, &caller_charlie, &charlie_expected);
    ast_copy_string(charlie_expected.linkedid, ast_channel_linkedid(chan_alice), sizeof(charlie_expected.linkedid));
 
    ast_channel_lock(chan_alice);
    EMULATE_APP_DATA(chan_alice, 1, "Answer", "");
    ast_setstate(chan_alice, AST_STATE_UP);
    EMULATE_APP_DATA(chan_alice, 2, "Bridge", "");
    ast_channel_unlock(chan_alice);
 
    bridge = ast_bridge_basic_new();
    ast_test_validate(test, bridge != NULL);
    do_sleep(&to_sleep);
 
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_alice, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
 
    ast_channel_lock(chan_bob);
    EMULATE_APP_DATA(chan_bob, 1, "Answer", "");
    ast_setstate(chan_bob, AST_STATE_UP);
    EMULATE_APP_DATA(chan_bob, 2, "Bridge", "");
    ast_channel_unlock(chan_bob);
    do_sleep(&to_sleep);
 
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_bob, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
 
    do_sleep(&to_sleep);
 
    ast_channel_lock(chan_charlie);
    EMULATE_APP_DATA(chan_charlie, 1, "Answer", "");
    ast_setstate(chan_charlie, AST_STATE_UP);
    EMULATE_APP_DATA(chan_charlie, 2, "Bridge", "");
    ast_channel_unlock(chan_charlie);
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_charlie, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
 
    do_sleep(&to_sleep);
 
    ast_bridge_depart(chan_alice);
    ast_bridge_depart(chan_bob);
    ast_bridge_depart(chan_charlie);
 
    HANGUP_CHANNEL(chan_alice, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_bob, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_charlie, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &alice_expected_one, 4);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, ast_bridge_basic_new(), ast_bridge_depart(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_linkedid(), ast_channel_lock, ast_channel_unlock, ast_copy_string(), ast_setstate(), AST_STATE_UP, AST_TEST_NOT_RUN, BOB_CALLERID, CHANNEL_TECH_NAME, CHARLIE_CALLERID, ast_cdr::clid, config, COPY_IDS, CREATE_ALICE_CHANNEL, CREATE_BOB_CHANNEL, CREATE_CHARLIE_CHANNEL, debug_cdr_config, do_sleep(), EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_bridge_destroy(), safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [20/24]

AST_TEST_DEFINE

(

test_cdr_single_party

)

Definition at line 633 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = "",
        .lastapp = "VoiceMailMain",
        .lastdata = "1",
        .billsec = 1,
    .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test cdrs for a single party";
        info->description =
            "Test the properties of a CDR for a call that is\n"
            "answered, but only involves a single channel";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
    SWAP_CONFIG(config, debug_cdr_config);
    CREATE_ALICE_CHANNEL(chan, &caller, &expected);
 
    ast_channel_lock(chan);
    EMULATE_APP_DATA(chan, 1, "Answer", "");
    ast_setstate(chan, AST_STATE_UP);
    EMULATE_APP_DATA(chan, 2, "VoiceMailMain", "1");
    ast_channel_unlock(chan);
 
    HANGUP_CHANNEL(chan, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_lock, ast_channel_unlock, ast_setstate(), AST_STATE_UP, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, debug_cdr_config, EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, and verify_mock_cdr_record().

AST_TEST_DEFINE() [21/24]

AST_TEST_DEFINE

(

test_cdr_single_twoparty_bridge_a

)

Definition at line 824 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_alice, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_bob, NULL, safe_channel_release);
    RAII_VAR(struct ast_bridge *, bridge, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct timespec to_sleep = {1, 0};
 
    struct ast_party_caller caller_alice = ALICE_CALLERID;
    struct ast_party_caller caller_bob = BOB_CALLERID;
    struct ast_cdr bob_expected = {
        .clid = "\"Bob\" <200>",
        .src = "200",
        .dst = "200",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Bridge",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "200",
    };
    struct ast_cdr alice_expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Bridge",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "200",
        .next = &bob_expected,
    };
 
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test cdrs for a single party entering/leaving a bridge";
        info->description =
            "Test the properties of a CDR for a call that is\n"
            "answered, enters a bridge, and leaves it. In this scenario, the\n"
            "Party A should answer the bridge first.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
    SWAP_CONFIG(config, debug_cdr_config);
    CREATE_ALICE_CHANNEL(chan_alice, &caller_alice, &alice_expected);
 
    CREATE_BOB_CHANNEL(chan_bob, &caller_bob, &bob_expected);
    ast_copy_string(bob_expected.linkedid, ast_channel_linkedid(chan_alice), sizeof(bob_expected.linkedid));
 
    ast_channel_lock(chan_alice);
    EMULATE_APP_DATA(chan_alice, 1, "Answer", "");
    ast_setstate(chan_alice, AST_STATE_UP);
    EMULATE_APP_DATA(chan_alice, 2, "Bridge", "");
    ast_channel_unlock(chan_alice);
 
    bridge = ast_bridge_basic_new();
    ast_test_validate(test, bridge != NULL);
 
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_alice, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
 
    ast_channel_lock(chan_bob);
    EMULATE_APP_DATA(chan_bob, 1, "Answer", "");
    ast_setstate(chan_bob, AST_STATE_UP);
    EMULATE_APP_DATA(chan_bob, 2, "Bridge", "");
    ast_channel_unlock(chan_bob);
 
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_bob, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
 
    ast_bridge_depart(chan_alice);
    ast_bridge_depart(chan_bob);
 
    HANGUP_CHANNEL(chan_alice, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_bob, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &alice_expected, 2);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, ast_bridge_basic_new(), ast_bridge_depart(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_linkedid(), ast_channel_lock, ast_channel_unlock, ast_copy_string(), ast_setstate(), AST_STATE_UP, AST_TEST_NOT_RUN, BOB_CALLERID, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, CREATE_BOB_CHANNEL, debug_cdr_config, do_sleep(), EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_bridge_destroy(), safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [22/24]

AST_TEST_DEFINE

(

test_cdr_single_twoparty_bridge_b

)

Definition at line 916 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan_alice, NULL, safe_channel_release);
    RAII_VAR(struct ast_channel *, chan_bob, NULL, safe_channel_release);
    RAII_VAR(struct ast_bridge *, bridge, NULL, safe_bridge_destroy);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
    struct timespec to_sleep = {1, 0};
 
    struct ast_party_caller caller_alice = ALICE_CALLERID;
    struct ast_party_caller caller_bob = BOB_CALLERID;
    struct ast_cdr bob_expected = {
        .clid = "\"Bob\" <200>",
        .src = "200",
        .dst = "200",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Bridge",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "200",
    };
    struct ast_cdr alice_expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .dstchannel = CHANNEL_TECH_NAME "/Bob",
        .lastapp = "Bridge",
        .billsec = 1,
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_ANSWERED,
        .accountcode = "100",
        .peeraccount = "200",
        .next = &bob_expected,
    };
 
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test cdrs for a single party entering/leaving a bridge";
        info->description =
            "Test the properties of a CDR for a call that is\n"
            "answered, enters a bridge, and leaves it. In this scenario, the\n"
            "Party B should answer the bridge first.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
    SWAP_CONFIG(config, debug_cdr_config);
    CREATE_ALICE_CHANNEL(chan_alice, &caller_alice, &alice_expected);
 
    CREATE_BOB_CHANNEL(chan_bob, &caller_bob, &bob_expected);
    ast_copy_string(bob_expected.linkedid, ast_channel_linkedid(chan_alice), sizeof(bob_expected.linkedid));
 
    ast_channel_unlock(chan_alice);
    EMULATE_APP_DATA(chan_alice, 1, "Answer", "");
    ast_setstate(chan_alice, AST_STATE_UP);
    EMULATE_APP_DATA(chan_alice, 2, "Bridge", "");
    ast_channel_unlock(chan_alice);
 
    bridge = ast_bridge_basic_new();
    ast_test_validate(test, bridge != NULL);
 
    ast_channel_lock(chan_bob);
    EMULATE_APP_DATA(chan_bob, 1, "Answer", "");
    ast_setstate(chan_bob, AST_STATE_UP);
    EMULATE_APP_DATA(chan_bob, 2, "Bridge", "");
    ast_channel_unlock(chan_bob);
    do_sleep(&to_sleep);
 
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_bob, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
 
    ast_test_validate(test, !ast_bridge_impart(bridge, chan_alice, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE));
    do_sleep(&to_sleep);
 
    ast_bridge_depart(chan_alice);
    ast_bridge_depart(chan_bob);
 
    HANGUP_CHANNEL(chan_alice, AST_CAUSE_NORMAL);
    HANGUP_CHANNEL(chan_bob, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &alice_expected, 2);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, ast_bridge_basic_new(), ast_bridge_depart(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_CAUSE_NORMAL, AST_CDR_ANSWERED, ast_channel_linkedid(), ast_channel_lock, ast_channel_unlock, ast_copy_string(), ast_setstate(), AST_STATE_UP, AST_TEST_NOT_RUN, BOB_CALLERID, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, CREATE_BOB_CHANNEL, debug_cdr_config, do_sleep(), EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_bridge_destroy(), safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, to_sleep, and verify_mock_cdr_record().

AST_TEST_DEFINE() [23/24]

AST_TEST_DEFINE

(

test_cdr_unanswered_inbound_call

)

Definition at line 435 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = ALICE_CALLERID;
    struct ast_cdr expected = {
        .clid = "\"Alice\" <100>",
        .src = "100",
        .dst = "100",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .lastapp = "Wait",
        .lastdata = "1",
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_NOANSWER,
        .accountcode = "100",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test inbound unanswered calls";
        info->description =
            "Test the properties of a CDR for a call that is\n"
            "inbound to Asterisk, executes some dialplan, but\n"
            "is never answered.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, unanswered_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan, &caller, &expected);
 
    EMULATE_APP_DATA(chan, 1, "Wait", "1");
 
    HANGUP_CHANNEL(chan, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ALICE_CALLERID, ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_NORMAL, AST_CDR_NOANSWER, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, EMULATE_APP_DATA, HANGUP_CHANNEL, NULL, RAII_VAR, result, safe_channel_release(), ast_cdr::start, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, unanswered_cdr_config, and verify_mock_cdr_record().

AST_TEST_DEFINE() [24/24]

AST_TEST_DEFINE

(

test_cdr_unanswered_outbound_call

)

Definition at line 483 of file test_cdr.c.

{
    RAII_VAR(struct ast_channel *, chan, NULL, safe_channel_release);
    RAII_VAR(struct ast_cdr_config *, config, ao2_alloc(sizeof(*config), NULL),
            ao2_cleanup);
 
    struct ast_party_caller caller = {
            .id.name.str = "",
            .id.name.valid = 1,
            .id.number.str = "",
            .id.number.valid = 1, };
    struct ast_cdr expected = {
        .clid = "\"\" <>",
        .dst = "s",
        .dcontext = "default",
        .channel = CHANNEL_TECH_NAME "/Alice",
        .lastapp = "AppDial",
        .lastdata = "(Outgoing Line)",
        .amaflags = AST_AMA_DOCUMENTATION,
        .disposition = AST_CDR_NOANSWER,
        .accountcode = "100",
    };
    enum ast_test_result_state result = AST_TEST_NOT_RUN;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = __func__;
        info->category = TEST_CATEGORY;
        info->summary = "Test outbound unanswered calls";
        info->description =
            "Test the properties of a CDR for a call that is\n"
            "outbound to Asterisk but is never answered.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    SWAP_CONFIG(config, unanswered_cdr_config);
 
    CREATE_ALICE_CHANNEL(chan, &caller, &expected);
 
    ast_channel_exten_set(chan, "s");
    ast_channel_context_set(chan, "default");
    ast_set_flag(ast_channel_flags(chan), AST_FLAG_ORIGINATED);
    EMULATE_APP_DATA(chan, 0, "AppDial", "(Outgoing Line)");
    HANGUP_CHANNEL(chan, AST_CAUSE_NORMAL);
 
    result = verify_mock_cdr_record(test, &expected, 1);
 
    return result;
}

References ao2_alloc, ao2_cleanup, AST_AMA_DOCUMENTATION, AST_CAUSE_NORMAL, AST_CDR_NOANSWER, ast_channel_context_set(), ast_channel_exten_set(), ast_channel_flags(), AST_FLAG_ORIGINATED, ast_set_flag, AST_TEST_NOT_RUN, CHANNEL_TECH_NAME, ast_cdr::clid, config, CREATE_ALICE_CHANNEL, EMULATE_APP_DATA, HANGUP_CHANNEL, ast_party_caller::id, ast_party_id::name, NULL, RAII_VAR, result, safe_channel_release(), ast_cdr::start, ast_party_name::str, SWAP_CONFIG, TEST_CATEGORY, TEST_EXECUTE, TEST_INIT, unanswered_cdr_config, and verify_mock_cdr_record().

clear_mock_cdr_backend()

static void clear_mock_cdr_backend ( void  )

static

Definition at line 169 of file test_cdr.c.

{
    struct test_cdr_entry *cdr_wrapper;
 
    AST_LIST_LOCK(&actual_cdr_entries);
    while ((cdr_wrapper = AST_LIST_REMOVE_HEAD(&actual_cdr_entries, list))) {
        ast_cdr_free(cdr_wrapper->cdr);
        ast_free(cdr_wrapper);
    }
    global_mock_cdr_count = 0;
    AST_LIST_UNLOCK(&actual_cdr_entries);
}

References actual_cdr_entries, ast_cdr_free(), ast_free, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, test_cdr_entry::cdr, global_mock_cdr_count, and test_cdr_entry::list.

Referenced by test_cdr_cleanup_cb(), test_cdr_init_cb(), and unload_module().

do_sleep()

static void do_sleep ( struct timespec *  to_sleep )

static

Definition at line 387 of file test_cdr.c.

{
    while ((nanosleep(to_sleep, to_sleep) == -1) && (errno == EINTR)) {
    }
}

References errno, and to_sleep.

load_module()

static int load_module ( void  )

static

Definition at line 2585 of file test_cdr.c.

{
    ast_cond_init(&mock_cdr_cond, NULL);
 
    AST_TEST_REGISTER(test_cdr_channel_creation);
    AST_TEST_REGISTER(test_cdr_unanswered_inbound_call);
    AST_TEST_REGISTER(test_cdr_unanswered_outbound_call);
 
    AST_TEST_REGISTER(test_cdr_single_party);
    AST_TEST_REGISTER(test_cdr_single_bridge);
    AST_TEST_REGISTER(test_cdr_single_bridge_continue);
    AST_TEST_REGISTER(test_cdr_single_twoparty_bridge_a);
    AST_TEST_REGISTER(test_cdr_single_twoparty_bridge_b);
    AST_TEST_REGISTER(test_cdr_single_multiparty_bridge);
 
    AST_TEST_REGISTER(test_cdr_outbound_bridged_call);
 
    AST_TEST_REGISTER(test_cdr_dial_unanswered);
    AST_TEST_REGISTER(test_cdr_dial_congestion);
    AST_TEST_REGISTER(test_cdr_dial_busy);
    AST_TEST_REGISTER(test_cdr_dial_unavailable);
    AST_TEST_REGISTER(test_cdr_dial_caller_cancel);
    AST_TEST_REGISTER(test_cdr_dial_parallel_failed);
    AST_TEST_REGISTER(test_cdr_dial_answer_no_bridge);
    AST_TEST_REGISTER(test_cdr_dial_answer_twoparty_bridge_a);
    AST_TEST_REGISTER(test_cdr_dial_answer_twoparty_bridge_b);
    AST_TEST_REGISTER(test_cdr_dial_answer_multiparty);
 
    AST_TEST_REGISTER(test_cdr_park);
 
    AST_TEST_REGISTER(test_cdr_fields);
    AST_TEST_REGISTER(test_cdr_no_reset_cdr);
    AST_TEST_REGISTER(test_cdr_fork_cdr);
 
    ast_test_register_init(TEST_CATEGORY, test_cdr_init_cb);
    ast_test_register_cleanup(TEST_CATEGORY, test_cdr_cleanup_cb);
 
    ast_channel_register(&test_cdr_chan_tech);
    ast_cdr_register(MOCK_CDR_BACKEND, "Mock CDR backend", mock_cdr_backend_cb);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ast_cdr_register(), ast_channel_register(), ast_cond_init, AST_MODULE_LOAD_SUCCESS, AST_TEST_REGISTER, MOCK_CDR_BACKEND, mock_cdr_backend_cb(), mock_cdr_cond, NULL, ast_cdr::start, TEST_CATEGORY, test_cdr_chan_tech, test_cdr_cleanup_cb(), and test_cdr_init_cb().

mock_cdr_backend_cb()

static int mock_cdr_backend_cb ( struct ast_cdr *  cdr )

static

Definition at line 116 of file test_cdr.c.

{
    struct ast_cdr *cdr_copy, *cdr_prev = NULL;
    struct ast_cdr *mock_cdr = NULL;
    struct test_cdr_entry *cdr_wrapper;
 
    cdr_wrapper = ast_calloc(1, sizeof(*cdr_wrapper));
    if (!cdr_wrapper) {
        return -1;
    }
 
    for (; cdr; cdr = cdr->next) {
        struct ast_var_t *var_entry, *var_copy;
 
        cdr_copy = ast_calloc(1, sizeof(*cdr_copy));
        if (!cdr_copy) {
            return -1;
        }
        *cdr_copy = *cdr;
        cdr_copy->varshead.first = NULL;
        cdr_copy->varshead.last = NULL;
        cdr_copy->next = NULL;
 
        AST_LIST_TRAVERSE(&cdr->varshead, var_entry, entries) {
            var_copy = ast_var_assign(var_entry->name, var_entry->value);
            if (!var_copy) {
                return -1;
            }
            AST_LIST_INSERT_TAIL(&cdr_copy->varshead, var_copy, entries);
        }
 
        if (!mock_cdr) {
            mock_cdr = cdr_copy;
        }
        if (cdr_prev) {
            cdr_prev->next = cdr_copy;
        }
        cdr_prev = cdr_copy;
    }
    cdr_wrapper->cdr = mock_cdr;
 
    AST_LIST_LOCK(&actual_cdr_entries);
    AST_LIST_INSERT_TAIL(&actual_cdr_entries, cdr_wrapper, list);
    global_mock_cdr_count++;
    ast_cond_signal(&mock_cdr_cond);
    AST_LIST_UNLOCK(&actual_cdr_entries);
 
    return 0;
}

References actual_cdr_entries, ast_calloc, ast_cond_signal, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_var_assign, test_cdr_entry::cdr, ast_var_t::entries, varshead::first, global_mock_cdr_count, varshead::last, mock_cdr_cond, ast_var_t::name, ast_cdr::next, NULL, ast_cdr::start, ast_var_t::value, and ast_cdr::varshead.

Referenced by load_module().

safe_bridge_destroy()

static void safe_bridge_destroy ( struct ast_bridge *  bridge )

static

Definition at line 379 of file test_cdr.c.

{
    if (!bridge) {
        return;
    }
    ast_bridge_destroy(bridge, 0);
}

References ast_bridge_destroy().

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

safe_channel_release()

static void safe_channel_release ( struct ast_channel *  chan )

static

Definition at line 371 of file test_cdr.c.

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

References ast_channel_release().

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

test_cdr_cleanup_cb()

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

static

Definition at line 2534 of file test_cdr.c.

{
    /* Restore the real config */
    ast_cdr_set_config(saved_config);
    ao2_cleanup(saved_config);
    saved_config = NULL;
    clear_mock_cdr_backend();
 
    return 0;
}

References ao2_cleanup, ast_cdr_set_config(), clear_mock_cdr_backend(), NULL, and saved_config.

Referenced by load_module().

test_cdr_init_cb()

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

static

Definition at line 2522 of file test_cdr.c.

{
    /* Back up the real config */
    saved_config = ast_cdr_get_config();
    clear_mock_cdr_backend();
    return 0;
}

References ast_cdr_get_config(), clear_mock_cdr_backend(), and saved_config.

Referenced by load_module().

unload_module()

static int unload_module ( void  )

static

Definition at line 2546 of file test_cdr.c.

{
    AST_TEST_UNREGISTER(test_cdr_channel_creation);
    AST_TEST_UNREGISTER(test_cdr_unanswered_inbound_call);
    AST_TEST_UNREGISTER(test_cdr_unanswered_outbound_call);
 
    AST_TEST_UNREGISTER(test_cdr_single_party);
    AST_TEST_UNREGISTER(test_cdr_single_bridge);
    AST_TEST_UNREGISTER(test_cdr_single_bridge_continue);
    AST_TEST_UNREGISTER(test_cdr_single_twoparty_bridge_a);
    AST_TEST_UNREGISTER(test_cdr_single_twoparty_bridge_b);
    AST_TEST_UNREGISTER(test_cdr_single_multiparty_bridge);
 
    AST_TEST_UNREGISTER(test_cdr_outbound_bridged_call);
 
    AST_TEST_UNREGISTER(test_cdr_dial_unanswered);
    AST_TEST_UNREGISTER(test_cdr_dial_congestion);
    AST_TEST_UNREGISTER(test_cdr_dial_busy);
    AST_TEST_UNREGISTER(test_cdr_dial_unavailable);
    AST_TEST_UNREGISTER(test_cdr_dial_caller_cancel);
    AST_TEST_UNREGISTER(test_cdr_dial_parallel_failed);
    AST_TEST_UNREGISTER(test_cdr_dial_answer_no_bridge);
    AST_TEST_UNREGISTER(test_cdr_dial_answer_twoparty_bridge_a);
    AST_TEST_UNREGISTER(test_cdr_dial_answer_twoparty_bridge_b);
    AST_TEST_UNREGISTER(test_cdr_dial_answer_multiparty);
 
    AST_TEST_UNREGISTER(test_cdr_park);
 
    AST_TEST_UNREGISTER(test_cdr_fields);
    AST_TEST_UNREGISTER(test_cdr_no_reset_cdr);
    AST_TEST_UNREGISTER(test_cdr_fork_cdr);
 
    ast_cdr_unregister(MOCK_CDR_BACKEND);
    ast_channel_unregister(&test_cdr_chan_tech);
    clear_mock_cdr_backend();
 
    return 0;
}

References ast_cdr_unregister(), ast_channel_unregister(), AST_TEST_UNREGISTER, clear_mock_cdr_backend(), MOCK_CDR_BACKEND, ast_cdr::start, and test_cdr_chan_tech.

verify_mock_cdr_record()

static enum ast_test_result_state verify_mock_cdr_record ( struct ast_test *  test, struct ast_cdr *  expected, int  record  )

static

Definition at line 310 of file test_cdr.c.

{
    struct ast_cdr *actual = NULL;
    struct test_cdr_entry *cdr_wrapper;
    int count = 0;
    struct timeval wait_now = ast_tvnow();
    struct timespec wait_time = { .tv_sec = wait_now.tv_sec + 5, .tv_nsec = wait_now.tv_usec * 1000 };
    enum ast_test_result_state res = AST_TEST_PASS;
 
    while (count < record) {
        AST_LIST_LOCK(&actual_cdr_entries);
        if (global_mock_cdr_count < record) {
            ast_cond_timedwait(&mock_cdr_cond, &actual_cdr_entries.lock, &wait_time);
        }
        cdr_wrapper = AST_LIST_REMOVE_HEAD(&actual_cdr_entries, list);
        AST_LIST_UNLOCK(&actual_cdr_entries);
 
        if (!cdr_wrapper) {
            ast_test_status_update(test, "Unable to find actual CDR record at %d\n", count);
            return AST_TEST_FAIL;
        }
        actual = cdr_wrapper->cdr;
 
        if (!expected && actual) {
            ast_test_status_update(test, "CDRs recorded where no record expected\n");
            return AST_TEST_FAIL;
        }
        ast_test_debug(test, "Verifying expected record %s, %s\n",
            expected->channel, S_OR(expected->dstchannel, "<none>"));
        VERIFY_STRING_FIELD(accountcode, actual, expected);
        VERIFY_NUMERIC_FIELD(amaflags, actual, expected);
        VERIFY_STRING_FIELD(channel, actual, expected);
        VERIFY_STRING_FIELD(clid, actual, expected);
        VERIFY_STRING_FIELD(dcontext, actual, expected);
        VERIFY_NUMERIC_FIELD(disposition, actual, expected);
        VERIFY_STRING_FIELD(dst, actual, expected);
        VERIFY_STRING_FIELD(dstchannel, actual, expected);
        VERIFY_STRING_FIELD(lastapp, actual, expected);
        VERIFY_STRING_FIELD(lastdata, actual, expected);
        VERIFY_STRING_FIELD(linkedid, actual, expected);
        VERIFY_STRING_FIELD(peeraccount, actual, expected);
        VERIFY_STRING_FIELD(src, actual, expected);
        VERIFY_STRING_FIELD(uniqueid, actual, expected);
        VERIFY_STRING_FIELD(userfield, actual, expected);
        VERIFY_TIME_VALUE(start, actual);
        VERIFY_TIME_VALUE(end, actual);
        /* Note: there's no way we can really calculate a duration or
         * billsec - the unit tests are too short. However, if billsec is
         * non-zero in the expected, then make sure we have an answer time
         */
        if (expected->billsec) {
            VERIFY_TIME_VALUE(answer, actual);
        }
        ast_test_debug(test, "Finished expected record %s, %s\n",
                expected->channel, S_OR(expected->dstchannel, "<none>"));
        expected = expected->next;
        ++count;
    }
    return res;
}

References accountcode, actual_cdr_entries, amaflags, answer(), ast_cond_timedwait, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_test_debug, AST_TEST_FAIL, AST_TEST_PASS, ast_test_status_update, ast_tvnow(), ast_cdr::billsec, test_cdr_entry::cdr, ast_cdr::channel, ast_cdr::dstchannel, end, global_mock_cdr_count, mock_cdr_cond, ast_cdr::next, NULL, S_OR, VERIFY_NUMERIC_FIELD, VERIFY_STRING_FIELD, and VERIFY_TIME_VALUE.

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

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "CDR unit tests" , .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 2628 of file test_cdr.c.

[struct]

struct { ... } actual_cdr_entries

A linked list of received CDR entries from the engine.

Referenced by clear_mock_cdr_backend(), mock_cdr_backend_cb(), and verify_mock_cdr_record().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2628 of file test_cdr.c.

congestion_cdr_config

struct ast_cdr_config congestion_cdr_config

static

Initial value:

= {
    .settings.flags = CDR_ENABLED | CDR_CHANNEL_DEFAULT_ENABLED | CDR_UNANSWERED | CDR_DEBUG | CDR_CONGESTION,
}

A configuration suitable for CDRs with congestion enabled.

Definition at line 71 of file test_cdr.c.

                                                     {
    .settings.flags = CDR_ENABLED | CDR_CHANNEL_DEFAULT_ENABLED | CDR_UNANSWERED | CDR_DEBUG | CDR_CONGESTION,
};

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

debug_cdr_config

struct ast_cdr_config debug_cdr_config

static

Initial value:

= {
    .settings.flags = CDR_ENABLED | CDR_CHANNEL_DEFAULT_ENABLED | CDR_DEBUG,
}

A configuration suitable for 'normal' CDRs.

Definition at line 61 of file test_cdr.c.

                                                {
    .settings.flags = CDR_ENABLED | CDR_CHANNEL_DEFAULT_ENABLED | CDR_DEBUG,
};

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

first

struct test_cdr_entry* first

Definition at line 85 of file test_cdr.c.

global_mock_cdr_count

int global_mock_cdr_count

static

The number of CDRs the mock backend has received.

Definition at line 102 of file test_cdr.c.

Referenced by clear_mock_cdr_backend(), mock_cdr_backend_cb(), and verify_mock_cdr_record().

last

struct test_cdr_entry* last

Definition at line 85 of file test_cdr.c.

lock

ast_mutex_t lock

Definition at line 85 of file test_cdr.c.

mock_cdr_cond

ast_cond_t mock_cdr_cond

static

The Mock CDR backend condition wait.

Definition at line 88 of file test_cdr.c.

Referenced by load_module(), mock_cdr_backend_cb(), and verify_mock_cdr_record().

saved_config

struct ast_cdr_config* saved_config

static

A placeholder for Asterisk's 'real' CDR configuration.

Definition at line 58 of file test_cdr.c.

Referenced by test_cdr_cleanup_cb(), and test_cdr_init_cb().

test_cdr_chan_tech

struct ast_channel_tech test_cdr_chan_tech

static

Initial value:

= {
    .type = CHANNEL_TECH_NAME,
    .description = "Mock channel technology for CDR tests",
}

A channel technology used for the unit tests.

Definition at line 91 of file test_cdr.c.

                                                    {
    .type = CHANNEL_TECH_NAME,
    .description = "Mock channel technology for CDR tests",
};

Referenced by load_module(), and unload_module().

unanswered_cdr_config

struct ast_cdr_config unanswered_cdr_config

static

Initial value:

= {
    .settings.flags = CDR_ENABLED | CDR_CHANNEL_DEFAULT_ENABLED | CDR_UNANSWERED | CDR_DEBUG,
}

A configuration suitable for CDRs with unanswered records.

Definition at line 66 of file test_cdr.c.

                                                     {
    .settings.flags = CDR_ENABLED | CDR_CHANNEL_DEFAULT_ENABLED | CDR_UNANSWERED | CDR_DEBUG,
};

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