test_abstract_jb.c File Reference

Abstract Jitterbuffer Tests. More...

#include "asterisk.h"
#include "asterisk/utils.h"
#include "asterisk/module.h"
#include "asterisk/test.h"
#include "asterisk/abstract_jb.h"
#include "asterisk/frame.h"
#include "asterisk/format_cache.h"

Include dependency graph for test_abstract_jb.c:

Go to the source code of this file.

Macros
#define	DEFAULT_CONFIG_FLAGS   0
#define	DEFAULT_CONFIG_RESYNC_THRESHOLD   (DEFAULT_FRAME_MS) * 2
#define	DEFAULT_CONFIG_SIZE   (DEFAULT_FRAME_MS) * 10
#define	DEFAULT_CONFIG_TARGET_EXTRA   -1
#define	DEFAULT_FRAME_MS   160
#define	INT_TEST(actual, expected)
#define	LONG_INT_TEST(actual, expected)
#define	MAKE_DEFAULT_CONFIG(conf, impl)
#define	OBTAIN_JITTERBUFFER_IMPL(impl, ast_jb_type, literal_name)
#define	STRING_TEST(actual, expected)
#define	STRINGIFY_TESTNAME(test_name)   TEST_NAME2(test_name)
#define	test_create_nominal(type_name, literal_type_name)
#define	TEST_NAME(type_name, specifier)   type_name ## _ ## specifier
#define	TEST_NAME2(test_name)   #test_name
#define	test_put(type_name, literal_type_name)
#define	test_put_first(type_name, literal_type_name)
#define	test_put_out_of_order(type_name, literal_type_name, synch_limit)
#define	test_put_overflow(type_name, literal_type_name, overflow_limit)
#define	UINT_TEST(actual, expected)
#define	VERIFY_FRAME(actual, expected)

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static struct ast_frame *	create_test_frame (long timestamp, int seqno)
static void	dispose_jitterbuffer (struct ast_jb *jb)
static int	load_module (void)
	test_create_nominal (test_put_first(AST_JB_ADAPTIVE, test_put_first("adaptive")

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Abstract JitterBuffer API 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 const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_jb	default_jb

Detailed Description

Abstract Jitterbuffer Tests.

Author

Matt Jordan <mjordan@digium.com> 

Tests the abstract jitter buffer API. This tests both adaptive and fixed jitter buffers. Functions defined in abstract_jb that are not part of the abstract jitter buffer API are not tested by this unit test.

Definition in file test_abstract_jb.c.

Macro Definition Documentation

DEFAULT_CONFIG_FLAGS

#define DEFAULT_CONFIG_FLAGS   0

Definition at line 47 of file test_abstract_jb.c.

DEFAULT_CONFIG_RESYNC_THRESHOLD

#define DEFAULT_CONFIG_RESYNC_THRESHOLD   (DEFAULT_FRAME_MS) * 2

Definition at line 49 of file test_abstract_jb.c.

DEFAULT_CONFIG_SIZE

#define DEFAULT_CONFIG_SIZE   (DEFAULT_FRAME_MS) * 10

Definition at line 48 of file test_abstract_jb.c.

DEFAULT_CONFIG_TARGET_EXTRA

#define DEFAULT_CONFIG_TARGET_EXTRA   -1

Definition at line 50 of file test_abstract_jb.c.

DEFAULT_FRAME_MS

#define DEFAULT_FRAME_MS   160

Definition at line 46 of file test_abstract_jb.c.

INT_TEST

#define INT_TEST	(		actual,
			expected
	)

Value:

    do { \
    if ((actual) != (expected)) { \
        ast_test_status_update(test, #actual ": expected [%d]; actual [%d]\n", (expected), (actual)); \
        return AST_TEST_FAIL; \
    } } while (0)

Definition at line 109 of file test_abstract_jb.c.

                                      { \
    if ((actual) != (expected)) { \
        ast_test_status_update(test, #actual ": expected [%d]; actual [%d]\n", (expected), (actual)); \
        return AST_TEST_FAIL; \
    } } while (0)

LONG_INT_TEST

#define LONG_INT_TEST	(		actual,
			expected
	)

Value:

    do { \
    if ((actual) != (expected)) { \
        ast_test_status_update(test, #actual ": expected [%ld]; actual [%ld]\n", (long int)(expected), (long int)(actual)); \
        return AST_TEST_FAIL; \
    } } while (0)

Definition at line 100 of file test_abstract_jb.c.

                                           { \
    if ((actual) != (expected)) { \
        ast_test_status_update(test, #actual ": expected [%ld]; actual [%ld]\n", (long int)(expected), (long int)(actual)); \
        return AST_TEST_FAIL; \
    } } while (0)

MAKE_DEFAULT_CONFIG

#define MAKE_DEFAULT_CONFIG	(		conf,
			impl
	)

Definition at line 161 of file test_abstract_jb.c.

                                           { \
    (conf)->flags = DEFAULT_CONFIG_FLAGS; \
    strcpy((conf)->impl, (impl)->name); \
    (conf)->max_size = DEFAULT_CONFIG_SIZE; \
    (conf)->resync_threshold = DEFAULT_CONFIG_RESYNC_THRESHOLD; \
    (conf)->target_extra = DEFAULT_CONFIG_TARGET_EXTRA; \
    } while (0)

OBTAIN_JITTERBUFFER_IMPL

#define OBTAIN_JITTERBUFFER_IMPL	(		impl,
			ast_jb_type,
			literal_name
	)

Definition at line 147 of file test_abstract_jb.c.

                                                                     { \
    (impl) = ast_jb_get_impl((ast_jb_type)); \
    if (!(impl)) { \
        ast_test_status_update(test, "Error: no %s jitterbuffer defined\n", (literal_name)); \
        return AST_TEST_FAIL; \
    } \
    if (strcmp((impl)->name, (literal_name))) { \
        ast_test_status_update(test, "Error: requested %s jitterbuffer and received %s\n", (literal_name), (impl)->name); \
        return AST_TEST_FAIL; \
    } } while (0)

STRING_TEST

#define STRING_TEST	(		actual,
			expected
	)

Value:

    do { \
    if (strcmp((actual), (expected))) { \
        ast_test_status_update(test, #actual ": expected [%s]; actual [%s]\n", (expected), (actual)); \
        return AST_TEST_FAIL; \
    } } while (0)

Definition at line 127 of file test_abstract_jb.c.

                                         { \
    if (strcmp((actual), (expected))) { \
        ast_test_status_update(test, #actual ": expected [%s]; actual [%s]\n", (expected), (actual)); \
        return AST_TEST_FAIL; \
    } } while (0)

STRINGIFY_TESTNAME

#define STRINGIFY_TESTNAME

(

test_name

)

TEST_NAME2(test_name)

Definition at line 185 of file test_abstract_jb.c.

test_create_nominal

#define test_create_nominal	(		type_name,
			literal_type_name
	)

Definition at line 194 of file test_abstract_jb.c.

                                                                                                        {\
    RAII_VAR(struct ast_jb *, jb, &default_jb, dispose_jitterbuffer); \
    const struct ast_jb_impl *impl; \
    struct ast_jb_conf conf; \
\
    switch (cmd) { \
    case TEST_INIT: \
        info->name = STRINGIFY_TESTNAME(TEST_NAME(type_name, create)); \
        info->category = "/main/abstract_jb/"; \
        info->summary = "Test nominal creation of a " literal_type_name " jitterbuffer"; \
        info->description = \
            "Tests nominal creation of a " literal_type_name " jitterbuffer using the " \
            " jitterbuffer API."; \
        return AST_TEST_NOT_RUN; \
    case TEST_EXECUTE: \
        break; \
    } \
 \
    ast_test_status_update(test, "Executing " STRINGIFY_TESTNAME(TEST_NAME(type_name,  create))"...\n"); \
    OBTAIN_JITTERBUFFER_IMPL(impl, (type_name), (literal_type_name)); \
    MAKE_DEFAULT_CONFIG(&conf, impl); \
 \
    jb->jbobj = impl->create(&conf); \
    jb->impl = impl; \
    if (!jb->jbobj) { \
        ast_test_status_update(test, "Error: Failed to adaptive jitterbuffer\n"); \
        return AST_TEST_FAIL; \
    } \
 \
    return AST_TEST_PASS; \
}

TEST_NAME

#define TEST_NAME	(		type_name,
			specifier
	)		type_name ## _ ## specifier

Definition at line 182 of file test_abstract_jb.c.

TEST_NAME2

#define TEST_NAME2

(

test_name

)

#test_name

Definition at line 184 of file test_abstract_jb.c.

test_put

#define test_put	(		type_name,
			literal_type_name
	)

