1213 lines
31 KiB
C
1213 lines
31 KiB
C
/*
|
|
* Asterisk -- An open source telephony toolkit.
|
|
*
|
|
* Copyright (C) 2017, Digium Inc.
|
|
*
|
|
* Mark Michelson <mmmichelson@digium.com>
|
|
*
|
|
* See http://www.asterisk.org for more information about
|
|
* the Asterisk project. Please do not directly contact
|
|
* any of the maintainers of this project for assistance;
|
|
* the project provides a web site, mailing lists and IRC
|
|
* channels for your use.
|
|
*
|
|
* This program is free software, distributed under the terms of
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
* at the top of the source tree.
|
|
*/
|
|
|
|
/*** MODULEINFO
|
|
<depend>TEST_FRAMEWORK</depend>
|
|
<support_level>core</support_level>
|
|
***/
|
|
|
|
#include "asterisk.h"
|
|
#include "asterisk/test.h"
|
|
#include "asterisk/module.h"
|
|
#include "asterisk/sdp.h"
|
|
#include "asterisk/stream.h"
|
|
#include "asterisk/format.h"
|
|
#include "asterisk/format_cache.h"
|
|
#include "asterisk/format_cap.h"
|
|
#include "asterisk/rtp_engine.h"
|
|
|
|
static int validate_o_line(struct ast_test *test, const struct ast_sdp_o_line *o_line,
|
|
const char *sdpowner, const char *address_type, const char *address)
|
|
{
|
|
if (!o_line) {
|
|
return -1;
|
|
}
|
|
|
|
if (strcmp(o_line->username, sdpowner)) {
|
|
ast_test_status_update(test, "Expected o-line SDP owner %s but got %s\n",
|
|
sdpowner, o_line->username);
|
|
return -1;
|
|
}
|
|
|
|
if (strcmp(o_line->address_type, address_type)) {
|
|
ast_test_status_update(test, "Expected o-line SDP address type %s but got %s\n",
|
|
address_type, o_line->address_type);
|
|
return -1;
|
|
}
|
|
|
|
if (strcmp(o_line->address, address)) {
|
|
ast_test_status_update(test, "Expected o-line SDP address %s but got %s\n",
|
|
address, o_line->address);
|
|
return -1;
|
|
}
|
|
|
|
ast_test_status_update(test, "SDP o-line is as expected!\n");
|
|
return 0;
|
|
}
|
|
|
|
static int validate_c_line(struct ast_test *test, const struct ast_sdp_c_line *c_line,
|
|
const char *address_type, const char *address)
|
|
{
|
|
if (strcmp(c_line->address_type, address_type)) {
|
|
ast_test_status_update(test, "Expected c-line SDP address type %s but got %s\n",
|
|
address_type, c_line->address_type);
|
|
return -1;
|
|
}
|
|
|
|
if (strcmp(c_line->address, address)) {
|
|
ast_test_status_update(test, "Expected c-line SDP address %s but got %s\n",
|
|
address, c_line->address);
|
|
return -1;
|
|
}
|
|
|
|
ast_test_status_update(test, "SDP c-line is as expected!\n");
|
|
return 0;
|
|
}
|
|
|
|
static int validate_m_line(struct ast_test *test, const struct ast_sdp_m_line *m_line,
|
|
const char *media_type, int num_payloads)
|
|
{
|
|
if (strcmp(m_line->type, media_type)) {
|
|
ast_test_status_update(test, "Expected m-line media type %s but got %s\n",
|
|
media_type, m_line->type);
|
|
return -1;
|
|
}
|
|
|
|
if (ast_sdp_m_get_payload_count(m_line) != num_payloads) {
|
|
ast_test_status_update(test, "Expected m-line payload count %d but got %d\n",
|
|
num_payloads, ast_sdp_m_get_payload_count(m_line));
|
|
return -1;
|
|
}
|
|
|
|
ast_test_status_update(test, "SDP m-line is as expected\n");
|
|
return 0;
|
|
}
|
|
|
|
static int validate_rtpmap(struct ast_test *test, const struct ast_sdp_m_line *m_line,
|
|
const char *media_name)
|
|
{
|
|
struct ast_sdp_a_line *a_line;
|
|
int i;
|
|
|
|
for (i = 0; i < ast_sdp_m_get_a_count(m_line); ++i) {
|
|
struct ast_sdp_rtpmap *rtpmap;
|
|
int match;
|
|
|
|
a_line = ast_sdp_m_get_a(m_line, i);
|
|
if (strcmp(a_line->name, "rtpmap")) {
|
|
continue;
|
|
}
|
|
|
|
rtpmap = ast_sdp_a_get_rtpmap(a_line);
|
|
if (!rtpmap) {
|
|
return -1;
|
|
}
|
|
|
|
match = !strcmp(rtpmap->encoding_name, media_name);
|
|
|
|
ast_sdp_rtpmap_free(rtpmap);
|
|
if (match) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
ast_test_status_update(test, "Could not find rtpmap with encoding name %s\n", media_name);
|
|
|
|
return -1;
|
|
}
|
|
|
|
static enum ast_test_result_state validate_t38(struct ast_test *test, const struct ast_sdp_m_line *m_line)
|
|
{
|
|
struct ast_sdp_a_line *a_line;
|
|
|
|
a_line = ast_sdp_m_find_attribute(m_line, "T38FaxVersion", -1);
|
|
ast_test_validate(test, a_line && !strcmp(a_line->value, "0"));
|
|
|
|
a_line = ast_sdp_m_find_attribute(m_line, "T38FaxMaxBitRate", -1);
|
|
ast_test_validate(test, a_line && !strcmp(a_line->value, "14400"));
|
|
|
|
a_line = ast_sdp_m_find_attribute(m_line, "T38FaxRateManagement", -1);
|
|
ast_test_validate(test, a_line && !strcmp(a_line->value, "transferredTCF"));
|
|
|
|
return AST_TEST_PASS;
|
|
}
|
|
|
|
AST_TEST_DEFINE(invalid_rtpmap)
|
|
{
|
|
/* a=rtpmap: is already assumed. This is the part after that */
|
|
static const char *invalids[] = {
|
|
"J PCMU/8000",
|
|
"0 PCMU:8000",
|
|
"0 PCMU/EIGHT-THOUSAND",
|
|
"0 PCMU/8000million/2",
|
|
"0 PCMU//2",
|
|
"0 /8000/2",
|
|
"0 PCMU/8000/",
|
|
"0 PCMU/8000million",
|
|
};
|
|
int i;
|
|
enum ast_test_result_state res = AST_TEST_PASS;
|
|
|
|
switch(cmd) {
|
|
case TEST_INIT:
|
|
info->name = "invalid_rtpmap";
|
|
info->category = "/main/sdp/";
|
|
info->summary = "Ensure invalid rtpmaps are rejected";
|
|
info->description =
|
|
"Try to convert several invalid rtpmap attributes. If\n"
|
|
"any succeeds, the test fails.";
|
|
return AST_TEST_NOT_RUN;
|
|
case TEST_EXECUTE:
|
|
break;
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_LEN(invalids); ++i) {
|
|
struct ast_sdp_a_line *a_line;
|
|
struct ast_sdp_rtpmap *rtpmap;
|
|
|
|
a_line = ast_sdp_a_alloc("rtpmap", invalids[i]);
|
|
rtpmap = ast_sdp_a_get_rtpmap(a_line);
|
|
if (rtpmap) {
|
|
ast_test_status_update(test, "Invalid rtpmap '%s' was accepted as valid\n",
|
|
invalids[i]);
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
ast_sdp_a_free(a_line);
|
|
ast_sdp_rtpmap_free(rtpmap);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
AST_TEST_DEFINE(rtpmap)
|
|
{
|
|
static const char *valids[] = {
|
|
"0 PCMU/8000",
|
|
"107 opus/48000/2",
|
|
};
|
|
static int payloads[] = {
|
|
0,
|
|
107,
|
|
};
|
|
static const char *encoding_names[] = {
|
|
"PCMU",
|
|
"opus",
|
|
};
|
|
static int clock_rates[] = {
|
|
8000,
|
|
48000,
|
|
};
|
|
static const char *encoding_parameters[] = {
|
|
"",
|
|
"2",
|
|
};
|
|
int i;
|
|
enum ast_test_result_state res = AST_TEST_PASS;
|
|
|
|
switch(cmd) {
|
|
case TEST_INIT:
|
|
info->name = "rtpmap";
|
|
info->category = "/main/sdp/";
|
|
info->summary = "Ensure rtpmap attribute values are parsed correctly";
|
|
info->description =
|
|
"Parse several valid rtpmap attributes. Ensure that the parsed values\n"
|
|
"are what we expect";
|
|
return AST_TEST_NOT_RUN;
|
|
case TEST_EXECUTE:
|
|
break;
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_LEN(valids); ++i) {
|
|
struct ast_sdp_a_line *a_line;
|
|
struct ast_sdp_rtpmap *rtpmap;
|
|
|
|
a_line = ast_sdp_a_alloc("rtpmap", valids[i]);
|
|
rtpmap = ast_sdp_a_get_rtpmap(a_line);
|
|
if (!rtpmap) {
|
|
ast_test_status_update(test, "Valid rtpmap '%s' was rejected as invalid\n",
|
|
valids[i]);
|
|
res = AST_TEST_FAIL;
|
|
continue;
|
|
}
|
|
if (rtpmap->payload != payloads[i]) {
|
|
ast_test_status_update(test, "RTPmap payload '%d' does not match expected '%d'\n",
|
|
rtpmap->payload, payloads[i]);
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
if (strcmp(rtpmap->encoding_name, encoding_names[i])) {
|
|
ast_test_status_update(test, "RTPmap encoding_name '%s' does not match expected '%s'\n",
|
|
rtpmap->encoding_name, encoding_names[i]);
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
if (rtpmap->clock_rate != clock_rates[i]) {
|
|
ast_test_status_update(test, "RTPmap clock rate '%d' does not match expected '%d'\n",
|
|
rtpmap->clock_rate, clock_rates[i]);
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
if (strcmp(rtpmap->encoding_parameters, encoding_parameters[i])) {
|
|
ast_test_status_update(test, "RTPmap encoding_parameter '%s' does not match expected '%s'\n",
|
|
rtpmap->encoding_parameters, encoding_parameters[i]);
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
ast_sdp_a_free(a_line);
|
|
ast_sdp_rtpmap_free(rtpmap);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
AST_TEST_DEFINE(find_attr)
|
|
{
|
|
enum ast_test_result_state res = AST_TEST_PASS;
|
|
struct ast_sdp_m_line *m_line;
|
|
struct ast_sdp_a_line *a_line;
|
|
int idx;
|
|
|
|
switch(cmd) {
|
|
case TEST_INIT:
|
|
info->name = "find_attr";
|
|
info->category = "/main/sdp/";
|
|
info->summary = "Ensure that finding attributes works as expected";
|
|
info->description =
|
|
"A SDP m-line is created, and attributes are added.\n"
|
|
"We then attempt a series of attribute-finding calls that are expected to work\n"
|
|
"followed by a series of attribute-finding calls that are expected fo fail.";
|
|
return AST_TEST_NOT_RUN;
|
|
case TEST_EXECUTE:
|
|
break;
|
|
}
|
|
|
|
m_line = ast_sdp_m_alloc("audio", 666, 1, "RTP/AVP", NULL);
|
|
if (!m_line) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
a_line = ast_sdp_a_alloc("foo", "0 bar");
|
|
if (!a_line) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
ast_sdp_m_add_a(m_line, a_line);
|
|
a_line = ast_sdp_a_alloc("foo", "0 bee");
|
|
if (!a_line) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
ast_sdp_m_add_a(m_line, a_line);
|
|
|
|
a_line = ast_sdp_a_alloc("baz", "howdy");
|
|
if (!a_line) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
ast_sdp_m_add_a(m_line, a_line);
|
|
|
|
/* These should work */
|
|
a_line = ast_sdp_m_find_attribute(m_line, "foo", 0);
|
|
if (!a_line || strcmp(a_line->value, "0 bar")) {
|
|
ast_test_status_update(test, "Failed to find attribute 'foo' with payload '0'\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
a_line = ast_sdp_m_find_attribute(m_line, "foo", -1);
|
|
if (!a_line || strcmp(a_line->value, "0 bar")) {
|
|
ast_test_status_update(test, "Failed to find attribute 'foo' with unspecified payload\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
a_line = ast_sdp_m_find_attribute(m_line, "baz", -1);
|
|
if (!a_line || strcmp(a_line->value, "howdy")) {
|
|
ast_test_status_update(test, "Failed to find attribute 'baz' with unspecified payload\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
|
|
idx = ast_sdp_m_find_a_first(m_line, "foo", 0);
|
|
if (idx < 0) {
|
|
ast_test_status_update(test, "Failed to find first attribute 'foo' with payload '0'\n");
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
a_line = ast_sdp_m_get_a(m_line, idx);
|
|
if (!a_line || strcmp(a_line->value, "0 bar")) {
|
|
ast_test_status_update(test, "Find first attribute 'foo' with payload '0' didn't match\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
idx = ast_sdp_m_find_a_next(m_line, idx, "foo", 0);
|
|
if (idx < 0) {
|
|
ast_test_status_update(test, "Failed to find next attribute 'foo' with payload '0'\n");
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
a_line = ast_sdp_m_get_a(m_line, idx);
|
|
if (!a_line || strcmp(a_line->value, "0 bee")) {
|
|
ast_test_status_update(test, "Find next attribute 'foo' with payload '0' didn't match\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
idx = ast_sdp_m_find_a_next(m_line, idx, "foo", 0);
|
|
if (0 <= idx) {
|
|
ast_test_status_update(test, "Find next attribute 'foo' with payload '0' found too many\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
|
|
idx = ast_sdp_m_find_a_first(m_line, "foo", -1);
|
|
if (idx < 0) {
|
|
ast_test_status_update(test, "Failed to find first attribute 'foo' with unspecified payload\n");
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
a_line = ast_sdp_m_get_a(m_line, idx);
|
|
if (!a_line || strcmp(a_line->value, "0 bar")) {
|
|
ast_test_status_update(test, "Find first attribute 'foo' with unspecified payload didn't match\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
idx = ast_sdp_m_find_a_next(m_line, idx, "foo", -1);
|
|
if (idx < 0) {
|
|
ast_test_status_update(test, "Failed to find next attribute 'foo' with unspecified payload\n");
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
a_line = ast_sdp_m_get_a(m_line, idx);
|
|
if (!a_line || strcmp(a_line->value, "0 bee")) {
|
|
ast_test_status_update(test, "Find next attribute 'foo' with unspecified payload didn't match\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
idx = ast_sdp_m_find_a_next(m_line, idx, "foo", -1);
|
|
if (0 <= idx) {
|
|
ast_test_status_update(test, "Find next attribute 'foo' with unspecified payload found too many\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
|
|
/* These should fail */
|
|
a_line = ast_sdp_m_find_attribute(m_line, "foo", 1);
|
|
if (a_line) {
|
|
ast_test_status_update(test, "Found non-existent attribute 'foo' with payload '1'\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
a_line = ast_sdp_m_find_attribute(m_line, "baz", 0);
|
|
if (a_line) {
|
|
ast_test_status_update(test, "Found non-existent attribute 'baz' with payload '0'\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
a_line = ast_sdp_m_find_attribute(m_line, "wibble", 0);
|
|
if (a_line) {
|
|
ast_test_status_update(test, "Found non-existent attribute 'wibble' with payload '0'\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
a_line = ast_sdp_m_find_attribute(m_line, "wibble", -1);
|
|
if (a_line) {
|
|
ast_test_status_update(test, "Found non-existent attribute 'wibble' with unspecified payload\n");
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
|
|
end:
|
|
ast_sdp_m_free(m_line);
|
|
return res;
|
|
}
|
|
|
|
static struct ast_sdp_options *sdp_options_common(void)
|
|
{
|
|
struct ast_sdp_options *options;
|
|
|
|
options = ast_sdp_options_alloc();
|
|
if (!options) {
|
|
return NULL;
|
|
}
|
|
ast_sdp_options_set_media_address(options, "127.0.0.1");
|
|
ast_sdp_options_set_sdpowner(options, "me");
|
|
ast_sdp_options_set_rtp_engine(options, "asterisk");
|
|
ast_sdp_options_set_impl(options, AST_SDP_IMPL_PJMEDIA);
|
|
|
|
return options;
|
|
}
|
|
|
|
struct sdp_format {
|
|
enum ast_media_type type;
|
|
const char *formats;
|
|
};
|
|
|
|
/*!
|
|
* \brief Common method to build an SDP state for a test.
|
|
*
|
|
* This uses the passed-in formats to create a stream topology, which is then used to create the SDP
|
|
* state.
|
|
*
|
|
* There is an optional test_options field you can use if your test has specific options you need to
|
|
* set. If your test does not require anything special, it can just pass NULL for this parameter. If
|
|
* you do pass in test_options, this function steals ownership of those options.
|
|
*
|
|
* \param num_streams The number of elements in the formats array.
|
|
* \param formats Array of media types and formats that will be in the state.
|
|
* \param test_options Optional SDP options.
|
|
*/
|
|
static struct ast_sdp_state *build_sdp_state(int num_streams, const struct sdp_format *formats, struct ast_sdp_options *test_options)
|
|
{
|
|
struct ast_stream_topology *topology = NULL;
|
|
struct ast_sdp_state *state = NULL;
|
|
struct ast_sdp_options *options;
|
|
int i;
|
|
|
|
if (!test_options) {
|
|
options = sdp_options_common();
|
|
if (!options) {
|
|
goto end;
|
|
}
|
|
} else {
|
|
options = test_options;
|
|
}
|
|
|
|
topology = ast_stream_topology_alloc();
|
|
if (!topology) {
|
|
goto end;
|
|
}
|
|
|
|
for (i = 0; i < num_streams; ++i) {
|
|
RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
|
|
struct ast_stream *stream;
|
|
|
|
caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
|
|
if (!caps) {
|
|
goto end;
|
|
}
|
|
if (ast_format_cap_update_by_allow_disallow(caps, formats[i].formats, 1) < 0) {
|
|
goto end;
|
|
}
|
|
stream = ast_stream_alloc("sure_thing", formats[i].type);
|
|
if (!stream) {
|
|
goto end;
|
|
}
|
|
ast_stream_set_formats(stream, caps);
|
|
ast_stream_topology_append_stream(topology, stream);
|
|
}
|
|
|
|
state = ast_sdp_state_alloc(topology, options);
|
|
if (!state) {
|
|
goto end;
|
|
}
|
|
|
|
end:
|
|
ast_stream_topology_free(topology);
|
|
if (!state) {
|
|
ast_sdp_options_free(options);
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
AST_TEST_DEFINE(topology_to_sdp)
|
|
{
|
|
enum ast_test_result_state res = AST_TEST_FAIL;
|
|
struct ast_sdp_state *sdp_state = NULL;
|
|
const struct ast_sdp *sdp = NULL;
|
|
struct ast_sdp_m_line *m_line = NULL;
|
|
struct sdp_format formats[] = {
|
|
{ AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
|
|
{ AST_MEDIA_TYPE_VIDEO, "h264,vp8" },
|
|
{ AST_MEDIA_TYPE_IMAGE, "t38" },
|
|
};
|
|
|
|
switch(cmd) {
|
|
case TEST_INIT:
|
|
info->name = "topology_to_sdp";
|
|
info->category = "/main/sdp/";
|
|
info->summary = "Convert a topology into an SDP";
|
|
info->description =
|
|
"Ensure SDPs get converted to expected stream topology";
|
|
return AST_TEST_NOT_RUN;
|
|
case TEST_EXECUTE:
|
|
break;
|
|
}
|
|
|
|
sdp_state = build_sdp_state(ARRAY_LEN(formats), formats, NULL);
|
|
if (!sdp_state) {
|
|
goto end;
|
|
}
|
|
|
|
sdp = ast_sdp_state_get_local_sdp(sdp_state);
|
|
if (!sdp) {
|
|
goto end;
|
|
}
|
|
|
|
if (validate_o_line(test, sdp->o_line, "me", "IP4", "127.0.0.1")) {
|
|
goto end;
|
|
}
|
|
|
|
if (validate_c_line(test, sdp->c_line, "IP4", "127.0.0.1")) {
|
|
goto end;
|
|
}
|
|
|
|
if (ast_sdp_get_m_count(sdp) != 3) {
|
|
ast_test_status_update(test, "Unexpected number of streams in generated SDP: %d\n",
|
|
ast_sdp_get_m_count(sdp));
|
|
goto end;
|
|
}
|
|
|
|
m_line = ast_sdp_get_m(sdp, 0);
|
|
|
|
if (validate_m_line(test, m_line, "audio", 4)) {
|
|
goto end;
|
|
}
|
|
|
|
if (validate_rtpmap(test, m_line, "PCMU")) {
|
|
goto end;
|
|
}
|
|
|
|
if (validate_rtpmap(test, m_line, "PCMA")) {
|
|
goto end;
|
|
}
|
|
|
|
if (validate_rtpmap(test, m_line, "G722")) {
|
|
goto end;
|
|
}
|
|
|
|
if (validate_rtpmap(test, m_line, "opus")) {
|
|
goto end;
|
|
}
|
|
|
|
m_line = ast_sdp_get_m(sdp, 1);
|
|
if (validate_m_line(test, m_line, "video", 2)) {
|
|
goto end;
|
|
}
|
|
|
|
if (validate_rtpmap(test, m_line, "VP8")) {
|
|
goto end;
|
|
}
|
|
|
|
if (validate_rtpmap(test, m_line, "H264")) {
|
|
goto end;
|
|
}
|
|
|
|
m_line = ast_sdp_get_m(sdp, 2);
|
|
if (validate_m_line(test, m_line, "image", 1)) {
|
|
goto end;
|
|
}
|
|
if (validate_t38(test, m_line) != AST_TEST_PASS) {
|
|
goto end;
|
|
}
|
|
|
|
res = AST_TEST_PASS;
|
|
|
|
end:
|
|
ast_sdp_state_free(sdp_state);
|
|
return res;
|
|
}
|
|
|
|
static int validate_formats(struct ast_test *test, struct ast_stream_topology *topology, int index,
|
|
enum ast_media_type type, int format_count, const char **expected_formats)
|
|
{
|
|
struct ast_stream *stream;
|
|
struct ast_format_cap *caps;
|
|
struct ast_format *format;
|
|
int i;
|
|
|
|
stream = ast_stream_topology_get_stream(topology, index);
|
|
if (ast_stream_get_type(stream) != type) {
|
|
ast_test_status_update(test, "Unexpected stream type encountered\n");
|
|
return -1;
|
|
}
|
|
caps = ast_stream_get_formats(stream);
|
|
|
|
if (ast_format_cap_count(caps) != format_count) {
|
|
ast_test_status_update(test, "Unexpected format count '%d'. Expecting '%d'\n",
|
|
(int) ast_format_cap_count(caps), format_count);
|
|
return -1;
|
|
}
|
|
|
|
for (i = 0; i < ast_format_cap_count(caps); ++i) {
|
|
format = ast_format_cap_get_format(caps, i);
|
|
if (strcmp(ast_format_get_name(format), expected_formats[i])) {
|
|
ast_test_status_update(test, "Unexpected format '%s'at index %d. Expected '%s'\n",
|
|
ast_format_get_name(format), i, expected_formats[i]);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
AST_TEST_DEFINE(sdp_to_topology)
|
|
{
|
|
enum ast_test_result_state res = AST_TEST_PASS;
|
|
struct ast_sdp_state *sdp_state;
|
|
const struct ast_sdp *sdp;
|
|
struct ast_stream_topology *topology = NULL;
|
|
struct sdp_format sdp_formats[] = {
|
|
{ AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
|
|
{ AST_MEDIA_TYPE_VIDEO, "h264,vp8" },
|
|
{ AST_MEDIA_TYPE_IMAGE, "t38" },
|
|
};
|
|
static const char *expected_audio_formats[] = {
|
|
"ulaw",
|
|
"alaw",
|
|
"g722",
|
|
"opus",
|
|
};
|
|
static const char *expected_video_formats[] = {
|
|
"h264",
|
|
"vp8",
|
|
};
|
|
static const char *expected_image_formats[] = {
|
|
"t38",
|
|
};
|
|
|
|
switch(cmd) {
|
|
case TEST_INIT:
|
|
info->name = "sdp_to_topology";
|
|
info->category = "/main/sdp/";
|
|
info->summary = "Convert an SDP into a topology";
|
|
info->description =
|
|
"Ensure SDPs get converted to expected stream topology";
|
|
return AST_TEST_NOT_RUN;
|
|
case TEST_EXECUTE:
|
|
break;
|
|
}
|
|
|
|
sdp_state = build_sdp_state(ARRAY_LEN(sdp_formats), sdp_formats, NULL);
|
|
if (!sdp_state) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
sdp = ast_sdp_state_get_local_sdp(sdp_state);
|
|
if (!sdp) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
topology = ast_get_topology_from_sdp(sdp, 0);
|
|
if (!topology) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
if (ast_stream_topology_get_count(topology) != 3) {
|
|
ast_test_status_update(test, "Unexpected topology count '%d'. Expecting 3\n",
|
|
ast_stream_topology_get_count(topology));
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
if (validate_formats(test, topology, 0, AST_MEDIA_TYPE_AUDIO,
|
|
ARRAY_LEN(expected_audio_formats), expected_audio_formats)) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
if (validate_formats(test, topology, 1, AST_MEDIA_TYPE_VIDEO,
|
|
ARRAY_LEN(expected_video_formats), expected_video_formats)) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
if (validate_formats(test, topology, 2, AST_MEDIA_TYPE_IMAGE,
|
|
ARRAY_LEN(expected_image_formats), expected_image_formats)) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
end:
|
|
ast_sdp_state_free(sdp_state);
|
|
ast_stream_topology_free(topology);
|
|
return res;
|
|
}
|
|
|
|
static int validate_merged_sdp(struct ast_test *test, const struct ast_sdp *sdp)
|
|
{
|
|
struct ast_sdp_m_line *m_line;
|
|
|
|
if (!sdp) {
|
|
return -1;
|
|
}
|
|
|
|
m_line = ast_sdp_get_m(sdp, 0);
|
|
if (validate_m_line(test, m_line, "audio", 1)) {
|
|
return -1;
|
|
}
|
|
if (validate_rtpmap(test, m_line, "PCMU")) {
|
|
return -1;
|
|
}
|
|
|
|
/* The other audio formats should *NOT* be present */
|
|
if (!validate_rtpmap(test, m_line, "PCMA")) {
|
|
return -1;
|
|
}
|
|
if (!validate_rtpmap(test, m_line, "G722")) {
|
|
return -1;
|
|
}
|
|
if (!validate_rtpmap(test, m_line, "opus")) {
|
|
return -1;
|
|
}
|
|
|
|
m_line = ast_sdp_get_m(sdp, 1);
|
|
if (validate_m_line(test, m_line, "video", 1)) {
|
|
return -1;
|
|
}
|
|
if (validate_rtpmap(test, m_line, "VP8")) {
|
|
return -1;
|
|
}
|
|
if (!validate_rtpmap(test, m_line, "H264")) {
|
|
return -1;
|
|
}
|
|
|
|
m_line = ast_sdp_get_m(sdp, 2);
|
|
if (validate_m_line(test, m_line, "image", 1)) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
AST_TEST_DEFINE(sdp_merge_symmetric)
|
|
{
|
|
enum ast_test_result_state res = AST_TEST_PASS;
|
|
struct ast_sdp_state *sdp_state_offerer = NULL;
|
|
struct ast_sdp_state *sdp_state_answerer = NULL;
|
|
const struct ast_sdp *offerer_sdp;
|
|
const struct ast_sdp *answerer_sdp;
|
|
|
|
static const struct sdp_format offerer_formats[] = {
|
|
{ AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
|
|
{ AST_MEDIA_TYPE_VIDEO, "h264,vp8" },
|
|
{ AST_MEDIA_TYPE_IMAGE, "t38" },
|
|
};
|
|
static const struct sdp_format answerer_formats[] = {
|
|
{ AST_MEDIA_TYPE_AUDIO, "ulaw" },
|
|
{ AST_MEDIA_TYPE_VIDEO, "vp8" },
|
|
{ AST_MEDIA_TYPE_IMAGE, "t38" },
|
|
};
|
|
|
|
switch(cmd) {
|
|
case TEST_INIT:
|
|
info->name = "sdp_merge_symmetric";
|
|
info->category = "/main/sdp/";
|
|
info->summary = "Merge two SDPs with symmetric stream types";
|
|
info->description =
|
|
"SDPs 1 and 2 each have one audio and one video stream (in that order).\n"
|
|
"SDP 1 offers to SDP 2, who answers. We ensure that both local SDPs have\n"
|
|
"the expected stream types and the expected formats";
|
|
return AST_TEST_NOT_RUN;
|
|
case TEST_EXECUTE:
|
|
break;
|
|
}
|
|
|
|
sdp_state_offerer = build_sdp_state(ARRAY_LEN(offerer_formats), offerer_formats, NULL);
|
|
if (!sdp_state_offerer) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
sdp_state_answerer = build_sdp_state(ARRAY_LEN(answerer_formats), answerer_formats, NULL);
|
|
if (!sdp_state_answerer) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
|
|
if (!offerer_sdp) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
ast_sdp_state_set_remote_sdp(sdp_state_answerer, offerer_sdp);
|
|
answerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_answerer);
|
|
if (!answerer_sdp) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
ast_sdp_state_set_remote_sdp(sdp_state_offerer, answerer_sdp);
|
|
|
|
/* Get the offerer SDP again because it's now going to be the joint SDP */
|
|
offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
|
|
if (validate_merged_sdp(test, offerer_sdp)) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
if (validate_merged_sdp(test, answerer_sdp)) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
end:
|
|
ast_sdp_state_free(sdp_state_offerer);
|
|
ast_sdp_state_free(sdp_state_answerer);
|
|
|
|
return res;
|
|
}
|
|
|
|
AST_TEST_DEFINE(sdp_merge_crisscross)
|
|
{
|
|
enum ast_test_result_state res = AST_TEST_PASS;
|
|
struct ast_sdp_state *sdp_state_offerer = NULL;
|
|
struct ast_sdp_state *sdp_state_answerer = NULL;
|
|
const struct ast_sdp *offerer_sdp;
|
|
const struct ast_sdp *answerer_sdp;
|
|
|
|
static const struct sdp_format offerer_formats[] = {
|
|
{ AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
|
|
{ AST_MEDIA_TYPE_VIDEO, "h264,vp8" },
|
|
{ AST_MEDIA_TYPE_IMAGE, "t38" },
|
|
};
|
|
static const struct sdp_format answerer_formats[] = {
|
|
{ AST_MEDIA_TYPE_IMAGE, "t38" },
|
|
{ AST_MEDIA_TYPE_VIDEO, "vp8" },
|
|
{ AST_MEDIA_TYPE_AUDIO, "ulaw" },
|
|
};
|
|
|
|
switch(cmd) {
|
|
case TEST_INIT:
|
|
info->name = "sdp_merge_crisscross";
|
|
info->category = "/main/sdp/";
|
|
info->summary = "Merge two SDPs with symmetric stream types";
|
|
info->description =
|
|
"SDPs 1 and 2 each have one audio and one video stream. However, SDP 1 and\n"
|
|
"2 natively have the formats in a different order.\n"
|
|
"SDP 1 offers to SDP 2, who answers. We ensure that both local SDPs have\n"
|
|
"the expected stream types and the expected formats. Since SDP 1 was the\n"
|
|
"offerer, the format order on SDP 1 should determine the order of formats in the SDPs";
|
|
return AST_TEST_NOT_RUN;
|
|
case TEST_EXECUTE:
|
|
break;
|
|
}
|
|
|
|
sdp_state_offerer = build_sdp_state(ARRAY_LEN(offerer_formats), offerer_formats, NULL);
|
|
if (!sdp_state_offerer) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
sdp_state_answerer = build_sdp_state(ARRAY_LEN(answerer_formats), answerer_formats, NULL);
|
|
if (!sdp_state_answerer) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
|
|
if (!offerer_sdp) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
ast_sdp_state_set_remote_sdp(sdp_state_answerer, offerer_sdp);
|
|
answerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_answerer);
|
|
if (!answerer_sdp) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
ast_sdp_state_set_remote_sdp(sdp_state_offerer, answerer_sdp);
|
|
|
|
/* Get the offerer SDP again because it's now going to be the joint SDP */
|
|
offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
|
|
if (validate_merged_sdp(test, offerer_sdp)) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
if (validate_merged_sdp(test, answerer_sdp)) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
end:
|
|
ast_sdp_state_free(sdp_state_offerer);
|
|
ast_sdp_state_free(sdp_state_answerer);
|
|
|
|
return res;
|
|
}
|
|
|
|
static int validate_merged_sdp_asymmetric(struct ast_test *test, const struct ast_sdp *sdp, int is_offer)
|
|
{
|
|
struct ast_sdp_m_line *m_line;
|
|
const char *side = is_offer ? "Offer side" : "Answer side";
|
|
|
|
if (!sdp) {
|
|
ast_test_status_update(test, "%s does not have a SDP\n", side);
|
|
return -1;
|
|
}
|
|
|
|
/* Stream 0 */
|
|
m_line = ast_sdp_get_m(sdp, 0);
|
|
if (validate_m_line(test, m_line, "audio", 1)) {
|
|
return -1;
|
|
}
|
|
if (!m_line->port) {
|
|
ast_test_status_update(test, "%s stream %d does%s have a port\n", side, 0, "n't");
|
|
return -1;
|
|
}
|
|
if (validate_rtpmap(test, m_line, "PCMU")) {
|
|
return -1;
|
|
}
|
|
|
|
/* The other audio formats should *NOT* be present */
|
|
if (!validate_rtpmap(test, m_line, "PCMA")) {
|
|
return -1;
|
|
}
|
|
if (!validate_rtpmap(test, m_line, "G722")) {
|
|
return -1;
|
|
}
|
|
if (!validate_rtpmap(test, m_line, "opus")) {
|
|
return -1;
|
|
}
|
|
|
|
/* The remaining streams should be declined */
|
|
|
|
/* Stream 1 */
|
|
m_line = ast_sdp_get_m(sdp, 1);
|
|
if (validate_m_line(test, m_line, "audio", 1)) {
|
|
return -1;
|
|
}
|
|
if (m_line->port) {
|
|
ast_test_status_update(test, "%s stream %d does%s have a port\n", side, 1, "");
|
|
return -1;
|
|
}
|
|
|
|
/* Stream 2 */
|
|
m_line = ast_sdp_get_m(sdp, 2);
|
|
if (validate_m_line(test, m_line, "video", 1)) {
|
|
return -1;
|
|
}
|
|
if (m_line->port) {
|
|
ast_test_status_update(test, "%s stream %d does%s have a port\n", side, 2, "");
|
|
return -1;
|
|
}
|
|
|
|
/* Stream 3 */
|
|
m_line = ast_sdp_get_m(sdp, 3);
|
|
if (validate_m_line(test, m_line, "image", 1)) {
|
|
return -1;
|
|
}
|
|
if (m_line->port) {
|
|
ast_test_status_update(test, "%s stream %d does%s have a port\n", side, 3, "");
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
AST_TEST_DEFINE(sdp_merge_asymmetric)
|
|
{
|
|
enum ast_test_result_state res = AST_TEST_PASS;
|
|
struct ast_sdp_state *sdp_state_offerer = NULL;
|
|
struct ast_sdp_state *sdp_state_answerer = NULL;
|
|
const struct ast_sdp *offerer_sdp;
|
|
const struct ast_sdp *answerer_sdp;
|
|
|
|
static const struct sdp_format offerer_formats[] = {
|
|
{ AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
|
|
{ AST_MEDIA_TYPE_AUDIO, "ulaw" },
|
|
{ AST_MEDIA_TYPE_VIDEO, "h261" },
|
|
{ AST_MEDIA_TYPE_IMAGE, "t38" },
|
|
};
|
|
static const struct sdp_format answerer_formats[] = {
|
|
{ AST_MEDIA_TYPE_AUDIO, "ulaw" },
|
|
};
|
|
|
|
switch(cmd) {
|
|
case TEST_INIT:
|
|
info->name = "sdp_merge_asymmetric";
|
|
info->category = "/main/sdp/";
|
|
info->summary = "Merge two SDPs with an asymmetric number of streams";
|
|
info->description =
|
|
"SDP 1 offers a four stream topology: Audio,Audio,Video,T.38\n"
|
|
"SDP 2 only has a single audio stream topology\n"
|
|
"We ensure that both local SDPs have the expected stream types and\n"
|
|
"the expected declined streams";
|
|
return AST_TEST_NOT_RUN;
|
|
case TEST_EXECUTE:
|
|
break;
|
|
}
|
|
|
|
sdp_state_offerer = build_sdp_state(ARRAY_LEN(offerer_formats), offerer_formats, NULL);
|
|
if (!sdp_state_offerer) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
sdp_state_answerer = build_sdp_state(ARRAY_LEN(answerer_formats), answerer_formats, NULL);
|
|
if (!sdp_state_answerer) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
|
|
if (!offerer_sdp) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
ast_sdp_state_set_remote_sdp(sdp_state_answerer, offerer_sdp);
|
|
answerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_answerer);
|
|
if (!answerer_sdp) {
|
|
res = AST_TEST_FAIL;
|
|
goto end;
|
|
}
|
|
|
|
ast_sdp_state_set_remote_sdp(sdp_state_offerer, answerer_sdp);
|
|
|
|
#if defined(XXX_TODO_NEED_TO_HANDLE_DECLINED_STREAMS_ON_OFFER_SIDE)
|
|
/* Get the offerer SDP again because it's now going to be the joint SDP */
|
|
offerer_sdp = ast_sdp_state_get_local_sdp(sdp_state_offerer);
|
|
if (validate_merged_sdp_asymmetric(test, offerer_sdp, 1)) {
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
#endif
|
|
if (validate_merged_sdp_asymmetric(test, answerer_sdp, 0)) {
|
|
res = AST_TEST_FAIL;
|
|
}
|
|
|
|
end:
|
|
ast_sdp_state_free(sdp_state_offerer);
|
|
ast_sdp_state_free(sdp_state_answerer);
|
|
|
|
return res;
|
|
}
|
|
|
|
static int validate_ssrc(struct ast_test *test, struct ast_sdp_m_line *m_line,
|
|
struct ast_rtp_instance *rtp)
|
|
{
|
|
unsigned int ssrc;
|
|
const char *cname;
|
|
struct ast_sdp_a_line *a_line;
|
|
char attr_value[128];
|
|
|
|
ssrc = ast_rtp_instance_get_ssrc(rtp);
|
|
cname = ast_rtp_instance_get_cname(rtp);
|
|
|
|
snprintf(attr_value, sizeof(attr_value), "%u cname:%s", ssrc, cname);
|
|
|
|
a_line = ast_sdp_m_find_attribute(m_line, "ssrc", -1);
|
|
if (!a_line) {
|
|
ast_test_status_update(test, "Could not find 'ssrc' attribute\n");
|
|
return -1;
|
|
}
|
|
|
|
if (strcmp(a_line->value, attr_value)) {
|
|
ast_test_status_update(test, "SDP attribute '%s' did not match expected attribute '%s'\n",
|
|
a_line->value, attr_value);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
AST_TEST_DEFINE(sdp_ssrc_attributes)
|
|
{
|
|
enum ast_test_result_state res;
|
|
struct ast_sdp_state *test_state = NULL;
|
|
struct ast_sdp_options *options;
|
|
struct sdp_format formats[] = {
|
|
{ AST_MEDIA_TYPE_AUDIO, "ulaw,alaw,g722,opus" },
|
|
};
|
|
const struct ast_sdp *sdp;
|
|
struct ast_sdp_m_line *m_line;
|
|
struct ast_rtp_instance *rtp;
|
|
|
|
switch(cmd) {
|
|
case TEST_INIT:
|
|
info->name = "sdp_ssrc_attributes";
|
|
info->category = "/main/sdp/";
|
|
info->summary = "Ensure SSRC-level attributes are added to local SDPs";
|
|
info->description =
|
|
"An SDP is created and is instructed to include SSRC-level attributes.\n"
|
|
"This test ensures that the CNAME SSRC-level attribute is present and\n"
|
|
"that the values match what the RTP instance reports";
|
|
return AST_TEST_NOT_RUN;
|
|
case TEST_EXECUTE:
|
|
break;
|
|
}
|
|
|
|
res = AST_TEST_FAIL;
|
|
|
|
options = sdp_options_common();
|
|
if (!options) {
|
|
ast_test_status_update(test, "Failed to allocate SDP options\n");
|
|
goto end;
|
|
}
|
|
ast_sdp_options_set_ssrc(options, 1);
|
|
|
|
test_state = build_sdp_state(ARRAY_LEN(formats), formats, options);
|
|
if (!test_state) {
|
|
ast_test_status_update(test, "Failed to create SDP state\n");
|
|
goto end;
|
|
}
|
|
|
|
sdp = ast_sdp_state_get_local_sdp(test_state);
|
|
if (!sdp) {
|
|
ast_test_status_update(test, "Failed to get local SDP\n");
|
|
goto end;
|
|
}
|
|
|
|
/* Need a couple of sanity checks */
|
|
if (ast_sdp_get_m_count(sdp) != ARRAY_LEN(formats)) {
|
|
ast_test_status_update(test, "SDP m count is %d instead of %zu\n",
|
|
ast_sdp_get_m_count(sdp), ARRAY_LEN(formats));
|
|
goto end;
|
|
}
|
|
|
|
m_line = ast_sdp_get_m(sdp, 0);
|
|
if (!m_line) {
|
|
ast_test_status_update(test, "Failed to get SDP m-line\n");
|
|
goto end;
|
|
}
|
|
|
|
rtp = ast_sdp_state_get_rtp_instance(test_state, 0);
|
|
if (!rtp) {
|
|
ast_test_status_update(test, "Failed to get the RTP instance\n");
|
|
goto end;
|
|
}
|
|
|
|
if (validate_ssrc(test, m_line, rtp)) {
|
|
goto end;
|
|
}
|
|
|
|
res = AST_TEST_PASS;
|
|
|
|
end:
|
|
ast_sdp_state_free(test_state);
|
|
return res;
|
|
}
|
|
|
|
static int unload_module(void)
|
|
{
|
|
AST_TEST_UNREGISTER(invalid_rtpmap);
|
|
AST_TEST_UNREGISTER(rtpmap);
|
|
AST_TEST_UNREGISTER(find_attr);
|
|
AST_TEST_UNREGISTER(topology_to_sdp);
|
|
AST_TEST_UNREGISTER(sdp_to_topology);
|
|
AST_TEST_UNREGISTER(sdp_merge_symmetric);
|
|
AST_TEST_UNREGISTER(sdp_merge_crisscross);
|
|
AST_TEST_UNREGISTER(sdp_merge_asymmetric);
|
|
AST_TEST_UNREGISTER(sdp_ssrc_attributes);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int load_module(void)
|
|
{
|
|
AST_TEST_REGISTER(invalid_rtpmap);
|
|
AST_TEST_REGISTER(rtpmap);
|
|
AST_TEST_REGISTER(find_attr);
|
|
AST_TEST_REGISTER(topology_to_sdp);
|
|
AST_TEST_REGISTER(sdp_to_topology);
|
|
AST_TEST_REGISTER(sdp_merge_symmetric);
|
|
AST_TEST_REGISTER(sdp_merge_crisscross);
|
|
AST_TEST_REGISTER(sdp_merge_asymmetric);
|
|
AST_TEST_REGISTER(sdp_ssrc_attributes);
|
|
|
|
return AST_MODULE_LOAD_SUCCESS;
|
|
}
|
|
|
|
AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "SDP tests");
|