test_stream.c File Reference

Media Stream API Unit Tests. More...

#include "asterisk.h"
#include "asterisk/test.h"
#include "asterisk/module.h"
#include "asterisk/stream.h"
#include "asterisk/format.h"
#include "asterisk/format_cap.h"
#include "asterisk/format_cache.h"
#include "asterisk/channel.h"
#include "asterisk/uuid.h"

Include dependency graph for test_stream.c:

Go to the source code of this file.

Data Structures
struct	mock_channel_pvt

Macros
#define	topology_append_stream(topology, name, type, res, label)

Enumerations
enum	CHANNEL_READ_TYPE { CHANNEL_READ , CHANNEL_READ_STREAM }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (format_cap_from_stream_topology)
	AST_TEST_DEFINE (stream_create)
	AST_TEST_DEFINE (stream_create_no_name)
	AST_TEST_DEFINE (stream_metadata)
	AST_TEST_DEFINE (stream_read_multistream)
	AST_TEST_DEFINE (stream_read_non_multistream)
	AST_TEST_DEFINE (stream_set_formats)
	AST_TEST_DEFINE (stream_set_state)
	AST_TEST_DEFINE (stream_set_type)
	AST_TEST_DEFINE (stream_topology_append_stream)
	AST_TEST_DEFINE (stream_topology_change_request_from_application)
	AST_TEST_DEFINE (stream_topology_change_request_from_application_non_multistream)
	AST_TEST_DEFINE (stream_topology_change_request_from_channel)
	AST_TEST_DEFINE (stream_topology_change_request_from_channel_non_multistream)
	AST_TEST_DEFINE (stream_topology_channel_set)
	AST_TEST_DEFINE (stream_topology_clone)
	AST_TEST_DEFINE (stream_topology_create)
	AST_TEST_DEFINE (stream_topology_create_from_channel_nativeformats)
	AST_TEST_DEFINE (stream_topology_create_from_format_cap)
	AST_TEST_DEFINE (stream_topology_del_stream)
	AST_TEST_DEFINE (stream_topology_get_first_stream_by_type)
	AST_TEST_DEFINE (stream_topology_map_create)
	AST_TEST_DEFINE (stream_topology_set_stream)
	AST_TEST_DEFINE (stream_write_multistream)
	AST_TEST_DEFINE (stream_write_non_multistream)
static int	check_stream_positions (struct ast_test *test, const struct ast_stream_topology *topology)
static int	load_module (void)
static int	load_stream_readqueue (struct ast_channel *chan, int frames)
static struct ast_channel *	make_channel (struct ast_test *test, int streams, struct ast_channel_tech *tech)
static int	mock_channel_hangup (struct ast_channel *chan)
static int	mock_channel_indicate (struct ast_channel *chan, int condition, const void *data, size_t datalen)
static struct ast_frame *	mock_channel_read (struct ast_channel *chan)
static int	mock_channel_write (struct ast_channel *chan, struct ast_frame *fr)
static int	mock_channel_write_stream (struct ast_channel *chan, int stream_num, struct ast_frame *fr)
static struct ast_frame *	read_from_chan (enum CHANNEL_READ_TYPE rt, struct ast_channel *chan)
static enum ast_test_result_state	read_test (struct ast_test *test, struct ast_channel_tech *tech, enum CHANNEL_READ_TYPE rt, int streams, int frames, int frames_per_read, int expected_nulls)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Media Stream API test module" , .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 const struct ast_channel_tech	mock_channel_old_write_tech
static const struct ast_channel_tech	mock_channel_tech
static const struct ast_channel_tech	mock_channel_write_stream_tech
static const struct ast_channel_tech	mock_stream_channel_tech

Detailed Description

Media Stream API Unit Tests.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file test_stream.c.

Macro Definition Documentation

topology_append_stream

#define topology_append_stream	(		topology,
			name,
			type,
			res,
			label
	)

Definition at line 2162 of file test_stream.c.

       { \
        struct ast_stream *__stream = ast_stream_alloc((name), (type)); \
        ast_test_validate_cleanup(test, __stream, res, label); \
        if (ast_stream_topology_append_stream((topology), __stream) < 0) { \
            ast_stream_free(__stream); \
            res = AST_TEST_FAIL; \
            goto label;      \
        } \
    } while(0)

Enumeration Type Documentation

CHANNEL_READ_TYPE

enum CHANNEL_READ_TYPE

Enumerator
CHANNEL_READ
CHANNEL_READ_STREAM