Definition at line 292 of file test_abstract_jb.c.

                                                                                          {\
    RAII_VAR(struct ast_jb *, jb, &default_jb, dispose_jitterbuffer); \
    const struct ast_jb_impl *impl; \
    struct ast_jb_conf conf; \
    struct ast_frame *expected_frame = NULL; \
    struct ast_frame *actual_frame = NULL; \
    int res; \
    long next; \
    int i; \
\
    switch (cmd) { \
    case TEST_INIT: \
        info->name = STRINGIFY_TESTNAME(TEST_NAME(type_name, put)); \
        info->category = "/main/abstract_jb/"; \
        info->summary = "Test putting frames onto a " literal_type_name " jitterbuffer"; \
        info->description = \
            "This tests putting multiple frames into a " literal_type_name " jitterbuffer"; \
        return AST_TEST_NOT_RUN; \
    case TEST_EXECUTE: \
        break; \
    } \
\
    ast_test_status_update(test, "Executing "STRINGIFY_TESTNAME(TEST_NAME(type_name, put))"...\n"); \
    OBTAIN_JITTERBUFFER_IMPL(impl, (type_name), (literal_type_name)); \
    MAKE_DEFAULT_CONFIG(&conf, impl); \
    jb->jbobj = impl->create(&conf); \
    jb->impl = impl; \
\
    expected_frame = create_test_frame(1000, 0); \
    res = jb->impl->put_first(jb->jbobj, \
        expected_frame, \
        1100); \
    if (res != AST_JB_IMPL_OK) { \
        ast_test_status_update(test, "Error: On first frame, got %d back from put_first (expected %d)\n", \
            res, AST_JB_IMPL_OK); \
        ast_frame_dtor(expected_frame); \
        return AST_TEST_FAIL; \
    } \
    for (i = 1; i < 10; i++) { \
        expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
        res = jb->impl->put(jb->jbobj, \
            expected_frame, \
            1100 + i * DEFAULT_FRAME_MS); \
        if (res != AST_JB_IMPL_OK) { \
            ast_test_status_update(test, "Error: On frame %d, got %d back from put (expected %d)\n", \
                i, res, AST_JB_IMPL_OK); \
            ast_frame_dtor(expected_frame); \
            return AST_TEST_FAIL; \
        } \
    } \
\
    for (i = 0; i < 10; i++) { \
        expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
        next = jb->impl->next(jb->jbobj); \
        res = jb->impl->get(jb->jbobj, &actual_frame, next, DEFAULT_FRAME_MS); \
        if (res != AST_JB_IMPL_OK) { \
            ast_test_status_update(test, "Error: failed to retrieve frame %i at time %ld\n", \
                i, next); \
            ast_frame_dtor(expected_frame); \
            return AST_TEST_FAIL; \
        } \
        VERIFY_FRAME(actual_frame, expected_frame); \
        ast_frame_dtor(expected_frame); \
        ast_frame_dtor(actual_frame); \
    } \
    return AST_TEST_PASS; \
}

