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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static 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.

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

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

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

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

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

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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 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.

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.

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.

Referenced by AST_TEST_DEFINE().