Definition at line 1702 of file test_stream.c.

                       {
    CHANNEL_READ,
    CHANNEL_READ_STREAM
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2314 of file test_stream.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 2314 of file test_stream.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 2314 of file test_stream.c.

AST_TEST_DEFINE() [1/25]

AST_TEST_DEFINE

(

format_cap_from_stream_topology

)

Definition at line 2069 of file test_stream.c.

{
    RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
    RAII_VAR(struct ast_format_cap *, stream_caps, NULL, ao2_cleanup);
    struct ast_stream_topology *topology;
    struct ast_stream *stream;
    struct ast_format_cap *new_cap;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "format_cap_from_stream_topology";
        info->category = "/main/stream/";
        info->summary = "stream topology to format capabilities conversion test";
        info->description =
            "Test that converting a stream topology to format capabilities results in expected formats";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!caps) {
        ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_ulaw, 0)) {
        ast_test_status_update(test, "Failed to append ulaw format to capabilities\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_h264, 0)) {
        ast_test_status_update(test, "Failed to append h264 format to capabilities\n");
        return AST_TEST_FAIL;
    }
 
    topology = ast_stream_topology_create_from_format_cap(caps);
    if (!topology) {
        ast_test_status_update(test, "Failed to create a stream topology from format capabilities of ulaw and h264\n");
        return AST_TEST_FAIL;
    }
 
    /*
     * Append declined stream with formats that should not be included
     * in combined topology caps.
     */
    stream = ast_stream_alloc("audio", AST_MEDIA_TYPE_AUDIO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create an audio stream for testing stream topology\n");
        ast_stream_topology_free(topology);
        return AST_TEST_FAIL;
    }
    ast_stream_set_state(stream, AST_STREAM_STATE_REMOVED);
    new_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!new_cap) {
        ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
        ast_stream_free(stream);
        ast_stream_topology_free(topology);
        return AST_TEST_FAIL;
    }
    if (ast_format_cap_append(new_cap, ast_format_alaw, 0)) {
        ast_test_status_update(test, "Failed to append alaw format to capabilities\n");
        ao2_cleanup(new_cap);
        ast_stream_free(stream);
        ast_stream_topology_free(topology);
        return AST_TEST_FAIL;
    }
    ast_stream_set_formats(stream, new_cap);
    ao2_cleanup(new_cap);
    if (ast_stream_topology_append_stream(topology, stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(stream);
        ast_stream_topology_free(topology);
        return AST_TEST_FAIL;
    }
 
    stream_caps = ast_stream_topology_get_formats(topology);
    if (!stream_caps) {
        ast_test_status_update(test, "Failed to create a format capabilities from a stream topology\n");
        ast_stream_topology_free(topology);
        return AST_TEST_FAIL;
    }
 
    ast_stream_topology_free(topology);
 
    if (!ast_format_cap_identical(caps, stream_caps)) {
        ast_test_status_update(test, "Converting format capabilities into topology and back resulted in different formats\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ao2_cleanup, ast_format_alaw, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_identical(), ast_format_h264, ast_format_ulaw, AST_MEDIA_TYPE_AUDIO, ast_stream_alloc(), ast_stream_free(), ast_stream_set_formats(), ast_stream_set_state(), AST_STREAM_STATE_REMOVED, ast_stream_topology_append_stream(), ast_stream_topology_create_from_format_cap(), ast_stream_topology_free(), ast_stream_topology_get_formats(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [2/25]

AST_TEST_DEFINE

(

stream_create

)

Definition at line 43 of file test_stream.c.

{
    RAII_VAR(struct ast_stream *, stream, NULL, ast_stream_free);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_create";
        info->category = "/main/stream/";
        info->summary = "stream create unit test";
        info->description =
            "Test that creating a stream results in a stream with the expected values";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    stream = ast_stream_alloc("test", AST_MEDIA_TYPE_AUDIO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create media stream given proper arguments\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_state(stream) != AST_STREAM_STATE_INACTIVE) {
        ast_test_status_update(test, "Newly created stream does not have expected inactive stream state\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_type(stream) != AST_MEDIA_TYPE_AUDIO) {
        ast_test_status_update(test, "Newly created stream does not have expected audio media type\n");
        return AST_TEST_FAIL;
    }
 
    if (strcmp(ast_stream_get_name(stream), "test")) {
        ast_test_status_update(test, "Newly created stream does not have expected name of test\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References AST_MEDIA_TYPE_AUDIO, ast_stream_alloc(), ast_stream_free(), ast_stream_get_name(), ast_stream_get_state(), ast_stream_get_type(), AST_STREAM_STATE_INACTIVE, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [3/25]

AST_TEST_DEFINE

(

stream_create_no_name

)

Definition at line 83 of file test_stream.c.

{
    RAII_VAR(struct ast_stream *, stream, NULL, ast_stream_free);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_create_no_name";
        info->category = "/main/stream/";
        info->summary = "stream create (without a name) unit test";
        info->description =
            "Test that creating a stream with no name works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    stream = ast_stream_alloc(NULL, AST_MEDIA_TYPE_AUDIO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create media stream given proper arguments\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References AST_MEDIA_TYPE_AUDIO, ast_stream_alloc(), ast_stream_free(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [4/25]

AST_TEST_DEFINE

(

stream_metadata

)

Definition at line 228 of file test_stream.c.

{
    RAII_VAR(struct ast_stream *, stream, NULL, ast_stream_free);
    char track_label[AST_UUID_STR_LEN + 1];
    const char *stream_track_label;
    int rc;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_metadata";
        info->category = "/main/stream/";
        info->summary = "stream metadata unit test";
        info->description =
            "Test that metadata operations on a stream works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    stream = ast_stream_alloc("test", AST_MEDIA_TYPE_AUDIO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create media stream given proper arguments\n");
        return AST_TEST_FAIL;
    }
 
    stream_track_label = ast_stream_get_metadata(stream, "AST_STREAM_METADATA_TRACK_LABEL");
    if (stream_track_label) {
        ast_test_status_update(test, "New stream HAD a track label\n");
        return AST_TEST_FAIL;
    }
 
    ast_uuid_generate_str(track_label, sizeof(track_label));
    rc = ast_stream_set_metadata(stream, "AST_STREAM_METADATA_TRACK_LABEL", track_label);
    if (rc != 0) {
        ast_test_status_update(test, "Failed to add track label\n");
        return AST_TEST_FAIL;
    }
 
    stream_track_label = ast_stream_get_metadata(stream, "AST_STREAM_METADATA_TRACK_LABEL");
    if (!stream_track_label) {
        ast_test_status_update(test, "Changed stream does not have a track label\n");
        return AST_TEST_FAIL;
    }
 
    if (strcmp(stream_track_label, track_label) != 0) {
        ast_test_status_update(test, "Changed stream did not return same track label\n");
        return AST_TEST_FAIL;
    }
 
    rc = ast_stream_set_metadata(stream, "AST_STREAM_METADATA_TRACK_LABEL", NULL);
    if (rc != 0) {
        ast_test_status_update(test, "Failed to remove track label\n");
        return AST_TEST_FAIL;
    }
 
    stream_track_label = ast_stream_get_metadata(stream, "AST_STREAM_METADATA_TRACK_LABEL");
    if (stream_track_label) {
        ast_test_status_update(test, "Changed stream still had a track label after we removed it\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References AST_MEDIA_TYPE_AUDIO, ast_stream_alloc(), ast_stream_free(), ast_stream_get_metadata(), ast_stream_set_metadata(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_uuid_generate_str(), AST_UUID_STR_LEN, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [5/25]

AST_TEST_DEFINE

(

stream_read_multistream

)

Definition at line 1801 of file test_stream.c.

{
    struct ast_channel_tech tech = {
        .read_stream = mock_channel_read,
        .write_stream = mock_channel_write_stream,
        .hangup = mock_channel_hangup,
    };
    enum ast_test_result_state res = AST_TEST_PASS;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_read_multistream";
        info->category = "/main/stream/";
        info->summary = "stream reading from multistream capable channel test";
        info->description =
            "Test that reading frames from a multistream channel works as expected";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    res = read_test(test, &tech, CHANNEL_READ, 2, 16, 1, 0);
    ast_test_validate(test, res == AST_TEST_PASS, "multi, non read stream, 2 stream");
 
    res = read_test(test, &tech, CHANNEL_READ_STREAM, 2, 16, 1, 0);
    ast_test_validate(test, res == AST_TEST_PASS, "multi, read stream, 2 stream");
 
    res = read_test(test, &tech, CHANNEL_READ, 4, 16, 1, 8);
    ast_test_validate(test, res == AST_TEST_PASS, "multi, non read stream, 4 stream");
 
    res = read_test(test, &tech, CHANNEL_READ_STREAM, 4, 16, 1, 0);
    ast_test_validate(test, res == AST_TEST_PASS, "multi, read stream, 4 stream");
 
    res = read_test(test, &tech, CHANNEL_READ, 2, 16, 3, 0);
    ast_test_validate(test, res == AST_TEST_PASS, "multi, non read stream, 2 stream, 3 frames per read");
 
    res = read_test(test, &tech, CHANNEL_READ_STREAM, 2, 16, 3, 0);
    ast_test_validate(test, res == AST_TEST_PASS, "multi, read stream, 2 stream, 3 frames per read");
 
    res = read_test(test, &tech, CHANNEL_READ, 4, 16, 3, 8);
    ast_test_validate(test, res == AST_TEST_PASS, "multi, non read stream, 4 stream, 3 frames per read");
 
    res = read_test(test, &tech, CHANNEL_READ_STREAM, 4, 16, 3, 0);
    ast_test_validate(test, res == AST_TEST_PASS, "multi, read stream, 4 stream, 3 frames per read");
 
    return res;
}

References AST_TEST_NOT_RUN, AST_TEST_PASS, CHANNEL_READ, CHANNEL_READ_STREAM, mock_channel_hangup(), mock_channel_read(), mock_channel_write_stream(), ast_channel_tech::read_stream, read_test(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [6/25]

AST_TEST_DEFINE

(

stream_read_non_multistream

)

Definition at line 1765 of file test_stream.c.

{
    struct ast_channel_tech tech = {
        .read = mock_channel_read,
        .hangup = mock_channel_hangup,
    };
 
    enum ast_test_result_state res = AST_TEST_PASS;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_read_non_multistream";
        info->category = "/main/stream/";
        info->summary = "stream reading from non-multistream capable channel test";
        info->description =
            "Test that reading frames from a non-multistream channel works as expected";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    res = read_test(test, &tech, CHANNEL_READ, 2, 16, 1, 0);
    ast_test_validate(test, res == AST_TEST_PASS, "non multi, non read stream, 2 stream");
 
    res = read_test(test, &tech, CHANNEL_READ_STREAM, 2, 16, 1, 0);
    ast_test_validate(test, res == AST_TEST_PASS, "non multi, read stream, 2 stream");
 
    res = read_test(test, &tech, CHANNEL_READ, 2, 16, 3, 0);
    ast_test_validate(test, res == AST_TEST_PASS, "non multi, non read stream, 2 stream, 3 frames per read");
 
    res = read_test(test, &tech, CHANNEL_READ_STREAM, 2, 16, 3, 0);
    ast_test_validate(test, res == AST_TEST_PASS, "non multi, read stream, 2 stream, 3 frames per read");
 
    return res;
}

References AST_TEST_NOT_RUN, AST_TEST_PASS, CHANNEL_READ, CHANNEL_READ_STREAM, mock_channel_hangup(), mock_channel_read(), ast_channel_tech::read, read_test(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [7/25]

AST_TEST_DEFINE

(

stream_set_formats

)

Definition at line 145 of file test_stream.c.

{
    RAII_VAR(struct ast_stream *, stream, NULL, ast_stream_free);
    RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_set_formats";
        info->category = "/main/stream/";
        info->summary = "stream formats setting unit test";
        info->description =
            "Test that changing the formats of a stream works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!caps) {
        ast_test_status_update(test, "Failed to create a format capabilities structure for testing\n");
        return AST_TEST_FAIL;
    }
 
    stream = ast_stream_alloc("test", AST_MEDIA_TYPE_AUDIO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create media stream given proper arguments\n");
        return AST_TEST_FAIL;
    }
 
    ast_stream_set_formats(stream, caps);
 
    if (ast_stream_get_formats(stream) != caps) {
        ast_test_status_update(test, "Changed stream does not have expected formats\n");
        return AST_TEST_FAIL;
    }
 
    ast_stream_set_formats(stream, NULL);
 
    if (ast_stream_get_formats(stream)) {
        ast_test_status_update(test, "Retrieved formats from stream despite removing them\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ao2_cleanup, ast_format_cap_alloc, AST_FORMAT_CAP_FLAG_DEFAULT, AST_MEDIA_TYPE_AUDIO, ast_stream_alloc(), ast_stream_free(), ast_stream_get_formats(), ast_stream_set_formats(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [8/25]

AST_TEST_DEFINE

(

stream_set_state

)

Definition at line 191 of file test_stream.c.

{
    RAII_VAR(struct ast_stream *, stream, NULL, ast_stream_free);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_set_state";
        info->category = "/main/stream/";
        info->summary = "stream state setting unit test";
        info->description =
            "Test that changing the state of a stream works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    stream = ast_stream_alloc("test", AST_MEDIA_TYPE_AUDIO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create media stream given proper arguments\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_state(stream) != AST_STREAM_STATE_INACTIVE) {
        ast_test_status_update(test, "Newly created stream does not have expected inactive stream state\n");
        return AST_TEST_FAIL;
    }
 
    ast_stream_set_state(stream, AST_STREAM_STATE_SENDRECV);
 
    if (ast_stream_get_state(stream) != AST_STREAM_STATE_SENDRECV) {
        ast_test_status_update(test, "Changed stream does not have expected sendrecv state\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References AST_MEDIA_TYPE_AUDIO, ast_stream_alloc(), ast_stream_free(), ast_stream_get_state(), ast_stream_set_state(), AST_STREAM_STATE_INACTIVE, AST_STREAM_STATE_SENDRECV, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [9/25]

AST_TEST_DEFINE

(

stream_set_type

)

Definition at line 108 of file test_stream.c.

{
    RAII_VAR(struct ast_stream *, stream, NULL, ast_stream_free);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_set_type";
        info->category = "/main/stream/";
        info->summary = "stream type setting unit test";
        info->description =
            "Test that changing the type of a stream works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    stream = ast_stream_alloc("test", AST_MEDIA_TYPE_AUDIO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create media stream given proper arguments\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_type(stream) != AST_MEDIA_TYPE_AUDIO) {
        ast_test_status_update(test, "Newly created stream does not have expected audio media type\n");
        return AST_TEST_FAIL;
    }
 
    ast_stream_set_type(stream, AST_MEDIA_TYPE_VIDEO);
 
    if (ast_stream_get_type(stream) != AST_MEDIA_TYPE_VIDEO) {
        ast_test_status_update(test, "Changed stream does not have expected video media type\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, ast_stream_alloc(), ast_stream_free(), ast_stream_get_type(), ast_stream_set_type(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [10/25]

AST_TEST_DEFINE

(

stream_topology_append_stream

)

Definition at line 442 of file test_stream.c.

{
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    struct ast_stream *audio_stream, *video_stream;
    int position;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_append_stream";
        info->category = "/main/stream/";
        info->summary = "stream topology stream appending unit test";
        info->description =
            "Test that appending streams to a stream topology works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    topology = ast_stream_topology_alloc();
    if (!topology) {
        ast_test_status_update(test, "Failed to create media stream topology\n");
        return AST_TEST_FAIL;
    }
 
    audio_stream = ast_stream_alloc("audio", AST_MEDIA_TYPE_AUDIO);
    if (!audio_stream) {
        ast_test_status_update(test, "Failed to create an audio stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    position = ast_stream_topology_append_stream(topology, audio_stream);
    if (position == -1) {
        ast_test_status_update(test, "Failed to append valid audio stream to stream topology\n");
        ast_stream_free(audio_stream);
        return AST_TEST_FAIL;
    } else if (position != 0) {
        ast_test_status_update(test, "Appended audio stream to stream topology but position is '%d' instead of 0\n",
            position);
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_count(topology) != 1) {
        ast_test_status_update(test, "Appended an audio stream to the stream topology but stream count is '%d' on it, not 1\n",
            ast_stream_topology_get_count(topology));
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_stream(topology, 0) != audio_stream) {
        ast_test_status_update(test, "Appended an audio stream to the stream topology but returned stream doesn't match\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_position(audio_stream) != 0) {
        ast_test_status_update(test, "Appended audio stream says it is at position '%d' instead of 0\n",
            ast_stream_get_position(audio_stream));
        return AST_TEST_FAIL;
    }
 
    video_stream = ast_stream_alloc("video", AST_MEDIA_TYPE_VIDEO);
    if (!video_stream) {
        ast_test_status_update(test, "Failed to create a video stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    position = ast_stream_topology_append_stream(topology, video_stream);
    if (position == -1) {
        ast_test_status_update(test, "Failed to append valid video stream to stream topology\n");
        ast_stream_free(video_stream);
        return AST_TEST_FAIL;
    } else if (position != 1) {
        ast_test_status_update(test, "Appended video stream to stream topology but position is '%d' instead of 1\n",
            position);
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_count(topology) != 2) {
        ast_test_status_update(test, "Appended a video stream to the stream topology but stream count is '%d' on it, not 2\n",
            ast_stream_topology_get_count(topology));
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_stream(topology, 1) != video_stream) {
        ast_test_status_update(test, "Appended a video stream to the stream topology but returned stream doesn't match\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_position(video_stream) != 1) {
        ast_test_status_update(test, "Appended video stream says it is at position '%d' instead of 1\n",
            ast_stream_get_position(video_stream));
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, ast_stream_alloc(), ast_stream_free(), ast_stream_get_position(), ast_stream_topology_alloc(), ast_stream_topology_append_stream(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, ast_stream::position, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [11/25]

AST_TEST_DEFINE

(

stream_topology_change_request_from_application

)

Definition at line 1958 of file test_stream.c.

{
    struct ast_channel_tech tech = {
        .read_stream = mock_channel_read,
        .write_stream = mock_channel_write_stream,
        .indicate = mock_channel_indicate,
        .hangup = mock_channel_hangup,
    };
    struct ast_channel *mock_channel;
    struct mock_channel_pvt *pvt;
    enum ast_test_result_state res = AST_TEST_PASS;
    int change_res;
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_change_request_from_application";
        info->category = "/main/stream/";
        info->summary = "stream topology change request from application test";
        info->description =
            "Test that an application changing the stream topology of a multistream capable channel receives success";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    mock_channel = make_channel(test, 1, &tech);
    ast_test_validate_cleanup(test, mock_channel, res, done);
 
    pvt = ast_channel_tech_pvt(mock_channel);
    pvt->indicated_change_request = 0;
    pvt->indicated_changed = 0;
 
    topology = ast_stream_topology_alloc();
    ast_test_validate_cleanup(test, topology, res, done);
 
    change_res = ast_channel_request_stream_topology_change(mock_channel, topology, NULL);
 
    ast_test_validate_cleanup(test, !change_res, res, done);
    ast_test_validate_cleanup(test, pvt->indicated_change_request, res, done);
 
    ast_channel_lock(mock_channel);
    change_res = ast_channel_stream_topology_changed(mock_channel, topology);
    ast_channel_unlock(mock_channel);
 
    ast_test_validate_cleanup(test, !change_res, res, done);
    ast_test_validate_cleanup(test, pvt->indicated_changed, res, done);
 
done:
    ast_hangup(mock_channel);
 
    return res;
}

References ast_channel_lock, ast_channel_request_stream_topology_change(), ast_channel_stream_topology_changed(), ast_channel_tech_pvt(), ast_channel_unlock, ast_hangup(), ast_stream_topology_alloc(), ast_stream_topology_free(), AST_TEST_NOT_RUN, AST_TEST_PASS, done, mock_channel_pvt::indicated_change_request, mock_channel_pvt::indicated_changed, make_channel(), mock_channel_hangup(), mock_channel_indicate(), mock_channel_read(), mock_channel_write_stream(), NULL, RAII_VAR, ast_channel_tech::read_stream, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [12/25]

AST_TEST_DEFINE

(

stream_topology_change_request_from_application_non_multistream

)

Definition at line 1849 of file test_stream.c.

{
    struct ast_channel_tech tech = {
        .read = mock_channel_read,
        .indicate = mock_channel_indicate,
        .hangup = mock_channel_hangup,
    };
    struct ast_channel *mock_channel;
    struct mock_channel_pvt *pvt;
    enum ast_test_result_state res = AST_TEST_PASS;
    int change_res;
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_change_request_from_application_non_multistream";
        info->category = "/main/stream/";
        info->summary = "stream topology changing on non-multistream channel test";
        info->description =
            "Test that an application trying to change the stream topology of a non-multistream channel gets a failure";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    mock_channel = make_channel(test, 1, &tech);
    ast_test_validate_cleanup(test, mock_channel, res, done);
 
    pvt = ast_channel_tech_pvt(mock_channel);
    pvt->indicated_change_request = 0;
    pvt->indicated_changed = 0;
 
    topology = ast_stream_topology_alloc();
    ast_test_validate_cleanup(test, topology, res, done);
 
    change_res = ast_channel_request_stream_topology_change(mock_channel, topology, NULL);
 
    ast_test_validate_cleanup(test, change_res == -1, res, done);
    ast_test_validate_cleanup(test, !pvt->indicated_change_request, res, done);
 
    ast_channel_lock(mock_channel);
    change_res = ast_channel_stream_topology_changed(mock_channel, topology);
    ast_channel_unlock(mock_channel);
 
    ast_test_validate_cleanup(test, change_res == -1, res, done);
    ast_test_validate_cleanup(test, !pvt->indicated_changed, res, done);
 
done:
    ast_hangup(mock_channel);
 
    return res;
}

References ast_channel_lock, ast_channel_request_stream_topology_change(), ast_channel_stream_topology_changed(), ast_channel_tech_pvt(), ast_channel_unlock, ast_hangup(), ast_stream_topology_alloc(), ast_stream_topology_free(), AST_TEST_NOT_RUN, AST_TEST_PASS, done, mock_channel_pvt::indicated_change_request, mock_channel_pvt::indicated_changed, make_channel(), mock_channel_hangup(), mock_channel_indicate(), mock_channel_read(), NULL, RAII_VAR, ast_channel_tech::read, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [13/25]

AST_TEST_DEFINE

(

stream_topology_change_request_from_channel

)

Definition at line 2012 of file test_stream.c.

{
    struct ast_channel_tech tech = {
        .read_stream = mock_channel_read,
        .write_stream = mock_channel_write_stream,
        .indicate = mock_channel_indicate,
        .hangup = mock_channel_hangup,
    };
    struct ast_channel *mock_channel;
    struct mock_channel_pvt *pvt;
    enum ast_test_result_state res = AST_TEST_PASS;
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    struct ast_frame request_change = {
        .frametype = AST_FRAME_CONTROL,
        .subclass.integer = AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE,
    };
    struct ast_frame *fr = NULL;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_change_request_from_channel";
        info->category = "/main/stream/";
        info->summary = "channel requesting stream topology change to multistream application test";
        info->description =
            "Test that a channel requesting a stream topology change from a multistream application works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    mock_channel = make_channel(test, 1, &tech);
    ast_test_validate_cleanup(test, mock_channel, res, done);
 
    pvt = ast_channel_tech_pvt(mock_channel);
    pvt->indicated_changed = 0;
 
    topology = ast_stream_topology_alloc();
    ast_test_validate_cleanup(test, topology, res, done);
 
    request_change.data.ptr = topology;
    ast_queue_frame(mock_channel, &request_change);
 
    fr = ast_read_stream(mock_channel);
    ast_test_validate_cleanup(test, fr, res, done);
    ast_test_validate_cleanup(test, fr->frametype == AST_FRAME_CONTROL, res, done);
    ast_test_validate_cleanup(test, fr->subclass.integer == AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE, res, done);
    ast_test_validate_cleanup(test, !pvt->indicated_changed, res, done);
 
done:
    if (fr) {
        ast_frfree(fr);
    }
    ast_hangup(mock_channel);
 
    return res;
}

References ast_channel_tech_pvt(), AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE, AST_FRAME_CONTROL, ast_frfree, ast_hangup(), ast_queue_frame(), ast_read_stream(), ast_stream_topology_alloc(), ast_stream_topology_free(), AST_TEST_NOT_RUN, AST_TEST_PASS, ast_frame::data, done, ast_frame::frametype, mock_channel_pvt::indicated_changed, ast_frame_subclass::integer, make_channel(), mock_channel_hangup(), mock_channel_indicate(), mock_channel_read(), mock_channel_write_stream(), NULL, ast_frame::ptr, RAII_VAR, ast_channel_tech::read_stream, ast_frame::subclass, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [14/25]

AST_TEST_DEFINE

(

stream_topology_change_request_from_channel_non_multistream

)

Definition at line 1902 of file test_stream.c.

{
    struct ast_channel_tech tech = {
        .read_stream = mock_channel_read,
        .write_stream = mock_channel_write_stream,
        .indicate = mock_channel_indicate,
        .hangup = mock_channel_hangup,
    };
    struct ast_channel *mock_channel;
    struct mock_channel_pvt *pvt;
    enum ast_test_result_state res = AST_TEST_PASS;
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    struct ast_frame request_change = {
        .frametype = AST_FRAME_CONTROL,
        .subclass.integer = AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE,
    };
    struct ast_frame *fr = NULL;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_change_request_from_channel_non_multistream";
        info->category = "/main/stream/";
        info->summary = "channel requesting stream topology change to non-multistream application test";
        info->description =
            "Test that a channel requesting a stream topology change from a non-multistream application does not work";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    mock_channel = make_channel(test, 1, &tech);
    ast_test_validate_cleanup(test, mock_channel, res, done);
 
    pvt = ast_channel_tech_pvt(mock_channel);
    pvt->indicated_changed = 0;
 
    topology = ast_stream_topology_alloc();
    ast_test_validate_cleanup(test, topology, res, done);
 
    request_change.data.ptr = topology;
    ast_queue_frame(mock_channel, &request_change);
 
    fr = ast_read(mock_channel);
    ast_test_validate_cleanup(test, fr, res, done);
    ast_test_validate_cleanup(test, fr == &ast_null_frame, res, done);
    ast_test_validate_cleanup(test, pvt->indicated_changed, res, done);
 
done:
    if (fr) {
        ast_frfree(fr);
    }
    ast_hangup(mock_channel);
 
    return res;
}

References ast_channel_tech_pvt(), AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE, AST_FRAME_CONTROL, ast_frfree, ast_hangup(), ast_null_frame, ast_queue_frame(), ast_read(), ast_stream_topology_alloc(), ast_stream_topology_free(), AST_TEST_NOT_RUN, AST_TEST_PASS, ast_frame::data, done, ast_frame::frametype, mock_channel_pvt::indicated_changed, make_channel(), mock_channel_hangup(), mock_channel_indicate(), mock_channel_read(), mock_channel_write_stream(), NULL, ast_frame::ptr, RAII_VAR, ast_channel_tech::read_stream, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [15/25]

AST_TEST_DEFINE

(

stream_topology_channel_set

)

Definition at line 1182 of file test_stream.c.

{
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    struct ast_channel *mock_channel;
    enum ast_test_result_state res = AST_TEST_PASS;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_channel_set";
        info->category = "/main/stream/";
        info->summary = "stream topology setting on a channel unit test";
        info->description =
            "Test that setting a stream topology on a channel works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    topology = ast_stream_topology_alloc();
    if (!topology) {
        ast_test_status_update(test, "Failed to create media stream topology\n");
        return AST_TEST_FAIL;
    }
 
    mock_channel = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, "TestChannel");
    if (!mock_channel) {
        ast_test_status_update(test, "Failed to create a mock channel for testing\n");
        return AST_TEST_FAIL;
    }
 
    ast_channel_tech_set(mock_channel, &mock_stream_channel_tech);
    ast_channel_set_stream_topology(mock_channel, topology);
 
    if (ast_channel_get_stream_topology(mock_channel) != topology) {
        ast_test_status_update(test, "Set an explicit stream topology on a channel but the returned one did not match it\n");
        res = AST_TEST_FAIL;
    }
 
    topology = NULL;
    ast_channel_unlock(mock_channel);
    ast_hangup(mock_channel);
 
    return res;
}

References ast_channel_alloc, ast_channel_get_stream_topology(), ast_channel_set_stream_topology(), ast_channel_tech_set(), ast_channel_unlock, ast_hangup(), AST_STATE_DOWN, ast_stream_topology_alloc(), ast_stream_topology_free(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, mock_stream_channel_tech, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [16/25]

AST_TEST_DEFINE

(

stream_topology_clone

)

Definition at line 317 of file test_stream.c.

{
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    RAII_VAR(struct ast_stream_topology *, cloned, NULL, ast_stream_topology_free);
    struct ast_stream *audio_stream, *video_stream;
    char audio_track_label[AST_UUID_STR_LEN + 1];
    char video_track_label[AST_UUID_STR_LEN + 1];
    const char *original_track_label;
    const char *cloned_track_label;
    int rc;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_clone";
        info->category = "/main/stream/";
        info->summary = "stream topology cloning unit test";
        info->description =
            "Test that cloning a stream topology results in a clone with the same contents";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    topology = ast_stream_topology_alloc();
    if (!topology) {
        ast_test_status_update(test, "Failed to create media stream topology\n");
        return AST_TEST_FAIL;
    }
 
    audio_stream = ast_stream_alloc("audio", AST_MEDIA_TYPE_AUDIO);
    if (!audio_stream) {
        ast_test_status_update(test, "Failed to create an audio stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    ast_uuid_generate_str(audio_track_label, sizeof(audio_track_label));
    rc = ast_stream_set_metadata(audio_stream, "AST_STREAM_METADATA_TRACK_LABEL", audio_track_label);
    if (rc != 0) {
        ast_test_status_update(test, "Failed to add track label\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_append_stream(topology, audio_stream) == -1) {
        ast_test_status_update(test, "Failed to append valid audio stream to stream topology\n");
        ast_stream_free(audio_stream);
        return AST_TEST_FAIL;
    }
 
    video_stream = ast_stream_alloc("video", AST_MEDIA_TYPE_VIDEO);
    if (!video_stream) {
        ast_test_status_update(test, "Failed to create a video stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    ast_uuid_generate_str(video_track_label, sizeof(video_track_label));
    rc = ast_stream_set_metadata(video_stream, "AST_STREAM_METADATA_TRACK_LABEL", video_track_label);
    if (rc != 0) {
        ast_test_status_update(test, "Failed to add track label\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_append_stream(topology, video_stream) == -1) {
        ast_test_status_update(test, "Failed to append valid video stream to stream topology\n");
        ast_stream_free(video_stream);
        return AST_TEST_FAIL;
    }
 
    cloned = ast_stream_topology_clone(topology);
    if (!cloned) {
        ast_test_status_update(test, "Failed to clone a perfectly good stream topology\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_count(cloned) != ast_stream_topology_get_count(topology)) {
        ast_test_status_update(test, "Cloned stream topology does not contain same number of streams as original\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_type(ast_stream_topology_get_stream(cloned, 0)) != ast_stream_get_type(ast_stream_topology_get_stream(topology, 0))) {
        ast_test_status_update(test, "Cloned audio stream does not contain same type as original\n");
        return AST_TEST_FAIL;
    }
 
    original_track_label = ast_stream_get_metadata(ast_stream_topology_get_stream(topology, 0),
        "AST_STREAM_METADATA_TRACK_LABEL");
    if (!original_track_label) {
        ast_test_status_update(test, "Original topology stream 0 does not contain metadata\n");
        return AST_TEST_FAIL;
    }
    cloned_track_label = ast_stream_get_metadata(ast_stream_topology_get_stream(cloned, 0),
        "AST_STREAM_METADATA_TRACK_LABEL");
    if (!cloned_track_label) {
        ast_test_status_update(test, "Cloned topology stream 0 does not contain metadata\n");
        return AST_TEST_FAIL;
    }
    if (strcmp(original_track_label, cloned_track_label) != 0) {
        ast_test_status_update(test, "Cloned topology stream 0 track label was not the same as the original\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_type(ast_stream_topology_get_stream(cloned, 1)) != ast_stream_get_type(ast_stream_topology_get_stream(topology, 1))) {
        ast_test_status_update(test, "Cloned video stream does not contain same type as original\n");
        return AST_TEST_FAIL;
    }
 
    original_track_label = ast_stream_get_metadata(ast_stream_topology_get_stream(topology, 1),
        "AST_STREAM_METADATA_TRACK_LABEL");
    if (!original_track_label) {
        ast_test_status_update(test, "Original topology stream 1 does not contain metadata\n");
        return AST_TEST_FAIL;
    }
    cloned_track_label = ast_stream_get_metadata(ast_stream_topology_get_stream(cloned, 1),
        "AST_STREAM_METADATA_TRACK_LABEL");
    if (!cloned_track_label) {
        ast_test_status_update(test, "Cloned topology stream 1 does not contain metadata\n");
        return AST_TEST_FAIL;
    }
    if (strcmp(original_track_label, cloned_track_label) != 0) {
        ast_test_status_update(test, "Cloned topology stream 1 track label was not the same as the original\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, ast_stream_alloc(), ast_stream_free(), ast_stream_get_metadata(), ast_stream_get_type(), ast_stream_set_metadata(), ast_stream_topology_alloc(), ast_stream_topology_append_stream(), ast_stream_topology_clone(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_uuid_generate_str(), AST_UUID_STR_LEN, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [17/25]

AST_TEST_DEFINE

(

stream_topology_create

)

Definition at line 292 of file test_stream.c.

{
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_create";
        info->category = "/main/stream/";
        info->summary = "stream topology creation unit test";
        info->description =
            "Test that creating a stream topology works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    topology = ast_stream_topology_alloc();
    if (!topology) {
        ast_test_status_update(test, "Failed to create media stream topology\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ast_stream_topology_alloc(), ast_stream_topology_free(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [18/25]

AST_TEST_DEFINE

(

stream_topology_create_from_channel_nativeformats

)

Definition at line 991 of file test_stream.c.

{
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
    struct ast_channel *mock_channel;
    enum ast_test_result_state res = AST_TEST_FAIL;
    struct ast_str *codec_have_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
    struct ast_str *codec_wanted_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_create_from_channel_nativeformats";
        info->category = "/main/stream/";
        info->summary = "stream topology creation from channel native formats unit test";
        info->description =
            "Test that creating a stream topology from the setting of channel nativeformats results in the expected streams";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!caps) {
        ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_ulaw, 0)) {
        ast_test_status_update(test, "Failed to append a ulaw format to capabilities for channel nativeformats\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_alaw, 0)) {
        ast_test_status_update(test, "Failed to append an alaw format to capabilities for channel nativeformats\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_h264, 0)) {
        ast_test_status_update(test, "Failed to append an h264 format to capabilities for channel nativeformats\n");
        return AST_TEST_FAIL;
    }
 
    mock_channel = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, "TestChannel");
    if (!mock_channel) {
        ast_test_status_update(test, "Failed to create a mock channel for testing\n");
        return AST_TEST_FAIL;
    }
 
    ast_channel_tech_set(mock_channel, &mock_channel_tech);
    ast_channel_nativeformats_set(mock_channel, caps);
 
    if (!ast_channel_get_stream_topology(mock_channel)) {
        ast_test_status_update(test, "Set nativeformats with ulaw, alaw, and h264 on channel but it did not create a topology\n");
        goto end;
    }
 
    if (ast_stream_topology_get_count(ast_channel_get_stream_topology(mock_channel)) != 2) {
        ast_test_status_update(test, "Set nativeformats on a channel to ulaw, alaw, and h264 and received '%d' streams instead of expected 2\n",
            ast_stream_topology_get_count(ast_channel_get_stream_topology(mock_channel)));
        goto end;
    }
 
    if (ast_stream_get_type(ast_stream_topology_get_stream(ast_channel_get_stream_topology(mock_channel), 0)) != AST_MEDIA_TYPE_AUDIO) {
        ast_test_status_update(test, "First stream on channel is of %s when it should be audio\n",
            ast_codec_media_type2str(ast_stream_get_type(ast_stream_topology_get_stream(ast_channel_get_stream_topology(mock_channel), 0))));
        goto end;
    }
 
    ast_format_cap_remove_by_type(caps, AST_MEDIA_TYPE_VIDEO);
    if (!ast_format_cap_identical(ast_stream_get_formats(ast_stream_topology_get_stream(ast_channel_get_stream_topology(mock_channel), 0)), caps)) {
        ast_test_status_update(test, "Formats on audio stream of channel are '%s' when they should be '%s'\n",
            ast_format_cap_get_names(ast_stream_get_formats(ast_stream_topology_get_stream(ast_channel_get_stream_topology(mock_channel), 0)), &codec_have_buf),
            ast_format_cap_get_names(caps, &codec_wanted_buf));
        goto end;
    }
 
    if (ast_stream_get_type(ast_stream_topology_get_stream(ast_channel_get_stream_topology(mock_channel), 1)) != AST_MEDIA_TYPE_VIDEO) {
        ast_test_status_update(test, "Second stream on channel is of type %s when it should be video\n",
            ast_codec_media_type2str(ast_stream_get_type(ast_stream_topology_get_stream(ast_channel_get_stream_topology(mock_channel), 1))));
        goto end;
    }
 
    ast_format_cap_remove_by_type(caps, AST_MEDIA_TYPE_AUDIO);
 
    if (ast_format_cap_append(caps, ast_format_h264, 0)) {
        ast_test_status_update(test, "Failed to append h264 video codec to capabilities for capabilities comparison\n");
        goto end;
    }
 
    if (!ast_format_cap_identical(ast_stream_get_formats(ast_stream_topology_get_stream(ast_channel_get_stream_topology(mock_channel), 1)), caps)) {
        ast_test_status_update(test, "Formats on video stream of channel are '%s' when they should be '%s'\n",
            ast_format_cap_get_names(ast_stream_get_formats(ast_stream_topology_get_stream(ast_channel_get_stream_topology(mock_channel), 1)), &codec_wanted_buf),
            ast_format_cap_get_names(caps, &codec_wanted_buf));
        goto end;
    }
 
    res = AST_TEST_PASS;
 
end:
    ast_channel_unlock(mock_channel);
    ast_hangup(mock_channel);
 
    return res;
}

References ao2_cleanup, ast_channel_alloc, ast_channel_get_stream_topology(), ast_channel_nativeformats_set(), ast_channel_tech_set(), ast_channel_unlock, ast_codec_media_type2str(), ast_format_alaw, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_names(), ast_format_cap_identical(), AST_FORMAT_CAP_NAMES_LEN, ast_format_cap_remove_by_type(), ast_format_h264, ast_format_ulaw, ast_hangup(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, AST_STATE_DOWN, ast_str_alloca, ast_stream_get_formats(), ast_stream_get_type(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, end, mock_channel_tech, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [19/25]

AST_TEST_DEFINE

(

stream_topology_create_from_format_cap

)

Definition at line 790 of file test_stream.c.

{
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_create_from_format_cap";
        info->category = "/main/stream/";
        info->summary = "stream topology creation from format capabilities unit test";
        info->description =
            "Test that creating a stream topology from format capabilities results in the expected streams";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!caps) {
        ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_ulaw, 0)) {
        ast_test_status_update(test, "Failed to append a ulaw format to capabilities for stream topology creation\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_alaw, 0)) {
        ast_test_status_update(test, "Failed to append an alaw format to capabilities for stream topology creation\n");
        return AST_TEST_FAIL;
    }
 
    topology = ast_stream_topology_create_from_format_cap(caps);
    if (!topology) {
        ast_test_status_update(test, "Failed to create a stream topology using a perfectly good format capabilities\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_count(topology) != 1) {
        ast_test_status_update(test, "Expected a stream topology with 1 stream but it has %d streams\n",
            ast_stream_topology_get_count(topology));
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_type(ast_stream_topology_get_stream(topology, 0)) != AST_MEDIA_TYPE_AUDIO) {
        ast_test_status_update(test, "Produced stream topology has a single stream of type %s instead of audio\n",
            ast_codec_media_type2str(ast_stream_get_type(ast_stream_topology_get_stream(topology, 0))));
        return AST_TEST_FAIL;
    }
 
    ast_stream_topology_free(topology);
    topology = NULL;
 
    ast_format_cap_append(caps, ast_format_h264, 0);
 
    topology = ast_stream_topology_create_from_format_cap(caps);
    if (!topology) {
        ast_test_status_update(test, "Failed to create a stream topology using a perfectly good format capabilities\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_count(topology) != 2) {
        ast_test_status_update(test, "Expected a stream topology with 2 streams but it has %d streams\n",
            ast_stream_topology_get_count(topology));
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_type(ast_stream_topology_get_stream(topology, 0)) != AST_MEDIA_TYPE_AUDIO) {
        ast_test_status_update(test, "Produced stream topology has a first stream of type %s instead of audio\n",
            ast_codec_media_type2str(ast_stream_get_type(ast_stream_topology_get_stream(topology, 0))));
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_type(ast_stream_topology_get_stream(topology, 1)) != AST_MEDIA_TYPE_VIDEO) {
        ast_test_status_update(test, "Produced stream topology has a second stream of type %s instead of video\n",
            ast_codec_media_type2str(ast_stream_get_type(ast_stream_topology_get_stream(topology, 1))));
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ao2_cleanup, ast_codec_media_type2str(), ast_format_alaw, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_h264, ast_format_ulaw, AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, ast_stream_get_type(), ast_stream_topology_create_from_format_cap(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [20/25]

AST_TEST_DEFINE

(

stream_topology_del_stream

)

Definition at line 670 of file test_stream.c.

{
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    struct ast_stream *stream;
    enum ast_media_type type;
    int idx;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_del_stream";
        info->category = "/main/stream/";
        info->summary = "stream topology stream delete unit test";
        info->description =
            "Test that deleting streams at a specific position in a topology works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    topology = ast_stream_topology_alloc();
    if (!topology) {
        ast_test_status_update(test, "Failed to create media stream topology\n");
        return AST_TEST_FAIL;
    }
 
    /* Create streams */
    for (type = AST_MEDIA_TYPE_UNKNOWN; type < AST_MEDIA_TYPE_END; ++type) {
        stream = ast_stream_alloc(ast_codec_media_type2str(type), type);
        if (!stream) {
            ast_test_status_update(test, "Failed to create '%s' stream for testing stream topology\n",
                ast_codec_media_type2str(type));
            return AST_TEST_FAIL;
        }
        if (ast_stream_topology_append_stream(topology, stream) == -1) {
            ast_test_status_update(test, "Failed to append '%s' stream to topology\n",
                ast_codec_media_type2str(type));
            ast_stream_free(stream);
            return AST_TEST_FAIL;
        }
    }
 
    /* Check initial stream positions and types for sanity. */
    type = AST_MEDIA_TYPE_UNKNOWN;
    for (idx = 0; idx < ast_stream_topology_get_count(topology); ++idx, ++type) {
        stream = ast_stream_topology_get_stream(topology, idx);
        if (type != ast_stream_get_type(stream)) {
            ast_test_status_update(test, "Initial topology types failed: Expected:%s Got:%s\n",
                ast_codec_media_type2str(type),
                ast_codec_media_type2str(ast_stream_get_type(stream)));
            return AST_TEST_FAIL;
        }
    }
    if (check_stream_positions(test, topology)) {
        ast_test_status_update(test, "Initial topology positions failed.\n");
        return AST_TEST_FAIL;
    }
 
    /* Try to delete outside of topology size */
    if (!ast_stream_topology_del_stream(topology, ast_stream_topology_get_count(topology))) {
        ast_test_status_update(test, "Deleting stream outside of topology succeeded!\n");
        return AST_TEST_FAIL;
    }
 
    /* Try to delete the last topology stream */
    if (ast_stream_topology_del_stream(topology, ast_stream_topology_get_count(topology) - 1)) {
        ast_test_status_update(test, "Failed deleting last stream of topology.\n");
        return AST_TEST_FAIL;
    }
    if (check_stream_positions(test, topology)) {
        ast_test_status_update(test, "Last stream delete topology positions failed.\n");
        return AST_TEST_FAIL;
    }
    stream = ast_stream_topology_get_stream(topology, ast_stream_topology_get_count(topology) - 1);
    type = ast_stream_get_type(stream);
    if (type != AST_MEDIA_TYPE_END - 2) {
        ast_test_status_update(test, "Last stream delete types failed: Expected:%s Got:%s\n",
            ast_codec_media_type2str(AST_MEDIA_TYPE_END - 2),
            ast_codec_media_type2str(type));
        return AST_TEST_FAIL;
    }
 
    /* Try to delete the second stream in the topology */
    if (ast_stream_topology_del_stream(topology, 1)) {
        ast_test_status_update(test, "Failed deleting second stream in topology.\n");
        return AST_TEST_FAIL;
    }
    if (check_stream_positions(test, topology)) {
        ast_test_status_update(test, "Second stream delete topology positions failed.\n");
        return AST_TEST_FAIL;
    }
    stream = ast_stream_topology_get_stream(topology, 1);
    type = ast_stream_get_type(stream);
    if (type != AST_MEDIA_TYPE_UNKNOWN + 2) {
        ast_test_status_update(test, "Second stream delete types failed: Expected:%s Got:%s\n",
            ast_codec_media_type2str(AST_MEDIA_TYPE_UNKNOWN + 2),
            ast_codec_media_type2str(type));
        return AST_TEST_FAIL;
    }
 
    /* Try to delete the first stream in the topology */
    if (ast_stream_topology_del_stream(topology, 0)) {
        ast_test_status_update(test, "Failed deleting first stream in topology.\n");
        return AST_TEST_FAIL;
    }
    if (check_stream_positions(test, topology)) {
        ast_test_status_update(test, "First stream delete topology positions failed.\n");
        return AST_TEST_FAIL;
    }
    stream = ast_stream_topology_get_stream(topology, 0);
    type = ast_stream_get_type(stream);
    if (type != AST_MEDIA_TYPE_UNKNOWN + 2) {
        ast_test_status_update(test, "First stream delete types failed: Expected:%s Got:%s\n",
            ast_codec_media_type2str(AST_MEDIA_TYPE_UNKNOWN + 2),
            ast_codec_media_type2str(type));
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ast_codec_media_type2str(), AST_MEDIA_TYPE_END, AST_MEDIA_TYPE_UNKNOWN, ast_stream_alloc(), ast_stream_free(), ast_stream_get_type(), ast_stream_topology_alloc(), ast_stream_topology_append_stream(), ast_stream_topology_del_stream(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, check_stream_positions(), NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and type.

AST_TEST_DEFINE() [21/25]

AST_TEST_DEFINE

(

stream_topology_get_first_stream_by_type

)

Definition at line 873 of file test_stream.c.

{
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    struct ast_stream *first_stream;
    struct ast_stream *second_stream;
    struct ast_stream *third_stream;
    struct ast_stream *fourth_stream;
    struct ast_stream *fifth_stream;
    struct ast_stream *sixth_stream;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_get_first_stream_by_type";
        info->category = "/main/stream/";
        info->summary = "stream topology getting first stream by type unit test";
        info->description =
            "Test that getting the first stream by type from a topology actually returns the first stream";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    topology = ast_stream_topology_alloc();
    if (!topology) {
        ast_test_status_update(test, "Failed to create media stream topology\n");
        return AST_TEST_FAIL;
    }
 
    first_stream = ast_stream_alloc("audio", AST_MEDIA_TYPE_AUDIO);
    if (!first_stream) {
        ast_test_status_update(test, "Failed to create an audio stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
    ast_stream_set_state(first_stream, AST_STREAM_STATE_REMOVED);
 
    if (ast_stream_topology_append_stream(topology, first_stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(first_stream);
        return AST_TEST_FAIL;
    }
 
    second_stream = ast_stream_alloc("audio2", AST_MEDIA_TYPE_AUDIO);
    if (!second_stream) {
        ast_test_status_update(test, "Failed to create a second audio stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_append_stream(topology, second_stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(second_stream);
        return AST_TEST_FAIL;
    }
 
    third_stream = ast_stream_alloc("audio3", AST_MEDIA_TYPE_AUDIO);
    if (!third_stream) {
        ast_test_status_update(test, "Failed to create a third audio stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_append_stream(topology, third_stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(third_stream);
        return AST_TEST_FAIL;
    }
 
    fourth_stream = ast_stream_alloc("video", AST_MEDIA_TYPE_VIDEO);
    if (!fourth_stream) {
        ast_test_status_update(test, "Failed to create a video stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
    ast_stream_set_state(fourth_stream, AST_STREAM_STATE_REMOVED);
 
    if (ast_stream_topology_append_stream(topology, fourth_stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(fourth_stream);
        return AST_TEST_FAIL;
    }
 
    fifth_stream = ast_stream_alloc("video2", AST_MEDIA_TYPE_VIDEO);
    if (!fifth_stream) {
        ast_test_status_update(test, "Failed to create a second video stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_append_stream(topology, fifth_stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(fifth_stream);
        return AST_TEST_FAIL;
    }
 
    sixth_stream = ast_stream_alloc("video3", AST_MEDIA_TYPE_VIDEO);
    if (!sixth_stream) {
        ast_test_status_update(test, "Failed to create a third video stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_append_stream(topology, sixth_stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(sixth_stream);
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_first_stream_by_type(topology, AST_MEDIA_TYPE_AUDIO) != second_stream) {
        ast_test_status_update(test, "Retrieved first audio stream from topology but it is not the correct one\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_first_stream_by_type(topology, AST_MEDIA_TYPE_VIDEO) != fifth_stream) {
        ast_test_status_update(test, "Retrieved first video stream from topology but it is not the correct one\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, ast_stream_alloc(), ast_stream_free(), ast_stream_set_state(), AST_STREAM_STATE_REMOVED, ast_stream_topology_alloc(), ast_stream_topology_append_stream(), ast_stream_topology_free(), ast_stream_topology_get_first_stream_by_type(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [22/25]

AST_TEST_DEFINE

(

stream_topology_map_create

)

Definition at line 2173 of file test_stream.c.

{
    RAII_VAR(struct ast_stream_topology *, t0, NULL, ast_stream_topology_free);
 
    struct ast_vector_int types = { NULL };
    struct ast_vector_int v0 = { NULL };
    struct ast_vector_int v1 = { NULL };
 
    enum ast_test_result_state res = AST_TEST_PASS;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_map_create";
        info->category = "/main/stream/";
        info->summary = "stream topology map creation unit test";
        info->description =
            "Test that creating a stream topology map works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_test_validate(test, AST_VECTOR_INIT(&types, 5) == 0);
 
    /* Map a first topology and check that it mapped one to one */
    ast_test_validate_cleanup(test, (t0 = ast_stream_topology_alloc()), res, done);
    topology_append_stream(t0, "audio", AST_MEDIA_TYPE_AUDIO, res, done);
    topology_append_stream(t0, "video", AST_MEDIA_TYPE_VIDEO, res, done);
 
    ast_stream_topology_map(t0, &types, &v0, &v1);
    ast_test_validate_cleanup(test, AST_VECTOR_SIZE(&types) == 2, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&types, 0) == AST_MEDIA_TYPE_AUDIO, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&types, 1) == AST_MEDIA_TYPE_VIDEO, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v0, 0) == 0, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v0, 1) == 1, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v1, 0) == 0, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v1, 1) == 1, res, done);
 
    /* Map a second topology and check that it merged */
    ast_stream_topology_free(t0);
    ast_test_validate_cleanup(test, (t0 = ast_stream_topology_alloc()), res, done);
    topology_append_stream(t0, "video", AST_MEDIA_TYPE_VIDEO, res, done);
    topology_append_stream(t0, "audio", AST_MEDIA_TYPE_AUDIO, res, done);
 
    ast_stream_topology_map(t0, &types, &v0, &v1);
    ast_test_validate_cleanup(test, AST_VECTOR_SIZE(&types) == 2, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&types, 0) == AST_MEDIA_TYPE_AUDIO, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&types, 1) == AST_MEDIA_TYPE_VIDEO, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v0, 0) == 1, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v0, 1) == 0, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v1, 0) == 1, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v1, 1) == 0, res, done);
 
    /* Map a third topology with more streams and check that it merged */
    ast_stream_topology_free(t0);
    ast_test_validate_cleanup(test, (t0 = ast_stream_topology_alloc()), res, done);
    topology_append_stream(t0, "video", AST_MEDIA_TYPE_VIDEO, res, done);
    topology_append_stream(t0, "audio", AST_MEDIA_TYPE_AUDIO, res, done);
    topology_append_stream(t0, "audio", AST_MEDIA_TYPE_AUDIO, res, done);
 
    ast_stream_topology_map(t0, &types, &v0, &v1);
    ast_test_validate_cleanup(test, AST_VECTOR_SIZE(&types) == 3, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&types, 0) == AST_MEDIA_TYPE_AUDIO, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&types, 1) == AST_MEDIA_TYPE_VIDEO, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&types, 2) == AST_MEDIA_TYPE_AUDIO, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v0, 0) == 1, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v0, 1) == 0, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v0, 2) == 2, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v1, 0) == 1, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v1, 1) == 0, res, done);
    ast_test_validate_cleanup(test, AST_VECTOR_GET(&v1, 2) == 2, res, done);
 
done:
    AST_VECTOR_FREE(&v1);
    AST_VECTOR_FREE(&v0);
    AST_VECTOR_FREE(&types);
 
    return res;
}

References AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, ast_stream_topology_alloc(), ast_stream_topology_free(), ast_stream_topology_map(), AST_TEST_NOT_RUN, AST_TEST_PASS, AST_VECTOR_FREE, AST_VECTOR_GET, AST_VECTOR_INIT, AST_VECTOR_SIZE, done, NULL, RAII_VAR, TEST_EXECUTE, TEST_INIT, and topology_append_stream.

AST_TEST_DEFINE() [23/25]

AST_TEST_DEFINE

(

stream_topology_set_stream

)

Definition at line 537 of file test_stream.c.

{
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    struct ast_stream *audio_stream, *video_stream;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_topology_set_stream";
        info->category = "/main/stream/";
        info->summary = "stream topology stream setting unit test";
        info->description =
            "Test that setting streams at a specific position in a topology works";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    topology = ast_stream_topology_alloc();
    if (!topology) {
        ast_test_status_update(test, "Failed to create media stream topology\n");
        return AST_TEST_FAIL;
    }
 
    audio_stream = ast_stream_alloc("audio", AST_MEDIA_TYPE_AUDIO);
    if (!audio_stream) {
        ast_test_status_update(test, "Failed to create an audio stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_set_stream(topology, 0, audio_stream)) {
        ast_test_status_update(test, "Failed to set an audio stream to a position where it is permitted\n");
        ast_stream_free(audio_stream);
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_count(topology) != 1) {
        ast_test_status_update(test, "Set an audio stream on the stream topology but stream count is '%d' on it, not 1\n",
            ast_stream_topology_get_count(topology));
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_stream(topology, 0) != audio_stream) {
        ast_test_status_update(test, "Set an audio stream on the stream topology but returned stream doesn't match\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_position(audio_stream) != 0) {
        ast_test_status_update(test, "Set audio stream says it is at position '%d' instead of 0\n",
            ast_stream_get_position(audio_stream));
        return AST_TEST_FAIL;
    }
 
    video_stream = ast_stream_alloc("video", AST_MEDIA_TYPE_VIDEO);
    if (!video_stream) {
        ast_test_status_update(test, "Failed to create a video stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_set_stream(topology, 0, video_stream)) {
        ast_test_status_update(test, "Failed to set a video stream to a position where it is permitted\n");
        ast_stream_free(video_stream);
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_count(topology) != 1) {
        ast_test_status_update(test, "Set a video stream on the stream topology but stream count is '%d' on it, not 1\n",
            ast_stream_topology_get_count(topology));
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_stream(topology, 0) != video_stream) {
        ast_test_status_update(test, "Set a video stream on the stream topology but returned stream doesn't match\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_position(video_stream) != 0) {
        ast_test_status_update(test, "Set video stream says it is at position '%d' instead of 0\n",
            ast_stream_get_position(video_stream));
        return AST_TEST_FAIL;
    }
 
    audio_stream = ast_stream_alloc("audio", AST_MEDIA_TYPE_AUDIO);
    if (!audio_stream) {
        ast_test_status_update(test, "Failed to create an audio stream for testing stream topology\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_set_stream(topology, 1, audio_stream)) {
        ast_test_status_update(test, "Failed to set an audio stream to a position where it is permitted\n");
        ast_stream_free(audio_stream);
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_count(topology) != 2) {
        ast_test_status_update(test, "Set an audio stream on the stream topology but stream count is '%d' on it, not 2\n",
            ast_stream_topology_get_count(topology));
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_get_stream(topology, 1) != audio_stream) {
        ast_test_status_update(test, "Set an audio stream on the stream topology but returned stream doesn't match\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_get_position(audio_stream) != 1) {
        ast_test_status_update(test, "Set audio stream says it is at position '%d' instead of 1\n",
            ast_stream_get_position(audio_stream));
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, ast_stream_alloc(), ast_stream_free(), ast_stream_get_position(), ast_stream_topology_alloc(), ast_stream_topology_free(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_stream_topology_set_stream(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [24/25]

AST_TEST_DEFINE

(

stream_write_multistream

)

Definition at line 1343 of file test_stream.c.

{
    RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
    RAII_VAR(struct ast_stream_topology *, topology, NULL, ast_stream_topology_free);
    struct ast_stream *stream;
    struct ast_channel *mock_channel;
    struct mock_channel_pvt pvt = { 0, };
    enum ast_test_result_state res = AST_TEST_FAIL;
    struct ast_frame frame = { 0, };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_write_multistream";
        info->category = "/main/stream/";
        info->summary = "stream writing to multistream capable channel test";
        info->description =
            "Test that writing frames to a multistream channel works as expected";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    topology = ast_stream_topology_alloc();
    if (!topology) {
        ast_test_status_update(test, "Failed to create media stream topology\n");
        return AST_TEST_FAIL;
    }
 
    stream = ast_stream_alloc("audio", AST_MEDIA_TYPE_AUDIO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create an audio stream for testing multistream writing\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_append_stream(topology, stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(stream);
        return AST_TEST_FAIL;
    }
 
    stream = ast_stream_alloc("audio2", AST_MEDIA_TYPE_AUDIO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create an audio stream for testing multistream writing\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_append_stream(topology, stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(stream);
        return AST_TEST_FAIL;
    }
 
    stream = ast_stream_alloc("video", AST_MEDIA_TYPE_VIDEO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create a video stream for testing multistream writing\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_append_stream(topology, stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(stream);
        return AST_TEST_FAIL;
    }
 
    stream = ast_stream_alloc("video2", AST_MEDIA_TYPE_VIDEO);
    if (!stream) {
        ast_test_status_update(test, "Failed to create a video stream for testing multistream writing\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_stream_topology_append_stream(topology, stream) == -1) {
        ast_test_status_update(test, "Failed to append a perfectly good stream to a topology\n");
        ast_stream_free(stream);
        return AST_TEST_FAIL;
    }
 
    caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!caps) {
        ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_ulaw, 0)) {
        ast_test_status_update(test, "Failed to append a ulaw format to capabilities for channel nativeformats\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_h264, 0)) {
        ast_test_status_update(test, "Failed to append an h264 format to capabilities for channel nativeformats\n");
        return AST_TEST_FAIL;
    }
 
    mock_channel = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, "TestChannel");
    if (!mock_channel) {
        ast_test_status_update(test, "Failed to create a mock channel for testing\n");
        return AST_TEST_FAIL;
    }
 
    ast_channel_tech_set(mock_channel, &mock_channel_write_stream_tech);
    ast_channel_set_stream_topology(mock_channel, topology);
    ast_channel_nativeformats_set(mock_channel, caps);
    topology = NULL;
 
    ast_channel_tech_pvt_set(mock_channel, &pvt);
    ast_channel_unlock(mock_channel);
 
    frame.frametype = AST_FRAME_VOICE;
    frame.subclass.format = ast_format_ulaw;
    pvt.stream_num = -1;
 
    if (ast_write(mock_channel, &frame)) {
        ast_test_status_update(test, "Failed to write a ulaw frame to the mock channel when it should be fine\n");
        goto end;
    }
 
    if (pvt.wrote) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw but it ended up on the old write callback instead of write_stream\n");
        goto end;
    }
 
    if (!pvt.wrote_stream) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw but it never reached the channel driver\n");
        goto end;
    }
 
    if (pvt.stream_num != 0) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw to the default stream but it ended up on stream %d and not 0\n",
            pvt.stream_num);
        goto end;
    }
 
    pvt.wrote_stream = 0;
    pvt.stream_num = -1;
 
    if (ast_write_stream(mock_channel, 0, &frame)) {
        ast_test_status_update(test, "Failed to write a ulaw frame to the first audio stream\n");
        goto end;
    }
 
    if (pvt.wrote) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw to the first audio stream but it ended up on the old write callback instead of write_stream\n");
        goto end;
    }
 
    if (!pvt.wrote_stream) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw to the first audio stream but it never reached the channel driver\n");
        goto end;
    }
 
    if (pvt.stream_num != 0) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw to the first audio stream but it ended up on stream %d and not 0\n",
            pvt.stream_num);
        goto end;
    }
 
    pvt.wrote_stream = 0;
    pvt.stream_num = -1;
 
    if (ast_write_stream(mock_channel, 1, &frame)) {
        ast_test_status_update(test, "Failed to write a ulaw frame to the second audio stream\n");
        goto end;
    }
 
    if (pvt.wrote) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw to the second audio stream but it ended up on the old write callback instead of write_stream\n");
        goto end;
    }
 
    if (!pvt.wrote_stream) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw to the second audio stream but it never reached the channel driver\n");
        goto end;
    }
 
    if (pvt.stream_num != 1) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw to the second audio stream but it ended up on stream %d and not 1\n",
            pvt.stream_num);
        goto end;
    }
 
    pvt.wrote_stream = 0;
    pvt.stream_num = -1;
 
    frame.frametype = AST_FRAME_VIDEO;
    frame.subclass.format = ast_format_h264;
 
    if (ast_write(mock_channel, &frame)) {
        ast_test_status_update(test, "Failed to write an h264 frame to the mock channel when it should be fine\n");
        goto end;
    }
 
    if (pvt.wrote) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 but it ended up on the old write callback instead of write_stream\n");
        goto end;
    }
 
    if (!pvt.wrote_stream) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 but it never reached the channel driver\n");
        goto end;
    }
 
    if (pvt.stream_num != 2) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 to the default stream but it ended up on stream %d and not 2\n",
            pvt.stream_num);
        goto end;
    }
 
    pvt.wrote_stream = 0;
    pvt.stream_num = -1;
 
    if (ast_write_stream(mock_channel, 2, &frame)) {
        ast_test_status_update(test, "Failed to write an h264 frame to the first video stream\n");
        goto end;
    }
 
    if (pvt.wrote) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 to the first video stream but it ended up on the old write callback instead of write_stream\n");
        goto end;
    }
 
    if (!pvt.wrote_stream) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 to the first video stream but it never reached the channel driver\n");
        goto end;
    }
 
    if (pvt.stream_num != 2) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 to the first video stream but it ended up on stream %d and not 2\n",
            pvt.stream_num);
        goto end;
    }
 
    pvt.wrote_stream = 0;
    pvt.stream_num = -1;
 
    if (ast_write_stream(mock_channel, 3, &frame)) {
        ast_test_status_update(test, "Failed to write an h264 frame to the second video stream\n");
        goto end;
    }
 
    if (pvt.wrote) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 to the second video stream but it ended up on the old write callback instead of write_stream\n");
        goto end;
    }
 
    if (!pvt.wrote_stream) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 to the second video stream but it never reached the channel driver\n");
        goto end;
    }
 
    if (pvt.stream_num != 3) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 to the second video stream but it ended up on stream %d and not 3\n",
            pvt.stream_num);
        goto end;
    }
 
    pvt.wrote_stream = 0;
    pvt.stream_num = -1;
 
    if (!ast_write_stream(mock_channel, 9, &frame)) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 to a non-existent stream\n");
        goto end;
    }
 
    if (pvt.wrote) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 to a non-existent stream and it ended up on the old write callback\n");
        goto end;
    }
 
    if (pvt.wrote_stream) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 to a non-existent stream and it ended up on the write_stream callback\n");
        goto end;
    }
 
    res = AST_TEST_PASS;
 
end:
    ast_hangup(mock_channel);
 
    return res;
}

References ao2_cleanup, ast_channel_alloc, ast_channel_nativeformats_set(), ast_channel_set_stream_topology(), ast_channel_tech_pvt_set(), ast_channel_tech_set(), ast_channel_unlock, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_h264, ast_format_ulaw, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_hangup(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, AST_STATE_DOWN, ast_stream_alloc(), ast_stream_free(), ast_stream_topology_alloc(), ast_stream_topology_append_stream(), ast_stream_topology_free(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_write(), ast_write_stream(), end, ast_frame_subclass::format, ast_frame::frametype, mock_channel_write_stream_tech, NULL, RAII_VAR, mock_channel_pvt::stream_num, ast_frame::subclass, TEST_EXECUTE, TEST_INIT, mock_channel_pvt::wrote, and mock_channel_pvt::wrote_stream.

AST_TEST_DEFINE() [25/25]

AST_TEST_DEFINE

(

stream_write_non_multistream

)

Definition at line 1245 of file test_stream.c.

{
    RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
    struct ast_channel *mock_channel;
    struct mock_channel_pvt pvt = { 0, };
    enum ast_test_result_state res = AST_TEST_FAIL;
    struct ast_frame frame = { 0, };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "stream_write_non_multistream";
        info->category = "/main/stream/";
        info->summary = "stream writing to non-multistream capable channel test";
        info->description =
            "Test that writing frames to a non-multistream channel works as expected";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!caps) {
        ast_test_status_update(test, "Could not allocate an empty format capabilities structure\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_ulaw, 0)) {
        ast_test_status_update(test, "Failed to append a ulaw format to capabilities for channel nativeformats\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_format_cap_append(caps, ast_format_h264, 0)) {
        ast_test_status_update(test, "Failed to append an h264 format to capabilities for channel nativeformats\n");
        return AST_TEST_FAIL;
    }
 
    mock_channel = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, "TestChannel");
    if (!mock_channel) {
        ast_test_status_update(test, "Failed to create a mock channel for testing\n");
        return AST_TEST_FAIL;
    }
 
    ast_channel_tech_set(mock_channel, &mock_channel_old_write_tech);
    ast_channel_nativeformats_set(mock_channel, caps);
 
    pvt.wrote = 0;
    ast_channel_tech_pvt_set(mock_channel, &pvt);
    ast_channel_unlock(mock_channel);
 
    frame.frametype = AST_FRAME_VOICE;
    frame.subclass.format = ast_format_ulaw;
 
    if (ast_write(mock_channel, &frame)) {
        ast_test_status_update(test, "Failed to write a ulaw frame to the mock channel when it should be fine\n");
        goto end;
    }
 
    if (!pvt.wrote) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw but it never reached the channel driver\n");
        goto end;
    }
 
    pvt.wrote = 0;
 
    if (!ast_write_stream(mock_channel, 2, &frame) || pvt.wrote) {
        ast_test_status_update(test, "Successfully wrote a frame of ulaw to a non-existent stream\n");
        goto end;
    }
 
    frame.frametype = AST_FRAME_VIDEO;
    frame.subclass.format = ast_format_h264;
 
    if (ast_write(mock_channel, &frame)) {
        ast_test_status_update(test, "Failed to write an h264 frame to the mock channel when it should be fine\n");
        goto end;
    }
 
    if (!pvt.wrote) {
        ast_test_status_update(test, "Successfully wrote a frame of h264 but it never reached the channel driver\n");
        goto end;
    }
 
    res = AST_TEST_PASS;
 
end:
    ast_hangup(mock_channel);
 
    return res;
}

References ao2_cleanup, ast_channel_alloc, ast_channel_nativeformats_set(), ast_channel_tech_pvt_set(), ast_channel_tech_set(), ast_channel_unlock, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_h264, ast_format_ulaw, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_hangup(), AST_STATE_DOWN, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_write(), ast_write_stream(), end, ast_frame_subclass::format, ast_frame::frametype, mock_channel_old_write_tech, NULL, RAII_VAR, ast_frame::subclass, TEST_EXECUTE, TEST_INIT, and mock_channel_pvt::wrote.

check_stream_positions()

static int check_stream_positions ( struct ast_test *  test, const struct ast_stream_topology *  topology  )

static

Definition at line 650 of file test_stream.c.

{
    const struct ast_stream *stream;
    int idx;
    int pos;
    enum ast_media_type type;
 
    for (idx = 0; idx < ast_stream_topology_get_count(topology); ++idx) {
        stream = ast_stream_topology_get_stream(topology, idx);
        pos = ast_stream_get_position(stream);
        if (idx != pos) {
            type = ast_stream_get_type(stream);
            ast_test_status_update(test, "Failed: '%s' stream says it is at position %d instead of %d\n",
                ast_codec_media_type2str(type), pos, idx);
            return -1;
        }
    }
    return 0;
}

References ast_codec_media_type2str(), ast_stream_get_position(), ast_stream_get_type(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_test_status_update, and type.

Referenced by AST_TEST_DEFINE().

load_module()

static int load_module ( void  )

static

Definition at line 2284 of file test_stream.c.

{
    AST_TEST_REGISTER(stream_create);
    AST_TEST_REGISTER(stream_create_no_name);
    AST_TEST_REGISTER(stream_set_type);
    AST_TEST_REGISTER(stream_set_formats);
    AST_TEST_REGISTER(stream_set_state);
    AST_TEST_REGISTER(stream_metadata);
    AST_TEST_REGISTER(stream_topology_create);
    AST_TEST_REGISTER(stream_topology_clone);
    AST_TEST_REGISTER(stream_topology_append_stream);
    AST_TEST_REGISTER(stream_topology_set_stream);
    AST_TEST_REGISTER(stream_topology_del_stream);
    AST_TEST_REGISTER(stream_topology_create_from_format_cap);
    AST_TEST_REGISTER(stream_topology_get_first_stream_by_type);
    AST_TEST_REGISTER(stream_topology_create_from_channel_nativeformats);
    AST_TEST_REGISTER(stream_topology_channel_set);
    AST_TEST_REGISTER(stream_write_non_multistream);
    AST_TEST_REGISTER(stream_write_multistream);
    AST_TEST_REGISTER(stream_read_non_multistream);
    AST_TEST_REGISTER(stream_read_multistream);
    AST_TEST_REGISTER(stream_topology_change_request_from_application_non_multistream);
    AST_TEST_REGISTER(stream_topology_change_request_from_channel_non_multistream);
    AST_TEST_REGISTER(stream_topology_change_request_from_application);
    AST_TEST_REGISTER(stream_topology_change_request_from_channel);
    AST_TEST_REGISTER(format_cap_from_stream_topology);
    AST_TEST_REGISTER(stream_topology_map_create);
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

load_stream_readqueue()

static int load_stream_readqueue ( struct ast_channel *  chan, int  frames  )

static

Definition at line 1623 of file test_stream.c.

{
    struct mock_channel_pvt *pvt = ast_channel_tech_pvt(chan);
    struct ast_frame f = { 0, };
    struct ast_frame *frame = NULL;
    int i;
 
    while ((frame = AST_LIST_REMOVE_HEAD(ast_channel_readq(chan), frame_list)))
            ast_frfree(frame);
 
    for (i = 0; i < frames; i++) {
        if (pvt->frame_count % 2 == 0) {
            f.frametype = AST_FRAME_VOICE;
            f.subclass.format = ast_format_ulaw;
        } else {
            f.frametype = AST_FRAME_VIDEO;
            f.subclass.format = ast_format_h264;
        }
        f.stream_num = pvt->frame_count % pvt->streams;
        f.seqno = pvt->frame_count;
        ast_queue_frame(chan, &f);
        pvt->frame_count++;
    }
 
    return 0;
}

References ast_channel_readq(), ast_channel_tech_pvt(), ast_format_h264, ast_format_ulaw, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree, AST_LIST_REMOVE_HEAD, ast_queue_frame(), ast_frame_subclass::format, mock_channel_pvt::frame_count, frames, ast_frame::frametype, NULL, ast_frame::seqno, ast_frame::stream_num, mock_channel_pvt::streams, and ast_frame::subclass.

Referenced by read_test().

make_channel()

static struct ast_channel * make_channel ( struct ast_test *  test, int  streams, struct ast_channel_tech *  tech  )

static

Definition at line 1650 of file test_stream.c.

{
    RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
    struct ast_channel *mock_channel = NULL;
    struct mock_channel_pvt *pvt = NULL;
    struct ast_stream_topology *topology = NULL;
    struct ast_stream *stream;
    enum ast_test_result_state res = AST_TEST_PASS;
    int i;
 
    mock_channel = ast_channel_alloc(0, AST_STATE_DOWN, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, "TestChannel");
    ast_test_validate_cleanup(test, mock_channel, res, done);
    ast_channel_tech_set(mock_channel, tech);
 
    if (tech->read_stream) {
        topology = ast_stream_topology_alloc();
        ast_test_validate_cleanup(test, topology, res, done);
 
        for (i = 0; i < streams; i++) {
            stream = ast_stream_alloc((i % 2 ? "video": "audio"), (i % 2 ? AST_MEDIA_TYPE_VIDEO : AST_MEDIA_TYPE_AUDIO));
            ast_test_validate_cleanup(test, stream, res, done);
            ast_test_validate_cleanup(test, ast_stream_topology_append_stream(topology, stream) == i, res, done);
        }
        ast_test_validate_cleanup(test, ast_stream_topology_get_count(topology) == streams, res, done);
        ast_channel_set_stream_topology(mock_channel, topology);
        topology = NULL;
    } else {
        caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
        ast_test_validate_cleanup(test, caps, res, done);
 
        ast_test_validate_cleanup(test, ast_format_cap_append(caps, ast_format_ulaw, 0) == 0, res, done);
        ast_test_validate_cleanup(test, ast_format_cap_append(caps, ast_format_h264, 0) == 0, res, done);
        ast_channel_nativeformats_set(mock_channel, caps);
    }
 
    pvt = ast_calloc(1, sizeof(*pvt));
    ast_test_validate_cleanup(test, pvt, res, done);
    pvt->mallocd = 1;
    ast_channel_tech_pvt_set(mock_channel, pvt);
 
    ast_channel_unlock(mock_channel);
 
done:
    ast_stream_topology_free(topology);
    if (res == AST_TEST_FAIL && mock_channel) {
        ast_hangup(mock_channel);
    }
 
    return mock_channel;
}

References ao2_cleanup, ast_calloc, ast_channel_alloc, ast_channel_nativeformats_set(), ast_channel_set_stream_topology(), ast_channel_tech_pvt_set(), ast_channel_tech_set(), ast_channel_unlock, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_h264, ast_format_ulaw, ast_hangup(), AST_MEDIA_TYPE_AUDIO, AST_MEDIA_TYPE_VIDEO, AST_STATE_DOWN, ast_stream_alloc(), ast_stream_topology_alloc(), ast_stream_topology_append_stream(), ast_stream_topology_free(), ast_stream_topology_get_count(), AST_TEST_FAIL, AST_TEST_PASS, done, mock_channel_pvt::mallocd, NULL, RAII_VAR, and ast_channel_tech::read_stream.

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

mock_channel_hangup()

static int mock_channel_hangup ( struct ast_channel *  chan )

static

Definition at line 1227 of file test_stream.c.

{
    struct mock_channel_pvt *pvt = ast_channel_tech_pvt(chan);
 
    if (pvt->mallocd) {
        ast_free(pvt);
    }
 
    ast_channel_tech_pvt_set(chan, NULL);
    return 0;
}

References ast_channel_tech_pvt(), ast_channel_tech_pvt_set(), ast_free, mock_channel_pvt::mallocd, and NULL.

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

mock_channel_indicate()

static int mock_channel_indicate ( struct ast_channel *  chan, int  condition, const void *  data, size_t  datalen  )

static

Definition at line 1154 of file test_stream.c.

{
    struct mock_channel_pvt *pvt = ast_channel_tech_pvt(chan);
 
    if (condition == AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE) {
        pvt->indicated_change_request = 1;
    } else if (condition == AST_CONTROL_STREAM_TOPOLOGY_CHANGED) {
        pvt->indicated_changed = 1;
    }
 
    return 0;
}

References ast_channel_tech_pvt(), AST_CONTROL_STREAM_TOPOLOGY_CHANGED, AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE, mock_channel_pvt::indicated_change_request, and mock_channel_pvt::indicated_changed.

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

mock_channel_read()

static struct ast_frame * mock_channel_read ( struct ast_channel *  chan )

static

Definition at line 1109 of file test_stream.c.

{
    struct mock_channel_pvt *pvt = ast_channel_tech_pvt(chan);
    struct ast_frame f = { 0, };
    struct ast_frame *head_frame = NULL;
    struct ast_frame *tail_frame = NULL;
    int i;
 
    if (pvt->frames_per_read == 0) {
        pvt->frames_per_read = 1;
    }
    for (i = 0; i < pvt->frames_per_read && pvt->frame_count < pvt->frame_limit; i++) {
        struct ast_frame *fr;
 
        if (pvt->frame_count % 2 == 0) {
            f.frametype = AST_FRAME_VOICE;
            f.subclass.format = ast_format_ulaw;
        } else {
            f.frametype = AST_FRAME_VIDEO;
            f.subclass.format = ast_format_h264;
        }
        f.seqno = pvt->frame_count;
        f.stream_num = pvt->frame_count % pvt->streams;
        pvt->frame_count++;
        fr = ast_frdup(&f);
        if (!head_frame) {
            head_frame = fr;
        } else  {
            tail_frame->frame_list.next = fr;
        }
        tail_frame = fr;
    }
 
    return(head_frame);
}

References ast_channel_tech_pvt(), ast_format_h264, ast_format_ulaw, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frdup, ast_frame_subclass::format, mock_channel_pvt::frame_count, mock_channel_pvt::frame_limit, ast_frame::frame_list, mock_channel_pvt::frames_per_read, ast_frame::frametype, ast_frame::next, NULL, ast_frame::seqno, ast_frame::stream_num, mock_channel_pvt::streams, and ast_frame::subclass.

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

mock_channel_write()

static int mock_channel_write ( struct ast_channel *  chan, struct ast_frame *  fr  )

static

Definition at line 1145 of file test_stream.c.

{
    struct mock_channel_pvt *pvt = ast_channel_tech_pvt(chan);
 
    pvt->wrote = 1;
 
    return 0;
}

References ast_channel_tech_pvt(), and mock_channel_pvt::wrote.

mock_channel_write_stream()

static int mock_channel_write_stream ( struct ast_channel *  chan, int  stream_num, struct ast_frame *  fr  )

static

Definition at line 1167 of file test_stream.c.

{
    struct mock_channel_pvt *pvt = ast_channel_tech_pvt(chan);
 
    pvt->wrote_stream = 1;
    pvt->stream_num = stream_num;
 
    return 0;
}

References ast_channel_tech_pvt(), mock_channel_pvt::stream_num, and mock_channel_pvt::wrote_stream.

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

read_from_chan()

static struct ast_frame * read_from_chan ( enum CHANNEL_READ_TYPE  rt, struct ast_channel *  chan  )

static

Definition at line 1707 of file test_stream.c.

{
    if (rt == CHANNEL_READ_STREAM) {
        return ast_read_stream(chan);
    } else {
        return ast_read(chan);
    }
}

References ast_read(), ast_read_stream(), and CHANNEL_READ_STREAM.

Referenced by read_test().

read_test()

static enum ast_test_result_state read_test ( struct ast_test *  test, struct ast_channel_tech *  tech, enum CHANNEL_READ_TYPE  rt, int  streams, int  frames, int  frames_per_read, int  expected_nulls  )

static

Definition at line 1716 of file test_stream.c.

{
    struct ast_channel *mock_channel;
    struct mock_channel_pvt *pvt;
    struct ast_frame *fr = NULL;
    enum ast_test_result_state res = AST_TEST_PASS;
    int i = 0;
    int null_frames = 0;
 
    ast_test_status_update(test, "ChanType: %s ReadType: %s Streams: %d Frames: %d Frames per read: %d Expected Nulls: %d\n",
            tech->read_stream ? "MULTI" : "NON-MULTI",
            rt == CHANNEL_READ_STREAM ? "STREAM" : "NON-STREAM",
            streams, frames, frames_per_read, expected_nulls);
    mock_channel = make_channel(test, 4, tech);
    ast_test_validate_cleanup(test, mock_channel, res, done);
 
    pvt = ast_channel_tech_pvt(mock_channel);
    pvt->frame_count = 0;
    pvt->frame_limit = frames;
    pvt->streams = streams;
    pvt->frames_per_read = frames_per_read;
 
    load_stream_readqueue(mock_channel, frames / 2);
    ast_channel_fdno_set(mock_channel, 0);
 
    while ((fr = read_from_chan(rt, mock_channel))) {
        ast_channel_fdno_set(mock_channel, 0);
        if (fr->frametype != AST_FRAME_NULL) {
            ast_test_validate_cleanup(test, i == fr->seqno, res, done);
            ast_test_validate_cleanup(test, fr->frametype == ( i % 2 ? AST_FRAME_VIDEO : AST_FRAME_VOICE), res, done);
            ast_test_validate_cleanup(test, fr->stream_num == ( i % streams ), res, done);
            ast_frfree(fr);
        } else {
            null_frames++;
        }
        fr = NULL;
        i++;
    }
    ast_test_validate_cleanup(test, i == frames, res, done);
    ast_test_validate_cleanup(test, null_frames == expected_nulls, res, done);
 
done:
    ast_test_status_update(test, "    Frames read: %d NULL frames: %d\n", i, null_frames);
    ast_hangup(mock_channel);
 
    return res;
}

References ast_channel_fdno_set(), ast_channel_tech_pvt(), AST_FRAME_NULL, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree, ast_hangup(), AST_TEST_PASS, ast_test_status_update, CHANNEL_READ_STREAM, done, mock_channel_pvt::frame_count, mock_channel_pvt::frame_limit, frames, mock_channel_pvt::frames_per_read, ast_frame::frametype, load_stream_readqueue(), make_channel(), NULL, read_from_chan(), ast_channel_tech::read_stream, ast_frame::seqno, ast_frame::stream_num, and mock_channel_pvt::streams.

Referenced by AST_TEST_DEFINE(), and AST_TEST_DEFINE().

unload_module()

static int unload_module ( void  )

static

Definition at line 2253 of file test_stream.c.

{
    AST_TEST_UNREGISTER(stream_create);
    AST_TEST_UNREGISTER(stream_create_no_name);
    AST_TEST_UNREGISTER(stream_set_type);
    AST_TEST_UNREGISTER(stream_set_formats);
    AST_TEST_UNREGISTER(stream_set_state);
    AST_TEST_UNREGISTER(stream_metadata);
    AST_TEST_UNREGISTER(stream_topology_create);
    AST_TEST_UNREGISTER(stream_topology_clone);
    AST_TEST_UNREGISTER(stream_topology_clone);
    AST_TEST_UNREGISTER(stream_topology_append_stream);
    AST_TEST_UNREGISTER(stream_topology_set_stream);
    AST_TEST_UNREGISTER(stream_topology_del_stream);
    AST_TEST_UNREGISTER(stream_topology_create_from_format_cap);
    AST_TEST_UNREGISTER(stream_topology_get_first_stream_by_type);
    AST_TEST_UNREGISTER(stream_topology_create_from_channel_nativeformats);
    AST_TEST_UNREGISTER(stream_topology_channel_set);
    AST_TEST_UNREGISTER(stream_write_non_multistream);
    AST_TEST_UNREGISTER(stream_write_multistream);
    AST_TEST_UNREGISTER(stream_read_non_multistream);
    AST_TEST_UNREGISTER(stream_read_multistream);
    AST_TEST_UNREGISTER(stream_topology_change_request_from_application_non_multistream);
    AST_TEST_UNREGISTER(stream_topology_change_request_from_channel_non_multistream);
    AST_TEST_UNREGISTER(stream_topology_change_request_from_application);
    AST_TEST_UNREGISTER(stream_topology_change_request_from_channel);
    AST_TEST_UNREGISTER(format_cap_from_stream_topology);
    AST_TEST_UNREGISTER(stream_topology_map_create);
    return 0;
}

References AST_TEST_UNREGISTER.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Media Stream API test module" , .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 2314 of file test_stream.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2314 of file test_stream.c.

mock_channel_old_write_tech

const struct ast_channel_tech mock_channel_old_write_tech

static

Initial value:

= {
    .write = mock_channel_write,
    .write_video = mock_channel_write,
    .hangup = mock_channel_hangup,
}

Definition at line 1239 of file test_stream.c.

                                                                   {
    .write = mock_channel_write,
    .write_video = mock_channel_write,
    .hangup = mock_channel_hangup,
};

Referenced by AST_TEST_DEFINE().

mock_channel_tech

const struct ast_channel_tech mock_channel_tech

static

Initial value:

= {
}

Definition at line 988 of file test_stream.c.

                                                         {
};

Referenced by AST_TEST_DEFINE().

mock_channel_write_stream_tech

const struct ast_channel_tech mock_channel_write_stream_tech

static

Definition at line 1335 of file test_stream.c.

                                                                      {
    .write = mock_channel_write,
    .write_video = mock_channel_write,
    .write_stream = mock_channel_write_stream,
    .read_stream = mock_channel_read,
    .hangup = mock_channel_hangup,
};

Referenced by AST_TEST_DEFINE().

mock_stream_channel_tech

const struct ast_channel_tech mock_stream_channel_tech

static

Initial value:

= {
    .read_stream = mock_channel_read,
    .write_stream = mock_channel_write_stream,
}

Definition at line 1177 of file test_stream.c.

                                                                {
    .read_stream = mock_channel_read,
    .write_stream = mock_channel_write_stream,
};

Referenced by AST_TEST_DEFINE().