test_put_first

#define test_put_first	(		type_name,
			literal_type_name
	)

Definition at line 233 of file test_abstract_jb.c.

                                                                                                       {\
    RAII_VAR(struct ast_jb *, jb, &default_jb, dispose_jitterbuffer); \
    const struct ast_jb_impl *impl; \
    struct ast_jb_conf conf; \
    RAII_VAR(struct ast_frame *, expected_frame, NULL, ast_frame_dtor); \
    RAII_VAR(struct ast_frame *, actual_frame, NULL, ast_frame_dtor); \
    int res; \
\
    switch (cmd) { \
    case TEST_INIT: \
        info->name = STRINGIFY_TESTNAME(TEST_NAME(type_name,  put_first)); \
        info->category = "/main/abstract_jb/"; \
        info->summary = "Test putting a frame into a " literal_type_name " jitterbuffer"; \
        info->description = \
            "This tests putting a single frame into a " literal_type_name " jitterbuffer " \
            "when the jitterbuffer is empty and verifying that it is indeed " \
            "the first frame on the jitterbuffer"; \
        return AST_TEST_NOT_RUN; \
    case TEST_EXECUTE: \
        break; \
    } \
\
    ast_test_status_update(test, "Executing " STRINGIFY_TESTNAME(TEST_NAME(type_name,  create))"...\n"); \
    OBTAIN_JITTERBUFFER_IMPL(impl, (type_name), (literal_type_name)); \
    MAKE_DEFAULT_CONFIG(&conf, impl); \
    jb->jbobj = impl->create(&conf); \
    jb->impl = impl; \
    if (!jb->jbobj) { \
        ast_test_status_update(test, "Error: Failed to adaptive jitterbuffer\n"); \
        return AST_TEST_FAIL; \
    } \
\
    expected_frame = create_test_frame(1000, 0); \
    res = jb->impl->put_first(jb->jbobj, \
        expected_frame, \
        1100); \
    if (res != AST_JB_IMPL_OK) { \
        ast_test_status_update(test, "Error: Got %d back from put_first (expected %d)\n", \
            res, AST_JB_IMPL_OK); \
        return AST_TEST_FAIL; \
    } \
\
    res = jb->impl->remove(jb->jbobj, &actual_frame); \
    if (!actual_frame || res != AST_JB_IMPL_OK) { \
        ast_test_status_update(test, "Error: failed to retrieve first frame\n"); \
        return AST_TEST_FAIL; \
    } \
    expected_frame = create_test_frame(1000, 0); \
    VERIFY_FRAME(actual_frame, expected_frame); \
    return AST_TEST_PASS; \
}

test_put_out_of_order

#define test_put_out_of_order	(		type_name,
			literal_type_name,
			synch_limit
	)

Definition at line 436 of file test_abstract_jb.c.

                                                                                                                                 {\
    RAII_VAR(struct ast_jb *, jb, &default_jb, dispose_jitterbuffer); \
    const struct ast_jb_impl *impl; \
    struct ast_jb_conf conf; \
    struct ast_frame *expected_frame = NULL; \
    struct ast_frame *actual_frame = NULL; \
    int res; \
    long next; \
    int i; \
\
    switch (cmd) { \
    case TEST_INIT: \
        info->name = STRINGIFY_TESTNAME(TEST_NAME(type_name, put_out_of_order)); \
        info->category = "/main/abstract_jb/"; \
        info->summary = "Test putting out of order frames onto a " literal_type_name " jitterbuffer"; \
        info->description = \
            "This tests putting multiple frames into a " literal_type_name " jitterbuffer " \
            "that arrive out of order.  Every 3rd frame is put in out of order."; \
        return AST_TEST_NOT_RUN; \
    case TEST_EXECUTE: \
        break; \
    } \
\
    ast_test_status_update(test, "Executing " STRINGIFY_TESTNAME(TEST_NAME(type_name, put_out_of_order)) "...\n"); \
    OBTAIN_JITTERBUFFER_IMPL(impl, (type_name), (literal_type_name)); \
    MAKE_DEFAULT_CONFIG(&conf, impl); \
    conf.resync_threshold = (synch_limit); \
    jb->jbobj = impl->create(&conf); \
    jb->impl = impl; \
\
    expected_frame = create_test_frame(1000, 0); \
    res = jb->impl->put_first(jb->jbobj, expected_frame, 1100); \
    if (res != AST_JB_IMPL_OK) { \
        ast_test_status_update(test, "Error: On first frame, got %d back from put_first (expected %d)\n", \
            res, AST_JB_IMPL_OK); \
        ast_frame_dtor(expected_frame); \
        return AST_TEST_FAIL; \
    } \
    for (i = 1; i <= 10; i++) { \
        if (i % 3 == 1 && i != 10) { \
            expected_frame = create_test_frame(1000 + ((i + 1) * DEFAULT_FRAME_MS), 0); \
        } else if (i % 3 == 2) { \
            expected_frame = create_test_frame(1000 + ((i - 1) * DEFAULT_FRAME_MS), 0); \
        } else { \
            expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
        } \
        res = jb->impl->put(jb->jbobj, \
            expected_frame, \
            1100 + i * DEFAULT_FRAME_MS); \
        if (res != AST_JB_IMPL_OK) { \
            ast_test_status_update(test, "Error: On frame %d, got %d back from put (expected %d)\n", \
                i, res, AST_JB_IMPL_OK); \
            ast_frame_dtor(expected_frame); \
            return AST_TEST_FAIL; \
        } \
    } \
\
    for (i = 0; i <= 10; i++) { \
        expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
        next = jb->impl->next(jb->jbobj); \
        res = jb->impl->get(jb->jbobj, &actual_frame, next, DEFAULT_FRAME_MS); \
        if (res != AST_JB_IMPL_OK) { \
            ast_test_status_update(test, "Error: failed to retrieve frame at %ld\n", \
                next); \
            ast_frame_dtor(expected_frame); \
            return AST_TEST_FAIL; \
        } \
        VERIFY_FRAME(actual_frame, expected_frame); \
        ast_frame_dtor(expected_frame); \
        ast_frame_dtor(actual_frame); \
        expected_frame = NULL; \
    } \
\
    return AST_TEST_PASS; \
}

test_put_overflow

#define test_put_overflow	(		type_name,
			literal_type_name,
			overflow_limit
	)

Definition at line 368 of file test_abstract_jb.c.

                                                                                                                            {\
    RAII_VAR(struct ast_jb *, jb, &default_jb, dispose_jitterbuffer); \
    const struct ast_jb_impl *impl; \
    struct ast_jb_conf conf; \
    RAII_VAR(struct ast_frame *, expected_frame, NULL, ast_frame_dtor); \
    int res; \
    int i; \
\
    switch (cmd) { \
    case TEST_INIT: \
        info->name = STRINGIFY_TESTNAME(TEST_NAME(type_name,  put_overflow)); \
        info->category = "/main/abstract_jb/"; \
        info->summary = "Test putting frames onto a " literal_type_name " jitterbuffer " \
            "that ends up overflowing the maximum allowed slots in the buffer"; \
        info->description = \
            "This tests putting multiple frames into a " literal_type_name " jitterbuffer " \
            "until the jitterbuffer overflows"; \
        return AST_TEST_NOT_RUN; \
    case TEST_EXECUTE: \
        break; \
    } \
\
    ast_test_status_update(test, "Executing "STRINGIFY_TESTNAME(TEST_NAME(type_name, put_overflow))"...\n"); \
    OBTAIN_JITTERBUFFER_IMPL(impl, (type_name), (literal_type_name)); \
    MAKE_DEFAULT_CONFIG(&conf, impl); \
    jb->jbobj = impl->create(&conf); \
    jb->impl = impl; \
\
    expected_frame = create_test_frame(1000, 0); \
    jb->impl->put_first(jb->jbobj, expected_frame, 1100); \
    for (i = 1; i <= (overflow_limit); i++) { \
        expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
        res = jb->impl->put(jb->jbobj, \
            expected_frame, \
            1100 + i * DEFAULT_FRAME_MS); \
        if (res != AST_JB_IMPL_OK) { \
            ast_test_status_update(test, "Error: On frame %d, got %d back from put (expected %d)\n", \
                i, res, AST_JB_IMPL_OK); \
            return AST_TEST_FAIL; \
        } \
    } \
\
    for (i = (overflow_limit)+1; i < (overflow_limit) + 5; i++) { \
        expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
        res = jb->impl->put(jb->jbobj, \
            expected_frame, \
            1100 + i * DEFAULT_FRAME_MS); \
        if (res != AST_JB_IMPL_DROP) { \
            expected_frame = NULL; \
            ast_test_status_update(test, "Error: On frame %d, got %d back from put (expected %d)\n", \
                i, res, AST_JB_IMPL_DROP); \
            return AST_TEST_FAIL; \
        } \
        ast_frfree(expected_frame); \
        expected_frame = NULL;\
    } \
\
    return AST_TEST_PASS; \
}

UINT_TEST

#define UINT_TEST	(		actual,
			expected
	)

Value:

    do { \
    if ((actual) != (expected)) { \
        ast_test_status_update(test, #actual ": expected [%u]; actual [%u]\n", (expected), (actual)); \
        return AST_TEST_FAIL; \
    } } while (0)

Definition at line 118 of file test_abstract_jb.c.

                                       { \
    if ((actual) != (expected)) { \
        ast_test_status_update(test, #actual ": expected [%u]; actual [%u]\n", (expected), (actual)); \
        return AST_TEST_FAIL; \
    } } while (0)

VERIFY_FRAME

#define VERIFY_FRAME	(		actual,
			expected
	)

Definition at line 136 of file test_abstract_jb.c.

                                          { \
    UINT_TEST((actual)->frametype, (expected)->frametype); \
    INT_TEST((actual)->seqno, (expected)->seqno); \
    LONG_INT_TEST((actual)->ts, (expected)->ts); \
    LONG_INT_TEST((actual)->len, (expected)->len); \
    STRING_TEST((actual)->src, (expected)->src); \
} while (0)

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 567 of file test_abstract_jb.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 567 of file test_abstract_jb.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 567 of file test_abstract_jb.c.

create_test_frame()

static struct ast_frame * create_test_frame ( long  timestamp, int  seqno  )

static

Definition at line 82 of file test_abstract_jb.c.

{
    struct ast_frame f = {0};
 
    f.subclass.format = ast_format_slin;
    f.frametype = AST_FRAME_VOICE;
    f.src = "TEST";
    f.ts = timestamp;
    f.len = DEFAULT_FRAME_MS;
    f.seqno = seqno;
 
    return ast_frisolate(&f);
}

References ast_format_slin, AST_FRAME_VOICE, ast_frisolate, DEFAULT_FRAME_MS, ast_frame_subclass::format, ast_frame::frametype, ast_frame::len, ast_frame::seqno, ast_frame::src, ast_frame::subclass, and ast_frame::ts.

dispose_jitterbuffer()

static void dispose_jitterbuffer ( struct ast_jb *  jb )

static

Definition at line 60 of file test_abstract_jb.c.

{
    if (!jb || !jb->impl || !jb->jbobj) {
        return;
    }
 
    jb->impl->empty_and_reset(jb->jbobj);
 
    jb->impl->destroy(jb->jbobj);
    jb->impl = NULL;
    jb->jbobj = NULL;
}

References ast_jb_impl::destroy, ast_jb_impl::empty_and_reset, ast_jb::impl, ast_jb::jbobj, and NULL.

load_module()

static int load_module ( void  )

static

Definition at line 550 of file test_abstract_jb.c.

{
    AST_TEST_REGISTER(TEST_NAME(AST_JB_ADAPTIVE, create));
    AST_TEST_REGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_first));
    AST_TEST_REGISTER(TEST_NAME(AST_JB_ADAPTIVE, put));
    AST_TEST_REGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_overflow));
    AST_TEST_REGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_out_of_order));
 
    AST_TEST_REGISTER(TEST_NAME(AST_JB_FIXED, create));
    AST_TEST_REGISTER(TEST_NAME(AST_JB_FIXED, put_first));
    AST_TEST_REGISTER(TEST_NAME(AST_JB_FIXED, put));
    AST_TEST_REGISTER(TEST_NAME(AST_JB_FIXED, put_overflow));
    AST_TEST_REGISTER(TEST_NAME(AST_JB_FIXED, put_out_of_order));
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_JB_ADAPTIVE, AST_JB_FIXED, AST_MODULE_LOAD_SUCCESS, AST_TEST_REGISTER, and TEST_NAME.

test_create_nominal()

test_create_nominal	(	test_put_first(	AST_JB_ADAPTIVE,
		test_put_first(	"adaptive"
	)

Definition at line 513 of file test_abstract_jb.c.

{
    AST_TEST_UNREGISTER(TEST_NAME(AST_JB_ADAPTIVE, create));
    AST_TEST_UNREGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_first));
    AST_TEST_UNREGISTER(TEST_NAME(AST_JB_ADAPTIVE, put));
    AST_TEST_UNREGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_overflow));
    AST_TEST_UNREGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_out_of_order));
 
    AST_TEST_UNREGISTER(TEST_NAME(AST_JB_FIXED, create));
    AST_TEST_UNREGISTER(TEST_NAME(AST_JB_FIXED, put_first));
    AST_TEST_UNREGISTER(TEST_NAME(AST_JB_FIXED, put));
    AST_TEST_UNREGISTER(TEST_NAME(AST_JB_FIXED, put_overflow));
    AST_TEST_UNREGISTER(TEST_NAME(AST_JB_FIXED, put_out_of_order));
 
    return 0;
}

References AST_JB_ADAPTIVE, AST_JB_FIXED, AST_TEST_UNREGISTER, and TEST_NAME.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Abstract JitterBuffer API 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 567 of file test_abstract_jb.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 567 of file test_abstract_jb.c.

default_jb

struct ast_jb default_jb

static

Initial value:

= {
    .impl = NULL,
    .jbobj = NULL
}

Definition at line 173 of file test_abstract_jb.c.

                                  {
    .impl = NULL,
    .jbobj = NULL
};