/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <string>
#define GTEST_HAS_RTTI
0
#include "gtest/gtest.h"
#include "nss.h"
#include "ssl.h"
#include "sdp/RsdparsaSdpParser.h"
#include "sdp/SipccSdpParser.h"
#include "sdp/SdpMediaSection.h"
#include "sdp/SdpAttribute.h"
#include "sdp/ParsingResultComparer.h"
extern "C" {
#include "sipcc_sdp.h"
#include "sdp_private.h"
}
#ifdef CRLF
# undef CRLF
#endif
#define CRLF
"\r\n"
#define SKIP_TEST_WITH_RUST_PARSER \
if (!::testing::get<
1>(GetParam())) { \
return; \
}
#define SKIP_TEST_WITH_SIPCC_PARSER \
if (ResultsAreFromSipcc()) { \
return; \
}
// If you want to see the SDP as it is parsed
// #define DEBUG_DISPLAY_SDP
using namespace mozilla;
namespace test {
class SdpTest :
public ::testing::Test {
public:
SdpTest() : final_level_(
0), sdp_ptr_(nullptr) {}
~SdpTest() { sdp_free_description(sdp_ptr_); }
static void SetUpTestCase() {
NSS_NoDB_Init(nullptr);
NSS_SetDomesticPolicy();
}
void SetUp() {
final_level_ =
0;
sdp_ptr_ = nullptr;
}
static void TearDownTestCase() {}
void ResetSdp() {
if (!sdp_ptr_) {
sdp_free_description(sdp_ptr_);
}
sdp_media_e supported_media[] = {
SDP_MEDIA_AUDIO, SDP_MEDIA_VIDEO, SDP_MEDIA_APPLICATION,
SDP_MEDIA_DATA, SDP_MEDIA_CONTROL, SDP_MEDIA_NAS_RADIUS,
SDP_MEDIA_NAS_TACACS, SDP_MEDIA_NAS_DIAMETER, SDP_MEDIA_NAS_L2TP,
SDP_MEDIA_NAS_LOGIN, SDP_MEDIA_NAS_NONE, SDP_MEDIA_IMAGE,
};
sdp_conf_options_t* config_p = sdp_init_config();
unsigned int i;
for (i =
0; i <
sizeof(supported_media) /
sizeof(sdp_media_e); i++) {
sdp_media_supported(config_p, supported_media[i],
true);
}
sdp_nettype_supported(config_p, SDP_NT_INTERNET,
true);
sdp_addrtype_supported(config_p, SDP_AT_IP4,
true);
sdp_addrtype_supported(config_p, SDP_AT_IP6,
true);
sdp_transport_supported(config_p, SDP_TRANSPORT_RTPSAVPF,
true);
sdp_transport_supported(config_p, SDP_TRANSPORT_UDPTL,
true);
sdp_require_session_name(config_p,
false);
sdp_ptr_ = sdp_init_description(config_p);
if (!sdp_ptr_) {
sdp_free_config(config_p);
}
}
void ParseSdp(
const std::string& sdp_str) {
const char* buf = sdp_str.data();
ResetSdp();
ASSERT_EQ(sdp_parse(sdp_ptr_, buf, sdp_str.size()), SDP_SUCCESS);
}
void InitLocalSdp() {
ResetSdp();
ASSERT_EQ(sdp_set_version(sdp_ptr_,
0), SDP_SUCCESS);
ASSERT_EQ(sdp_set_owner_username(sdp_ptr_,
"-"), SDP_SUCCESS);
ASSERT_EQ(sdp_set_owner_sessionid(sdp_ptr_,
"132954853"), SDP_SUCCESS);
ASSERT_EQ(sdp_set_owner_version(sdp_ptr_,
"0"), SDP_SUCCESS);
ASSERT_EQ(sdp_set_owner_network_type(sdp_ptr_, SDP_NT_INTERNET),
SDP_SUCCESS);
ASSERT_EQ(sdp_set_owner_address_type(sdp_ptr_, SDP_AT_IP4), SDP_SUCCESS);
ASSERT_EQ(sdp_set_owner_address(sdp_ptr_,
"198.51.100.7"), SDP_SUCCESS);
ASSERT_EQ(sdp_set_session_name(sdp_ptr_,
"SDP Unit Test"), SDP_SUCCESS);
ASSERT_EQ(sdp_set_time_start(sdp_ptr_,
"0"), SDP_SUCCESS);
ASSERT_EQ(sdp_set_time_stop(sdp_ptr_,
"0"), SDP_SUCCESS);
}
std::string SerializeSdp() {
flex_string fs;
flex_string_init(&fs);
EXPECT_EQ(sdp_build(sdp_ptr_, &fs), SDP_SUCCESS);
std::string body(fs.buffer);
flex_string_free(&fs);
return body;
}
// Returns "level" for new media section
int AddNewMedia(sdp_media_e type) {
final_level_++;
EXPECT_EQ(sdp_insert_media_line(sdp_ptr_, final_level_), SDP_SUCCESS);
EXPECT_EQ(sdp_set_conn_nettype(sdp_ptr_, final_level_, SDP_NT_INTERNET),
SDP_SUCCESS);
EXPECT_EQ(sdp_set_conn_addrtype(sdp_ptr_, final_level_, SDP_AT_IP4),
SDP_SUCCESS);
EXPECT_EQ(sdp_set_conn_address(sdp_ptr_, final_level_,
"198.51.100.7"),
SDP_SUCCESS);
EXPECT_EQ(sdp_set_media_type(sdp_ptr_, final_level_, SDP_MEDIA_VIDEO),
SDP_SUCCESS);
EXPECT_EQ(
sdp_set_media_transport(sdp_ptr_, final_level_, SDP_TRANSPORT_RTPAVP),
SDP_SUCCESS);
EXPECT_EQ(sdp_set_media_portnum(sdp_ptr_, final_level_,
12345,
0),
SDP_SUCCESS);
EXPECT_EQ(sdp_add_media_payload_type(sdp_ptr_, final_level_,
120,
SDP_PAYLOAD_NUMERIC),
SDP_SUCCESS);
return final_level_;
}
uint16_t AddNewRtcpFbAck(
int level, sdp_rtcp_fb_ack_type_e type,
uint16_t payload = SDP_ALL_PAYLOADS) {
uint16_t inst_num =
0;
EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level,
0, SDP_ATTR_RTCP_FB, &inst_num),
SDP_SUCCESS);
EXPECT_EQ(
sdp_attr_set_rtcp_fb_ack(sdp_ptr_, level, payload, inst_num, type),
SDP_SUCCESS);
return inst_num;
}
uint16_t AddNewRtcpFbNack(
int level, sdp_rtcp_fb_nack_type_e type,
uint16_t payload = SDP_ALL_PAYLOADS) {
uint16_t inst_num =
0;
EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level,
0, SDP_ATTR_RTCP_FB, &inst_num),
SDP_SUCCESS);
EXPECT_EQ(
sdp_attr_set_rtcp_fb_nack(sdp_ptr_, level, payload, inst_num, type),
SDP_SUCCESS);
return inst_num;
}
uint16_t AddNewRtcpFbTrrInt(
int level, uint32_t interval,
uint16_t payload = SDP_ALL_PAYLOADS) {
uint16_t inst_num =
0;
EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level,
0, SDP_ATTR_RTCP_FB, &inst_num),
SDP_SUCCESS);
EXPECT_EQ(sdp_attr_set_rtcp_fb_trr_int(sdp_ptr_, level, payload, inst_num,
interval),
SDP_SUCCESS);
return inst_num;
}
uint16_t AddNewRtcpFbRemb(
int level, uint16_t payload = SDP_ALL_PAYLOADS) {
uint16_t inst_num =
0;
EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level,
0, SDP_ATTR_RTCP_FB, &inst_num),
SDP_SUCCESS);
EXPECT_EQ(sdp_attr_set_rtcp_fb_remb(sdp_ptr_, level, payload, inst_num),
SDP_SUCCESS);
return inst_num;
}
uint16_t AddNewRtcpFbCcm(
int level, sdp_rtcp_fb_ccm_type_e type,
uint16_t payload = SDP_ALL_PAYLOADS) {
uint16_t inst_num =
0;
EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level,
0, SDP_ATTR_RTCP_FB, &inst_num),
SDP_SUCCESS);
EXPECT_EQ(
sdp_attr_set_rtcp_fb_ccm(sdp_ptr_, level, payload, inst_num, type),
SDP_SUCCESS);
return inst_num;
}
uint16_t AddNewExtMap(
int level,
const char* uri) {
uint16_t inst_num =
0;
EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level,
0, SDP_ATTR_EXTMAP, &inst_num),
SDP_SUCCESS);
EXPECT_EQ(sdp_attr_set_extmap(sdp_ptr_, level, inst_num, uri, inst_num),
SDP_SUCCESS);
return inst_num;
}
uint16_t AddNewFmtpMaxFs(
int level, uint32_t max_fs) {
uint16_t inst_num =
0;
EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level,
0, SDP_ATTR_FMTP, &inst_num),
SDP_SUCCESS);
EXPECT_EQ(sdp_attr_set_fmtp_payload_type(sdp_ptr_, level,
0, inst_num,
120),
SDP_SUCCESS);
EXPECT_EQ(sdp_attr_set_fmtp_max_fs(sdp_ptr_, level,
0, inst_num, max_fs),
SDP_SUCCESS);
return inst_num;
}
uint16_t AddNewFmtpMaxFr(
int level, uint32_t max_fr) {
uint16_t inst_num =
0;
EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level,
0, SDP_ATTR_FMTP, &inst_num),
SDP_SUCCESS);
EXPECT_EQ(sdp_attr_set_fmtp_payload_type(sdp_ptr_, level,
0, inst_num,
120),
SDP_SUCCESS);
EXPECT_EQ(sdp_attr_set_fmtp_max_fr(sdp_ptr_, level,
0, inst_num, max_fr),
SDP_SUCCESS);
return inst_num;
}
uint16_t AddNewFmtpMaxFsFr(
int level, uint32_t max_fs, uint32_t max_fr) {
uint16_t inst_num =
0;
EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, level,
0, SDP_ATTR_FMTP, &inst_num),
SDP_SUCCESS);
EXPECT_EQ(sdp_attr_set_fmtp_payload_type(sdp_ptr_, level,
0, inst_num,
120),
SDP_SUCCESS);
EXPECT_EQ(sdp_attr_set_fmtp_max_fs(sdp_ptr_, level,
0, inst_num, max_fs),
SDP_SUCCESS);
EXPECT_EQ(sdp_attr_set_fmtp_max_fr(sdp_ptr_, level,
0, inst_num, max_fr),
SDP_SUCCESS);
return inst_num;
}
protected:
int final_level_;
sdp_t* sdp_ptr_;
};
MOZ_RUNINIT
static const std::string kVideoSdp =
"v=0\r\n"
"o=- 4294967296 2 IN IP4 127.0.0.1\r\n"
"s=SIP Call\r\n"
"c=IN IP4 198.51.100.7\r\n"
"t=0 0\r\n"
"m=video 56436 RTP/SAVPF 120\r\n"
"a=rtpmap:120 VP8/90000\r\n";
TEST_F(SdpTest, parseRtcpFbAckRpsi) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ack rpsi\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_ACK_RPSI);
}
TEST_F(SdpTest, parseRtcpFbAckApp) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ack app\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
1), SDP_RTCP_FB_ACK_APP);
}
TEST_F(SdpTest, parseRtcpFbAckAppFoo) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ack app foo\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
1), SDP_RTCP_FB_ACK_APP);
}
TEST_F(SdpTest, parseRtcpFbAckFooBar) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ack foo bar\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_ACK_UNKNOWN);
}
TEST_F(SdpTest, parseRtcpFbAckFooBarBaz) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ack foo bar baz\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_ACK_UNKNOWN);
}
TEST_F(SdpTest, parseRtcpFbNack) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 nack\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_NACK_BASIC);
}
TEST_F(SdpTest, parseRtcpFbNackPli) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 nack pli\r\n");
}
TEST_F(SdpTest, parseRtcpFbNackSli) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 nack sli\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_NACK_SLI);
}
TEST_F(SdpTest, parseRtcpFbNackRpsi) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 nack rpsi\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_NACK_RPSI);
}
TEST_F(SdpTest, parseRtcpFbNackApp) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 nack app\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_NACK_APP);
}
TEST_F(SdpTest, parseRtcpFbNackAppFoo) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 nack app foo\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_NACK_APP);
}
TEST_F(SdpTest, parseRtcpFbNackAppFooBar) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 nack app foo bar\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_NACK_APP);
}
TEST_F(SdpTest, parseRtcpFbNackFooBarBaz) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 nack foo bar baz\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_NACK_UNKNOWN);
}
TEST_F(SdpTest, parseRtcpFbRemb) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 goog-remb\r\n");
ASSERT_EQ((
bool)sdp_attr_get_rtcp_fb_remb_enabled(sdp_ptr_,
1,
120),
true);
}
TEST_F(SdpTest, parseRtcpRbRembAllPt) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:* goog-remb\r\n");
ASSERT_EQ(
(
bool)sdp_attr_get_rtcp_fb_remb_enabled(sdp_ptr_,
1, SDP_ALL_PAYLOADS),
true);
}
TEST_F(SdpTest, parseRtcpFbTrrInt0) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 trr-int 0\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_trr_int(sdp_ptr_,
1,
120,
1),
0U);
}
TEST_F(SdpTest, parseRtcpFbTrrInt123) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 trr-int 123\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_trr_int(sdp_ptr_,
1,
120,
1),
123U);
}
TEST_F(SdpTest, parseRtcpFbCcmFir) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ccm fir\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
1), SDP_RTCP_FB_CCM_FIR);
}
TEST_F(SdpTest, parseRtcpFbCcmTmmbr) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ccm tmmbr\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_CCM_TMMBR);
}
TEST_F(SdpTest, parseRtcpFbCcmTmmbrSmaxpr) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ccm tmmbr smaxpr=456\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_CCM_TMMBR);
}
TEST_F(SdpTest, parseRtcpFbCcmTstr) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ccm tstr\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_CCM_TSTR);
}
TEST_F(SdpTest, parseRtcpFbCcmVbcm) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ccm vbcm 123 456 789\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_CCM_VBCM);
// We don't currently parse out VBCM submessage types, since we don't have
// any use for them.
}
TEST_F(SdpTest, parseRtcpFbCcmFoo) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ccm foo\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_CCM_UNKNOWN);
}
TEST_F(SdpTest, parseRtcpFbCcmFooBarBaz) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ccm foo bar baz\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_CCM_UNKNOWN);
}
TEST_F(SdpTest, parseRtcpFbFoo) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 foo\r\n");
}
TEST_F(SdpTest, parseRtcpFbFooBar) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 foo bar\r\n");
}
TEST_F(SdpTest, parseRtcpFbFooBarBaz) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 foo bar baz\r\n");
}
MOZ_RUNINIT
static const std::string kVideoSdpWithUnknonwBrokenFtmp =
"v=0\r\n"
"o=- 4294967296 2 IN IP4 127.0.0.1\r\n"
"s=SIP Call\r\n"
"c=IN IP4 198.51.100.7\r\n"
"t=0 0\r\n"
"m=video 56436 RTP/SAVPF 120\r\n"
"a=rtpmap:120 VP8/90000\r\n"
"a=fmtp:122 unknown=10\n"
"a=rtpmap:122 red/90000\r\n";
TEST_F(SdpTest, parseUnknownBrokenFtmp) {
ParseSdp(kVideoSdpWithUnknonwBrokenFtmp);
}
TEST_F(SdpTest, parseRtcpFbKitchenSink) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:120 ack rpsi\r\n"
"a=rtcp-fb:120 ack app\r\n"
"a=rtcp-fb:120 ack app foo\r\n"
"a=rtcp-fb:120 ack foo bar\r\n"
"a=rtcp-fb:120 ack foo bar baz\r\n"
"a=rtcp-fb:120 nack\r\n"
"a=rtcp-fb:120 nack pli\r\n"
"a=rtcp-fb:120 nack sli\r\n"
"a=rtcp-fb:120 nack rpsi\r\n"
"a=rtcp-fb:120 nack app\r\n"
"a=rtcp-fb:120 nack app foo\r\n"
"a=rtcp-fb:120 nack app foo bar\r\n"
"a=rtcp-fb:120 nack foo bar baz\r\n"
"a=rtcp-fb:120 trr-int 0\r\n"
"a=rtcp-fb:120 trr-int 123\r\n"
"a=rtcp-fb:120 goog-remb\r\n"
"a=rtcp-fb:120 ccm fir\r\n"
"a=rtcp-fb:120 ccm tmmbr\r\n"
"a=rtcp-fb:120 ccm tmmbr smaxpr=456\r\n"
"a=rtcp-fb:120 ccm tstr\r\n"
"a=rtcp-fb:120 ccm vbcm 123 456 789\r\n"
"a=rtcp-fb:120 ccm foo\r\n"
"a=rtcp-fb:120 ccm foo bar baz\r\n"
"a=rtcp-fb:120 foo\r\n"
"a=rtcp-fb:120 foo bar\r\n"
"a=rtcp-fb:120 foo bar baz\r\n");
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_ACK_RPSI);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
2), SDP_RTCP_FB_ACK_APP);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
3), SDP_RTCP_FB_ACK_APP);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
4),
SDP_RTCP_FB_ACK_UNKNOWN);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
5),
SDP_RTCP_FB_ACK_UNKNOWN);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1,
120,
6),
SDP_RTCP_FB_ACK_NOT_FOUND);
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
1),
SDP_RTCP_FB_NACK_BASIC);
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
2),
SDP_RTCP_FB_NACK_PLI);
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
3),
SDP_RTCP_FB_NACK_SLI);
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
4),
SDP_RTCP_FB_NACK_RPSI);
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
5),
SDP_RTCP_FB_NACK_APP);
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
6),
SDP_RTCP_FB_NACK_APP);
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
7),
SDP_RTCP_FB_NACK_APP);
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
8),
SDP_RTCP_FB_NACK_UNKNOWN);
ASSERT_EQ(sdp_attr_get_rtcp_fb_nack(sdp_ptr_,
1,
120,
9),
SDP_RTCP_FB_NACK_NOT_FOUND);
ASSERT_EQ(sdp_attr_get_rtcp_fb_trr_int(sdp_ptr_,
1,
120,
1),
0U);
ASSERT_EQ(sdp_attr_get_rtcp_fb_trr_int(sdp_ptr_,
1,
120,
2),
123U);
ASSERT_EQ(sdp_attr_get_rtcp_fb_trr_int(sdp_ptr_,
1,
120,
3),
0xFFFFFFFF);
ASSERT_EQ((
bool)sdp_attr_get_rtcp_fb_remb_enabled(sdp_ptr_,
1,
120),
true);
ASSERT_EQ((
bool)sdp_attr_get_rtcp_fb_remb_enabled(sdp_ptr_,
2,
120),
false);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
1), SDP_RTCP_FB_CCM_FIR);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
2),
SDP_RTCP_FB_CCM_TMMBR);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
3),
SDP_RTCP_FB_CCM_TMMBR);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
4),
SDP_RTCP_FB_CCM_TSTR);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
5),
SDP_RTCP_FB_CCM_VBCM);
// We don't currently parse out VBCM submessage types, since we don't have
// any use for them.
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
6),
SDP_RTCP_FB_CCM_UNKNOWN);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
7),
SDP_RTCP_FB_CCM_UNKNOWN);
ASSERT_EQ(sdp_attr_get_rtcp_fb_ccm(sdp_ptr_,
1,
120,
8),
SDP_RTCP_FB_CCM_NOT_FOUND);
}
TEST_F(SdpTest, addRtcpFbAckRpsi) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbAck(level, SDP_RTCP_FB_ACK_RPSI,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 ack rpsi\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbAckRpsiAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbAck(level, SDP_RTCP_FB_ACK_RPSI);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* ack rpsi\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbAckApp) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbAck(level, SDP_RTCP_FB_ACK_APP,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 ack app\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbAckAppAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbAck(level, SDP_RTCP_FB_ACK_APP);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* ack app\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNack) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_BASIC,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 nack\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_BASIC);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* nack\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackSli) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_SLI,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 nack sli\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackSliAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_SLI);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* nack sli\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackPli) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_PLI,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 nack pli\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackPliAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_PLI);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* nack pli\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackRpsi) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_RPSI,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 nack rpsi\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackRpsiAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_RPSI);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* nack rpsi\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackApp) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_APP,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 nack app\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackAppAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_APP);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* nack app\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackRai) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_RAI,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 nack rai\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackRaiAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_RAI);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* nack rai\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackTllei) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_TLLEI,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 nack tllei\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackTlleiAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_TLLEI);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* nack tllei\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackPslei) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_PSLEI,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 nack pslei\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackPsleiAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_PSLEI);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* nack pslei\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackEcn) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_ECN,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 nack ecn\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackEcnAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbNack(level, SDP_RTCP_FB_NACK_ECN);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* nack ecn\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbRemb) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbRemb(level,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 goog-remb\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbRembAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbRemb(level);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* goog-remb\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbTrrInt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbTrrInt(level,
12345,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 trr-int 12345\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbNackTrrIntAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbTrrInt(level,
0);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* trr-int 0\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbCcmFir) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_FIR,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 ccm fir\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbCcmFirAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_FIR);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* ccm fir\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbCcmTmmbr) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_TMMBR,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 ccm tmmbr\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbCcmTmmbrAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_TMMBR);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* ccm tmmbr\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbCcmTstr) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_TSTR,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 ccm tstr\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbCcmTstrAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_TSTR);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* ccm tstr\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbCcmVbcm) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_VBCM,
120);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:120 ccm vbcm\r\n"), std::string::npos);
}
TEST_F(SdpTest, addRtcpFbCcmVbcmAllPt) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewRtcpFbCcm(level, SDP_RTCP_FB_CCM_VBCM);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=rtcp-fb:* ccm vbcm\r\n"), std::string::npos);
}
TEST_F(SdpTest, parseRtcpFbAllPayloads) {
ParseSdp(kVideoSdp +
"a=rtcp-fb:* ack rpsi\r\n");
for (
int i =
0; i <
128; i++) {
ASSERT_EQ(sdp_attr_get_rtcp_fb_ack(sdp_ptr_,
1, i,
1),
SDP_RTCP_FB_ACK_RPSI);
}
}
TEST_F(SdpTest, addExtMap) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewExtMap(level, SDP_EXTMAP_AUDIO_LEVEL);
std::string body = SerializeSdp();
ASSERT_NE(
body.find(
"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\n"),
std::string::npos);
}
TEST_F(SdpTest, parseExtMap) {
ParseSdp(kVideoSdp +
"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\n");
ASSERT_STREQ(sdp_attr_get_extmap_uri(sdp_ptr_,
1,
1), SDP_EXTMAP_AUDIO_LEVEL);
ASSERT_EQ(sdp_attr_get_extmap_id(sdp_ptr_,
1,
1),
1);
}
TEST_F(SdpTest, parseFmtpBitrate) {
ParseSdp(kVideoSdp +
"a=fmtp:120 bitrate=400\r\n");
ASSERT_EQ(
400, sdp_attr_get_fmtp_bitrate_type(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpBitrateWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 bitrate=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE,
sdp_attr_get_fmtp_bitrate_type(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpBitrateWith32001) {
ParseSdp(kVideoSdp +
"a=fmtp:120 bitrate=32001\r\n");
ASSERT_EQ(
32001, sdp_attr_get_fmtp_bitrate_type(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpBitrateWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 bitrate=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_VALUE,
sdp_attr_get_fmtp_bitrate_type(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpMode) {
ParseSdp(kVideoSdp +
"a=fmtp:120 mode=200\r\n");
ASSERT_EQ(
200U, sdp_attr_get_fmtp_mode_for_payload_type(sdp_ptr_,
1,
0,
120));
}
TEST_F(SdpTest, parseFmtpModeWith4294967295) {
ParseSdp(kVideoSdp +
"a=fmtp:120 mode=4294967295\r\n");
ASSERT_EQ(
4294967295,
sdp_attr_get_fmtp_mode_for_payload_type(sdp_ptr_,
1,
0,
120));
}
TEST_F(SdpTest, parseFmtpModeWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 mode=4294967296\r\n");
// returns 0 if not found
ASSERT_EQ(
0U, sdp_attr_get_fmtp_mode_for_payload_type(sdp_ptr_,
1,
0,
120));
}
TEST_F(SdpTest, parseFmtpQcif) {
ParseSdp(kVideoSdp +
"a=fmtp:120 qcif=20\r\n");
ASSERT_EQ(
20, sdp_attr_get_fmtp_qcif(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpQcifWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 qcif=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_qcif(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpQcifWith33) {
ParseSdp(kVideoSdp +
"a=fmtp:120 qcif=33\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_qcif(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpCif) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cif=11\r\n");
ASSERT_EQ(
11, sdp_attr_get_fmtp_cif(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpCifWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cif=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpCifWith33) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cif=33\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpMaxbr) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxbr=21\r\n");
ASSERT_EQ(
21, sdp_attr_get_fmtp_maxbr(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpMaxbrWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxbr=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_maxbr(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpMaxbrWith65536) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxbr=65536\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_maxbr(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpSqcif) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sqcif=6\r\n");
ASSERT_EQ(
6, sdp_attr_get_fmtp_sqcif(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpSqcifWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sqcif=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_sqcif(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpSqcifWith33) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sqcif=33\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_sqcif(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpCif4) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cif4=11\r\n");
ASSERT_EQ(
11, sdp_attr_get_fmtp_cif4(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpCif4With0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cif4=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif4(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpCif4With33) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cif4=33\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif4(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpCif16) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cif16=11\r\n");
ASSERT_EQ(
11, sdp_attr_get_fmtp_cif16(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpCif16With0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cif16=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif16(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpCif16With33) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cif16=33\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_cif16(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpBpp) {
ParseSdp(kVideoSdp +
"a=fmtp:120 bpp=7\r\n");
ASSERT_EQ(
7, sdp_attr_get_fmtp_bpp(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpBppWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 bpp=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_bpp(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpBppWith65536) {
ParseSdp(kVideoSdp +
"a=fmtp:120 bpp=65536\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_bpp(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpHrd) {
ParseSdp(kVideoSdp +
"a=fmtp:120 hrd=800\r\n");
ASSERT_EQ(
800, sdp_attr_get_fmtp_hrd(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpHrdWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 hrd=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_hrd(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpHrdWith65536) {
ParseSdp(kVideoSdp +
"a=fmtp:120 hrd=65536\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_hrd(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpProfile) {
ParseSdp(kVideoSdp +
"a=fmtp:120 profile=4\r\n");
ASSERT_EQ(
4, sdp_attr_get_fmtp_profile(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpProfileWith11) {
ParseSdp(kVideoSdp +
"a=fmtp:120 profile=11\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_profile(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpLevel) {
ParseSdp(kVideoSdp +
"a=fmtp:120 level=56\r\n");
ASSERT_EQ(
56, sdp_attr_get_fmtp_level(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpLevelWith101) {
ParseSdp(kVideoSdp +
"a=fmtp:120 level=101\r\n");
ASSERT_EQ(SDP_INVALID_VALUE, sdp_attr_get_fmtp_level(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpPacketizationMode) {
ParseSdp(kVideoSdp +
"a=fmtp:120 packetization-mode=1\r\n");
uint16_t packetizationMode;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_pack_mode(sdp_ptr_,
1,
0,
1, &packetizationMode));
ASSERT_EQ(
1, packetizationMode);
}
TEST_F(SdpTest, parseFmtpPacketizationModeWith3) {
ParseSdp(kVideoSdp +
"a=fmtp:120 packetization-mode=3\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_pack_mode(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpInterleavingDepth) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-interleaving-depth=566\r\n");
uint16_t interleavingDepth;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_interleaving_depth(
sdp_ptr_,
1,
0,
1, &interleavingDepth));
ASSERT_EQ(
566, interleavingDepth);
}
TEST_F(SdpTest, parseFmtpInterleavingDepthWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-interleaving-depth=0\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_interleaving_depth(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpInterleavingDepthWith65536) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-interleaving-depth=65536\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_interleaving_depth(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpDeintBuf) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-deint-buf-req=4294967295\r\n");
uint32_t deintBuf;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_deint_buf_req(sdp_ptr_,
1,
0,
1, &deintBuf));
ASSERT_EQ(
4294967295, deintBuf);
}
TEST_F(SdpTest, parseFmtpDeintBufWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-deint-buf-req=0\r\n");
uint32_t deintBuf;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_deint_buf_req(sdp_ptr_,
1,
0,
1, &deintBuf));
ASSERT_EQ(
0U, deintBuf);
}
TEST_F(SdpTest, parseFmtpDeintBufWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-deint-buf-req=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_deint_buf_req(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxDonDiff) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-max-don-diff=5678\r\n");
uint32_t maxDonDiff;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_max_don_diff(sdp_ptr_,
1,
0,
1, &maxDonDiff));
ASSERT_EQ(
5678U, maxDonDiff);
}
TEST_F(SdpTest, parseFmtpMaxDonDiffWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-max-don-diff=0\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_don_diff(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxDonDiffWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-max-don-diff=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_don_diff(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpInitBufTime) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-init-buf-time=4294967295\r\n");
uint32_t initBufTime;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_init_buf_time(sdp_ptr_,
1,
0,
1, &initBufTime));
ASSERT_EQ(
4294967295, initBufTime);
}
TEST_F(SdpTest, parseFmtpInitBufTimeWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-init-buf-time=0\r\n");
uint32_t initBufTime;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_init_buf_time(sdp_ptr_,
1,
0,
1, &initBufTime));
ASSERT_EQ(
0U, initBufTime);
}
TEST_F(SdpTest, parseFmtpInitBufTimeWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 sprop-init-buf-time=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_init_buf_time(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxMbps) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-mbps=46789\r\n");
uint32_t maxMpbs;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_max_mbps(sdp_ptr_,
1,
0,
1, &maxMpbs));
ASSERT_EQ(
46789U, maxMpbs);
}
TEST_F(SdpTest, parseFmtpMaxMbpsWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-mbps=0\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_mbps(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxMbpsWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-mbps=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_mbps(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxCpb) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-cpb=47891\r\n");
uint32_t maxCpb;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_cpb(sdp_ptr_,
1,
0,
1, &maxCpb));
ASSERT_EQ(
47891U, maxCpb);
}
TEST_F(SdpTest, parseFmtpMaxCpbWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-cpb=0\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_cpb(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxCpbWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-cpb=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_cpb(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxDpb) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-dpb=47892\r\n");
uint32_t maxDpb;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_dpb(sdp_ptr_,
1,
0,
1, &maxDpb));
ASSERT_EQ(
47892U, maxDpb);
}
TEST_F(SdpTest, parseFmtpMaxDpbWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-dpb=0\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_dpb(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxDpbWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-dpb=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_dpb(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxBr) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-br=47893\r\n");
uint32_t maxBr;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_br(sdp_ptr_,
1,
0,
1, &maxBr));
ASSERT_EQ(
47893U, maxBr);
}
TEST_F(SdpTest, parseFmtpMaxBrWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-br=0\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_br(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxBrWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-br=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_br(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpRedundantPicCap) {
ParseSdp(kVideoSdp +
"a=fmtp:120 redundant-pic-cap=1\r\n");
ASSERT_EQ(
1, sdp_attr_fmtp_is_redundant_pic_cap(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpRedundantPicCapWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 redundant-pic-cap=0\r\n");
ASSERT_EQ(
0, sdp_attr_fmtp_is_redundant_pic_cap(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpRedundantPicCapWith2) {
ParseSdp(kVideoSdp +
"a=fmtp:120 redundant-pic-cap=2\r\n");
ASSERT_EQ(
0, sdp_attr_fmtp_is_redundant_pic_cap(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpDeintBufCap) {
ParseSdp(kVideoSdp +
"a=fmtp:120 deint-buf-cap=4294967295\r\n");
uint32_t deintBufCap;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_deint_buf_cap(sdp_ptr_,
1,
0,
1, &deintBufCap));
ASSERT_EQ(
4294967295, deintBufCap);
}
TEST_F(SdpTest, parseFmtpDeintBufCapWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 deint-buf-cap=0\r\n");
uint32_t deintBufCap;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_deint_buf_cap(sdp_ptr_,
1,
0,
1, &deintBufCap));
ASSERT_EQ(
0U, deintBufCap);
}
TEST_F(SdpTest, parseFmtpDeintBufCapWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 deint-buf-cap=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_deint_buf_cap(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxRcmdNaluSize) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-rcmd-nalu-size=4294967295\r\n");
uint32_t maxRcmdNaluSize;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_rcmd_nalu_size(
sdp_ptr_,
1,
0,
1, &maxRcmdNaluSize));
ASSERT_EQ(
4294967295, maxRcmdNaluSize);
}
TEST_F(SdpTest, parseFmtpMaxRcmdNaluSizeWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-rcmd-nalu-size=0\r\n");
uint32_t maxRcmdNaluSize;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_rcmd_nalu_size(
sdp_ptr_,
1,
0,
1, &maxRcmdNaluSize));
ASSERT_EQ(
0U, maxRcmdNaluSize);
}
TEST_F(SdpTest, parseFmtpMaxRcmdNaluSizeWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-rcmd-nalu-size=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_rcmd_nalu_size(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpParameterAdd) {
ParseSdp(kVideoSdp +
"a=fmtp:120 parameter-add=1\r\n");
ASSERT_EQ(
1, sdp_attr_fmtp_is_parameter_add(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpParameterAddWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 parameter-add=0\r\n");
ASSERT_EQ(
0, sdp_attr_fmtp_is_parameter_add(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpParameterAddWith2) {
ParseSdp(kVideoSdp +
"a=fmtp:120 parameter-add=2\r\n");
ASSERT_EQ(
0, sdp_attr_fmtp_is_parameter_add(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpAnnexK) {
ParseSdp(kVideoSdp +
"a=fmtp:120 K=566\r\n");
ASSERT_EQ(
566, sdp_attr_get_fmtp_annex_k_val(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpAnnexKWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 K=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE,
sdp_attr_get_fmtp_annex_k_val(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpAnnexKWith65536) {
ParseSdp(kVideoSdp +
"a=fmtp:120 K=65536\r\n");
ASSERT_EQ(SDP_INVALID_VALUE,
sdp_attr_get_fmtp_annex_k_val(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpAnnexN) {
ParseSdp(kVideoSdp +
"a=fmtp:120 N=4567\r\n");
ASSERT_EQ(
4567, sdp_attr_get_fmtp_annex_n_val(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpAnnexNWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 N=0\r\n");
ASSERT_EQ(SDP_INVALID_VALUE,
sdp_attr_get_fmtp_annex_n_val(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpAnnexNWith65536) {
ParseSdp(kVideoSdp +
"a=fmtp:120 N=65536\r\n");
ASSERT_EQ(SDP_INVALID_VALUE,
sdp_attr_get_fmtp_annex_n_val(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpAnnexP) {
ParseSdp(kVideoSdp +
"a=fmtp:120 P=5678,2\r\n");
ASSERT_EQ(
5678, sdp_attr_get_fmtp_annex_p_picture_resize(sdp_ptr_,
1,
0,
1));
ASSERT_EQ(
2, sdp_attr_get_fmtp_annex_p_warp(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpAnnexPWithResize0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 P=0,3\r\n");
ASSERT_EQ(
0, sdp_attr_get_fmtp_annex_p_picture_resize(sdp_ptr_,
1,
0,
1));
ASSERT_EQ(
3, sdp_attr_get_fmtp_annex_p_warp(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpAnnexPWithResize65536) {
ParseSdp(kVideoSdp +
"a=fmtp:120 P=65536,4\r\n");
ASSERT_EQ(
0, sdp_attr_get_fmtp_annex_p_picture_resize(sdp_ptr_,
1,
0,
1));
// if the first fails, the second will too. Both default to 0 on failure.
ASSERT_EQ(
0, sdp_attr_get_fmtp_annex_p_warp(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpAnnexPWithWarp65536) {
ParseSdp(kVideoSdp +
"a=fmtp:120 P=346,65536\r\n");
ASSERT_EQ(
346, sdp_attr_get_fmtp_annex_p_picture_resize(sdp_ptr_,
1,
0,
1));
ASSERT_EQ(
0, sdp_attr_get_fmtp_annex_p_warp(sdp_ptr_,
1,
0,
1));
}
TEST_F(SdpTest, parseFmtpLevelAsymmetryAllowed) {
ParseSdp(kVideoSdp +
"a=fmtp:120 level-asymmetry-allowed=1\r\n");
uint16_t levelAsymmetryAllowed;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_level_asymmetry_allowed(
sdp_ptr_,
1,
0,
1, &levelAsymmetryAllowed));
ASSERT_EQ(
1U, levelAsymmetryAllowed);
}
TEST_F(SdpTest, parseFmtpLevelAsymmetryAllowedWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 level-asymmetry-allowed=0\r\n");
uint16_t levelAsymmetryAllowed;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_level_asymmetry_allowed(
sdp_ptr_,
1,
0,
1, &levelAsymmetryAllowed));
ASSERT_EQ(
0U, levelAsymmetryAllowed);
}
TEST_F(SdpTest, parseFmtpLevelAsymmetryAllowedWith2) {
ParseSdp(kVideoSdp +
"a=fmtp:120 level-asymmetry-allowed=2\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER, sdp_attr_get_fmtp_level_asymmetry_allowed(
sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxAverageBitrate) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxaveragebitrate=47893\r\n");
uint32_t maxAverageBitrate;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_max_average_bitrate(
sdp_ptr_,
1,
0,
1, &maxAverageBitrate));
ASSERT_EQ(
47893U, maxAverageBitrate);
}
TEST_F(SdpTest, parseFmtpMaxAverageBitrateWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxaveragebitrate=0\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_average_bitrate(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxAverageBitrateWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxaveragebitrate=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_average_bitrate(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpUsedTx) {
ParseSdp(kVideoSdp +
"a=fmtp:120 usedtx=1\r\n");
tinybool usedTx;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_usedtx(sdp_ptr_,
1,
0,
1, &usedTx));
ASSERT_EQ(
1, usedTx);
}
TEST_F(SdpTest, parseFmtpUsedTxWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 usedtx=0\r\n");
tinybool usedTx;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_usedtx(sdp_ptr_,
1,
0,
1, &usedTx));
ASSERT_EQ(
0, usedTx);
}
TEST_F(SdpTest, parseFmtpUsedTxWith2) {
ParseSdp(kVideoSdp +
"a=fmtp:120 usedtx=2\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_usedtx(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpStereo) {
ParseSdp(kVideoSdp +
"a=fmtp:120 stereo=1\r\n");
tinybool stereo;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_stereo(sdp_ptr_,
1,
0,
1, &stereo));
ASSERT_EQ(
1, stereo);
}
TEST_F(SdpTest, parseFmtpStereoWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 stereo=0\r\n");
tinybool stereo;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_stereo(sdp_ptr_,
1,
0,
1, &stereo));
ASSERT_EQ(
0, stereo);
}
TEST_F(SdpTest, parseFmtpStereoWith2) {
ParseSdp(kVideoSdp +
"a=fmtp:120 stereo=2\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_stereo(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpUseInBandFec) {
ParseSdp(kVideoSdp +
"a=fmtp:120 useinbandfec=1\r\n");
tinybool useInbandFec;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_useinbandfec(sdp_ptr_,
1,
0,
1, &useInbandFec));
ASSERT_EQ(
1, useInbandFec);
}
TEST_F(SdpTest, parseFmtpUseInBandWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 useinbandfec=0\r\n");
tinybool useInbandFec;
ASSERT_EQ(SDP_SUCCESS,
sdp_attr_get_fmtp_useinbandfec(sdp_ptr_,
1,
0,
1, &useInbandFec));
ASSERT_EQ(
0, useInbandFec);
}
TEST_F(SdpTest, parseFmtpUseInBandWith2) {
ParseSdp(kVideoSdp +
"a=fmtp:120 useinbandfec=2\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_useinbandfec(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxCodedAudioBandwidth) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxcodedaudiobandwidth=abcdefg\r\n");
char* maxCodedAudioBandwith =
sdp_attr_get_fmtp_maxcodedaudiobandwidth(sdp_ptr_,
1,
0,
1);
ASSERT_EQ(
0, strcmp(
"abcdefg", maxCodedAudioBandwith));
}
TEST_F(SdpTest, parseFmtpMaxCodedAudioBandwidthBad) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxcodedaudiobandwidth=\r\n");
char* maxCodedAudioBandwith =
sdp_attr_get_fmtp_maxcodedaudiobandwidth(sdp_ptr_,
1,
0,
1);
ASSERT_EQ(
0, *maxCodedAudioBandwith);
}
TEST_F(SdpTest, parseFmtpCbr) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cbr=1\r\n");
tinybool cbr;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_cbr(sdp_ptr_,
1,
0,
1, &cbr));
ASSERT_EQ(
1, cbr);
}
TEST_F(SdpTest, parseFmtpCbrWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cbr=0\r\n");
tinybool cbr;
ASSERT_EQ(SDP_SUCCESS, sdp_attr_get_fmtp_cbr(sdp_ptr_,
1,
0,
1, &cbr));
ASSERT_EQ(
0, cbr);
}
TEST_F(SdpTest, parseFmtpCbrWith2) {
ParseSdp(kVideoSdp +
"a=fmtp:120 cbr=2\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_cbr(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxPlaybackRate) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxplaybackrate=47900\r\n");
sdp_attr_t* attr_p = sdp_find_attr(sdp_ptr_,
1,
0, SDP_ATTR_FMTP,
1);
ASSERT_NE(nullptr, attr_p);
ASSERT_EQ(
47900U, attr_p->attr.fmtp.maxplaybackrate);
}
TEST_F(SdpTest, parseFmtpMaxPlaybackRateWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxplaybackrate=0\r\n");
sdp_attr_t* attr_p = sdp_find_attr(sdp_ptr_,
1,
0, SDP_ATTR_FMTP,
1);
ASSERT_EQ(NULL, attr_p);
}
TEST_F(SdpTest, parseFmtpMaxPlaybackRateWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 maxplaybackrate=4294967296\r\n");
sdp_attr_t* attr_p = sdp_find_attr(sdp_ptr_,
1,
0, SDP_ATTR_FMTP,
1);
ASSERT_EQ(NULL, attr_p);
}
TEST_F(SdpTest, parseFmtpMaxFs) {
uint32_t val =
0;
ParseSdp(kVideoSdp +
"a=fmtp:120 max-fs=300;max-fr=30\r\n");
ASSERT_EQ(sdp_attr_get_fmtp_max_fs(sdp_ptr_,
1,
0,
1, &val), SDP_SUCCESS);
ASSERT_EQ(val,
300U);
}
TEST_F(SdpTest, parseFmtpMaxFsWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-fs=0\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_fs(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxFsWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-fs=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_fs(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxFr) {
uint32_t val =
0;
ParseSdp(kVideoSdp +
"a=fmtp:120 max-fs=300;max-fr=30\r\n");
ASSERT_EQ(sdp_attr_get_fmtp_max_fr(sdp_ptr_,
1,
0,
1, &val), SDP_SUCCESS);
ASSERT_EQ(val,
30U);
}
TEST_F(SdpTest, parseFmtpMaxFrWith0) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-fr=0\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_fr(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, parseFmtpMaxFrWith4294967296) {
ParseSdp(kVideoSdp +
"a=fmtp:120 max-fr=4294967296\r\n");
ASSERT_EQ(SDP_INVALID_PARAMETER,
sdp_attr_get_fmtp_max_fr(sdp_ptr_,
1,
0,
1, nullptr));
}
TEST_F(SdpTest, addFmtpMaxFs) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewFmtpMaxFs(level,
300);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=fmtp:120 max-fs=300\r\n"), std::string::npos);
}
TEST_F(SdpTest, addFmtpMaxFr) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewFmtpMaxFr(level,
30);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=fmtp:120 max-fr=30\r\n"), std::string::npos);
}
TEST_F(SdpTest, addFmtpMaxFsFr) {
InitLocalSdp();
int level = AddNewMedia(SDP_MEDIA_VIDEO);
AddNewFmtpMaxFsFr(level,
300,
30);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=fmtp:120 max-fs=300;max-fr=30\r\n"),
std::string::npos);
}
MOZ_RUNINIT
static const std::string kBrokenFmtp =
"v=0\r\n"
"o=- 4294967296 2 IN IP4 127.0.0.1\r\n"
"s=SIP Call\r\n"
"t=0 0\r\n"
"m=video 56436 RTP/SAVPF 120\r\n"
"c=IN IP4 198.51.100.7\r\n"
"a=rtpmap:120 VP8/90000\r\n"
/* Note: the \0 in this string triggered bz://1089207
*/
"a=fmtp:120 max-fs=300;max\0fr=30";
TEST_F(SdpTest, parseBrokenFmtp) {
uint32_t val =
0;
const char* buf = kBrokenFmtp.data();
ResetSdp();
/* We need to manually invoke the parser here to be able to specify the length
* of the string beyond the \0 in last line of the string.
*/
ASSERT_EQ(sdp_parse(sdp_ptr_, buf,
165), SDP_SUCCESS);
ASSERT_EQ(sdp_attr_get_fmtp_max_fs(sdp_ptr_,
1,
0,
1, &val),
SDP_INVALID_PARAMETER);
}
TEST_F(SdpTest, addIceLite) {
InitLocalSdp();
uint16_t inst_num =
0;
EXPECT_EQ(sdp_add_new_attr(sdp_ptr_, SDP_SESSION_LEVEL,
0, SDP_ATTR_ICE_LITE,
&inst_num),
SDP_SUCCESS);
std::string body = SerializeSdp();
ASSERT_NE(body.find(
"a=ice-lite\r\n"), std::string::npos);
}
TEST_F(SdpTest, parseIceLite) {
std::string sdp =
"v=0\r\n"
"o=- 4294967296 2 IN IP4 127.0.0.1\r\n"
"s=SIP Call\r\n"
"t=0 0\r\n"
"a=ice-lite\r\n";
ParseSdp(sdp);
ASSERT_TRUE(
sdp_attr_is_present(sdp_ptr_, SDP_ATTR_ICE_LITE, SDP_SESSION_LEVEL,
0));
}
class NewSdpTest
:
public ::testing::Test,
public ::testing::WithParamInterface< ::testing::tuple<
bool,
bool> > {
public:
NewSdpTest() =
default;
void ParseSdp(
const std::string& sdp,
bool expectSuccess =
true,
bool expectEqual =
true) {
UniquePtr<SdpParser> firstParser(
new RsdparsaSdpParser());
UniquePtr<SdpParser> secondParser(
new SipccSdpParser());
if (::testing::get<
1>(GetParam())) {
firstParser.swap(secondParser);
}
mResults = firstParser->Parse(sdp);
#ifdef DEBUG_DISPLAY_SDP
std::cout << firstParser->Name() <<
" Parsing SDP:" << std::endl;
std::stringstream sdpStream(sdp);
std::string line;
size_t lineNumber =
0;
while (std::getline(sdpStream, line,
'\n')) {
if (line.length() && line.back() ==
'\r') {
line.pop_back();
}
lineNumber++;
std::cout << std::setw(
4) << lineNumber <<
" " << line << std::endl;
}
#endif
// Are we configured to do a parse and serialize before actually
// running the test?
if (::testing::get<
0>(GetParam())) {
if (expectSuccess) {
ASSERT_TRUE(!!mResults->Sdp())
<<
"Parse failed on first pass: " << SerializeParseErrors();
}
if (mResults->Sdp()) {
std::stringstream os, os2;
// Serialize and re-parse
mResults->Sdp()->Serialize(os);
const auto secondResults = secondParser->Parse(os.str());
// Whether we expected the parse to work or not, it should
// succeed the second time if it succeeded the first.
ASSERT_TRUE(!!Sdp())
<<
"Parse failed on second pass, SDP was: " << std::endl
<< os.str() << std::endl
<<
"Errors were: " << IntSerializeParseErrors(secondResults);
// Serialize again and compare
secondResults->Sdp()->Serialize(os2);
if (expectEqual) {
ASSERT_EQ(os.str(), os2.str())
<<
"FIRST IS " << mResults->ParserName() <<
", SECOND IS "
<< secondResults->ParserName();
}
else {
ASSERT_NE(os.str(), os2.str())
<<
"FIRST IS " << mResults->ParserName() <<
", SECOND IS "
<< secondResults->ParserName();
}
}
}
if (expectSuccess) {
ASSERT_TRUE(!!mResults->Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
0U, ParseErrorCount())
<<
"Got unexpected parse errors/warnings: " << SerializeParseErrors();
}
}
const UniquePtr<
class Sdp>& Sdp()
const {
static const UniquePtr<
class Sdp> NO_SDP(nullptr);
return mResults ? mResults->Sdp() : NO_SDP;
}
size_t ParseErrorCount()
const {
return mResults->Errors().size(); }
size_t ParseWarningCount()
const {
return mResults->Warnings().size(); }
std::string IntSerializeParseErrors(
const UniquePtr<SdpParser::Results>& aResults)
const {
std::stringstream output;
for (
const auto& e : aResults->Errors()) {
output << e.first <<
": " << e.second << std::endl;
}
return output.str();
}
// For streaming parse errors
std::string SerializeParseErrors()
const {
return IntSerializeParseErrors(mResults);
}
std::string IntSerializeParseWarnings(
const UniquePtr<SdpParser::Results>& aResults)
const {
std::stringstream output;
for (
const auto& e : aResults->Warnings()) {
output << e.first <<
": " << e.second << std::endl;
}
return output.str();
}
std::string SerializeParseWarnings()
const {
return IntSerializeParseWarnings(mResults);
}
void CheckRtpmap(
const std::string& expected_pt,
SdpRtpmapAttributeList::CodecType codec,
const std::string& name, uint32_t clock, uint16_t channels,
const std::string& search_pt,
const SdpRtpmapAttributeList& rtpmaps)
const {
ASSERT_TRUE(rtpmaps.HasEntry(search_pt));
auto attr = rtpmaps.GetEntry(search_pt);
ASSERT_EQ(expected_pt, attr.pt);
ASSERT_EQ(codec, attr.codec);
std::cout <<
"Codec = " << name << std::endl;
ASSERT_EQ(name, attr.name);
ASSERT_EQ(clock, attr.clock);
ASSERT_EQ(channels, attr.channels);
}
void CheckSctpmap(
const std::string& expected_pt,
const std::string& name,
uint16_t streams,
const std::string& search_pt,
const SdpSctpmapAttributeList& sctpmaps)
const {
ASSERT_TRUE(sctpmaps.HasEntry(search_pt));
auto attr = sctpmaps.GetFirstEntry();
ASSERT_EQ(expected_pt, search_pt);
ASSERT_EQ(expected_pt, attr.pt);
ASSERT_EQ(name, attr.name);
ASSERT_EQ(streams, attr.streams);
}
void CheckRtcpFb(
const SdpRtcpFbAttributeList::Feedback& feedback,
const std::string& pt, SdpRtcpFbAttributeList::Type type,
const std::string& first_parameter,
const std::string& extra =
"")
const {
ASSERT_EQ(pt, feedback.pt);
ASSERT_EQ(type, feedback.type);
ASSERT_EQ(first_parameter, feedback.parameter);
ASSERT_EQ(extra, feedback.extra);
}
void CheckDtmfFmtp(
const std::string& expectedDtmfTones)
const {
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
auto audio_format_params =
Sdp()->GetMediaSection(
0).GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
2U, audio_format_params.size());
ASSERT_EQ(
"101", audio_format_params[
1].format);
ASSERT_TRUE(!!audio_format_params[
1].parameters);
const SdpFmtpAttributeList::TelephoneEventParameters* te_parameters =
static_cast<SdpFmtpAttributeList::TelephoneEventParameters*>(
audio_format_params[
1].parameters.get());
ASSERT_NE(
0U, te_parameters->dtmfTones.size());
ASSERT_EQ(expectedDtmfTones, te_parameters->dtmfTones);
}
void CheckSerialize(
const std::string& expected,
const SdpAttribute& attr)
const {
std::stringstream str;
attr.Serialize(str);
ASSERT_EQ(expected, str.str());
}
bool ResultsAreFromSipcc()
const {
return mResults && SipccSdpParser::IsNamed(mResults->ParserName());
}
mozilla::UniquePtr<SdpParser::Results> mResults;
};
// class NewSdpTest
TEST_P(NewSdpTest, CreateDestroy) {}
TEST_P(NewSdpTest, ParseEmpty) {
ParseSdp(
"",
false);
ASSERT_FALSE(Sdp());
ASSERT_NE(
0U, ParseErrorCount()) <<
"Expected at least one parse error.";
}
MOZ_RUNINIT
const std::string kBadSdp =
"This is SDPARTA!!!!";
TEST_P(NewSdpTest, ParseGarbage) {
ParseSdp(kBadSdp,
false);
ASSERT_FALSE(Sdp());
ASSERT_NE(
0U, ParseErrorCount()) <<
"Expected at least one parse error.";
}
TEST_P(NewSdpTest, ParseGarbageTwice) {
ParseSdp(kBadSdp,
false);
ASSERT_FALSE(Sdp());
size_t errorCount = ParseErrorCount();
ASSERT_NE(
0U, errorCount) <<
"Expected at least one parse error.";
ParseSdp(kBadSdp,
false);
ASSERT_FALSE(Sdp());
ASSERT_EQ(errorCount, ParseErrorCount())
<<
"Expected same error count for same SDP.";
}
TEST_P(NewSdpTest, ParseMinimal) {
ParseSdp(kVideoSdp);
ASSERT_EQ(
0U, ParseErrorCount())
<<
"Got parse errors: " << SerializeParseErrors();
}
TEST_P(NewSdpTest, CheckOriginGetUsername) {
ParseSdp(kVideoSdp);
ASSERT_EQ(
"-", Sdp()->GetOrigin().GetUsername())
<<
"Wrong username in origin";
}
TEST_P(NewSdpTest, CheckOriginGetSessionId) {
ParseSdp(kVideoSdp);
ASSERT_EQ(
4294967296U, Sdp()->GetOrigin().GetSessionId())
<<
"Wrong session id in origin";
}
TEST_P(NewSdpTest, CheckOriginGetSessionVersion) {
ParseSdp(kVideoSdp);
ASSERT_EQ(
2U, Sdp()->GetOrigin().GetSessionVersion())
<<
"Wrong version in origin";
}
TEST_P(NewSdpTest, CheckOriginGetAddrType) {
ParseSdp(kVideoSdp);
ASSERT_EQ(sdp::kIPv4, Sdp()->GetOrigin().GetAddrType())
<<
"Wrong address type in origin";
}
TEST_P(NewSdpTest, CheckOriginGetAddress) {
ParseSdp(kVideoSdp);
ASSERT_EQ(
"127.0.0.1", Sdp()->GetOrigin().GetAddress())
<<
"Wrong address in origin";
}
TEST_P(NewSdpTest, CheckGetMissingBandwidth) {
ParseSdp(kVideoSdp);
ASSERT_EQ(
0U, Sdp()->GetBandwidth(
"CT")) <<
"Wrong bandwidth in session";
}
TEST_P(NewSdpTest, CheckGetBandwidth) {
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"b=FOOBAR:10" CRLF
"b=AS:4" CRLF
"t=0 0" CRLF
"m=video 56436 RTP/SAVPF 120" CRLF
"a=rtpmap:120 VP8/90000" CRLF,
true, ::testing::get<
1>(GetParam()));
ASSERT_EQ(
5000U, Sdp()->GetBandwidth(
"CT"))
<<
"Wrong CT bandwidth in session";
ASSERT_EQ(
0U, Sdp()->GetBandwidth(
"FOOBAR"))
<<
"Wrong FOOBAR bandwidth in session";
ASSERT_EQ(
4U, Sdp()->GetBandwidth(
"AS")) <<
"Wrong AS bandwidth in session";
}
TEST_P(NewSdpTest, CheckGetMediaSectionsCount) {
ParseSdp(kVideoSdp);
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
}
TEST_P(NewSdpTest, CheckMediaSectionGetMediaType) {
ParseSdp(kVideoSdp);
ASSERT_EQ(SdpMediaSection::kVideo, Sdp()->GetMediaSection(
0).GetMediaType())
<<
"Wrong type for first media section";
}
TEST_P(NewSdpTest, CheckMediaSectionGetProtocol) {
ParseSdp(kVideoSdp);
ASSERT_EQ(SdpMediaSection::kRtpSavpf, Sdp()->GetMediaSection(
0).GetProtocol())
<<
"Wrong protocol for video";
}
TEST_P(NewSdpTest, CheckMediaSectionGetFormats) {
ParseSdp(kVideoSdp);
auto video_formats = Sdp()->GetMediaSection(
0).GetFormats();
ASSERT_EQ(
1U, video_formats.size()) <<
"Wrong number of formats for video";
ASSERT_EQ(
"120", video_formats[
0]);
}
TEST_P(NewSdpTest, CheckMediaSectionGetPort) {
ParseSdp(kVideoSdp);
ASSERT_EQ(
56436U, Sdp()->GetMediaSection(
0).GetPort())
<<
"Wrong port number in media section";
}
TEST_P(NewSdpTest, CheckMediaSectionGetMissingPortCount) {
ParseSdp(kVideoSdp);
ASSERT_EQ(
0U, Sdp()->GetMediaSection(
0).GetPortCount())
<<
"Wrong port count in media section";
}
TEST_P(NewSdpTest, CheckMediaSectionGetPortCount) {
ParseSdp(kVideoSdp +
"m=audio 12345/2 RTP/SAVPF 0" CRLF
"a=rtpmap:0 PCMU/8000" CRLF);
ASSERT_EQ(
2U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_EQ(
2U, Sdp()->GetMediaSection(
1).GetPortCount())
<<
"Wrong port count in media section";
}
TEST_P(NewSdpTest, CheckMediaSectionGetMissingBandwidth) {
ParseSdp(kVideoSdp);
ASSERT_EQ(
0U, Sdp()->GetMediaSection(
0).GetBandwidth(
"CT"))
<<
"Wrong bandwidth in media section";
}
TEST_P(NewSdpTest, CheckMediaSectionGetBandwidth) {
ParseSdp(
"v=0\r\n"
"o=- 4294967296 2 IN IP4 127.0.0.1\r\n"
"s=SIP Call\r\n"
"c=IN IP4 198.51.100.7\r\n"
"t=0 0\r\n"
"m=video 56436 RTP/SAVPF 120\r\n"
"b=CT:1000\r\n"
"a=rtpmap:120 VP8/90000\r\n");
ASSERT_EQ(
1000U, Sdp()->GetMediaSection(
0).GetBandwidth(
"CT"))
<<
"Wrong bandwidth in media section";
}
// Define a string that is 258 characters long. We use a long string here so
// that we can test that we are able to parse and handle a string longer than
// the default maximum length of 256 in sipcc.
#define ID_A
"1234567890abcdef"
#define ID_B ID_A ID_A ID_A ID_A
#define LONG_IDENTITY ID_B ID_B ID_B ID_B
"xx"
#define BASE64_DTLS_HELLO \
"FgEAAAAAAAAAAAAAagEAAF4AAAAAAAAAXgEARI11KHx3QB6Ky" \
"CKgoBj/kwjKrApkL8kiZLwIqBaJGT8AAAA2ADkAOAA1ABYAEwAKADMAMgAvAAcAZgAFAAQAYw" \
"BiAGEAFQASAAkAZQBkAGAAFAARAAgABgADAQA="
// SDP from a basic A/V apprtc call FFX/FFX
MOZ_RUNINIT
const std::vector<std::string> kBasicAudioVideoOfferLines = {
"v=0",
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0",
"s=SIP Call",
"c=IN IP4 224.0.0.1/100/12",
"t=0 0",
"a=dtls-message:client " BASE64_DTLS_HELLO,
"a=ice-ufrag:4a799b2e",
"a=ice-pwd:e4cc12a910f106a0a744719425510e17",
"a=ice-lite",
"a=ice-options:trickle foo",
"a=msid-semantic:WMS stream streama",
"a=msid-semantic:foo stream",
"a=fingerprint:sha-256 "
"DF:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:"
"A0:72:9B:14:08:6D:0F:4C",
"a=identity:" LONG_IDENTITY,
"a=group:BUNDLE first second",
"a=group:BUNDLE third",
"a=group:LS first third",
"m=audio 9 RTP/SAVPF 109 9 0 8 101",
"c=IN IP4 0.0.0.0",
"a=mid:first",
"a=rtpmap:109 opus/48000/2",
"a=fmtp:109 maxplaybackrate=32000;stereo=1",
"a=ptime:20",
"a=maxptime:20",
"a=rtpmap:9 G722/8000",
"a=rtpmap:0 PCMU/8000",
"a=rtpmap:8 PCMA/8000",
"a=rtpmap:101 telephone-event/8000",
"a=fmtp:101 0-15,66,32-34,67",
"a=ice-ufrag:00000000",
"a=ice-pwd:0000000000000000000000000000000",
"a=sendonly",
"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level",
"a=setup:actpass",
"a=rtcp-mux",
"a=msid:stream track",
"a=candidate:0 1 UDP 2130379007 10.0.0.36 62453 typ host",
"a=candidate:2 1 UDP 1694236671 24.6.134.204 62453 typ srflx raddr "
"10.0.0.36 rport 62453",
"a=candidate:3 1 UDP 100401151 162.222.183.171 49761 typ relay raddr "
"162.222.183.171 rport 49761",
"a=candidate:6 1 UDP 16515071 162.222.183.171 51858 typ relay raddr "
"162.222.183.171 rport 51858",
"a=candidate:3 2 UDP 100401150 162.222.183.171 62454 typ relay raddr "
"162.222.183.171 rport 62454",
"a=candidate:2 2 UDP 1694236670 24.6.134.204 55428 typ srflx raddr "
"10.0.0.36 rport 55428",
"a=candidate:6 2 UDP 16515070 162.222.183.171 50340 typ relay raddr "
"162.222.183.171 rport 50340",
"a=candidate:0 2 UDP 2130379006 10.0.0.36 55428 typ host",
"a=rtcp:62454 IN IP4 162.222.183.171",
"a=end-of-candidates",
"a=ssrc:5150",
"m=video 9 RTP/SAVPF 120 121 122 123",
"c=IN IP6 ::1",
"a=fingerprint:sha-1 "
"DF:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C",
"a=mid:second",
"a=rtpmap:120 VP8/90000",
"a=fmtp:120 max-fs=3600;max-fr=30",
"a=rtpmap:121 VP9/90000",
"a=fmtp:121 max-fs=3600;max-fr=30",
"a=rtpmap:122 red/90000",
"a=rtpmap:123 ulpfec/90000",
"a=fmtp:122 120/121/123",
"a=recvonly",
"a=rtcp-fb:120 nack",
"a=rtcp-fb:120 nack pli",
"a=rtcp-fb:120 ccm fir",
"a=rtcp-fb:121 nack",
"a=rtcp-fb:121 nack pli",
"a=rtcp-fb:121 ccm fir",
"a=setup:active",
"a=rtcp-mux",
"a=msid:streama tracka",
"a=msid:streamb trackb",
"a=candidate:0 1 UDP 2130379007 10.0.0.36 59530 typ host",
"a=candidate:0 2 UDP 2130379006 10.0.0.36 64378 typ host",
"a=candidate:2 2 UDP 1694236670 24.6.134.204 64378 typ srflx raddr "
"10.0.0.36 rport 64378",
"a=candidate:6 2 UDP 16515070 162.222.183.171 64941 typ relay raddr "
"162.222.183.171 rport 64941",
"a=candidate:6 1 UDP 16515071 162.222.183.171 64800 typ relay raddr "
"162.222.183.171 rport 64800",
"a=candidate:2 1 UDP 1694236671 24.6.134.204 59530 typ srflx raddr "
"10.0.0.36 rport 59530",
"a=candidate:3 1 UDP 100401151 162.222.183.171 62935 typ relay raddr "
"162.222.183.171 rport 62935",
"a=candidate:3 2 UDP 100401150 162.222.183.171 61026 typ relay raddr "
"162.222.183.171 rport 61026",
"a=rtcp:61026",
"a=end-of-candidates",
"a=ssrc:1111 foo",
"a=ssrc:1111 foo:bar",
"a=ssrc:1111 msid:1d0cdb4e-5934-4f0f-9f88-40392cb60d31 "
"315b086a-5cb6-4221-89de-caf0b038c79d",
"a=imageattr:120 send * recv *",
"a=imageattr:121 send [x=640,y=480] recv [x=640,y=480]",
"a=rid:bar recv pt=120;max-width=800;max-height=600",
"a=rid:bar123 recv max-width=1920;max-height=1080",
"a=simulcast:recv bar;bar123",
"m=audio 9 RTP/SAVPF 0",
"a=mid:third",
"a=rtpmap:0 PCMU/8000",
"a=ice-options:foo bar",
"a=msid:noappdata",
"a=bundle-only"};
// SDP from a basic A/V apprtc call FFX/FFX
MOZ_RUNINIT
const std::vector<std::string> kBasicAV1AudioVideoOfferLines = {
"v=0",
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0",
"s=SIP Call",
"c=IN IP4 224.0.0.1/100/12",
"t=0 0",
"a=dtls-message:client " BASE64_DTLS_HELLO,
"a=ice-ufrag:4a799b2e",
"a=ice-pwd:e4cc12a910f106a0a744719425510e17",
"a=ice-lite",
"a=ice-options:trickle foo",
"a=msid-semantic:WMS stream streama",
"a=msid-semantic:foo stream",
"a=fingerprint:sha-256 "
"DF:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:"
"A0:72:9B:14:08:6D:0F:4C",
"a=identity:" LONG_IDENTITY,
"a=group:BUNDLE first second",
"a=group:BUNDLE third",
"a=group:LS first third",
"m=audio 9 RTP/SAVPF 109 9 0 8 101",
"c=IN IP4 0.0.0.0",
"a=mid:first",
"a=rtpmap:109 opus/48000/2",
"a=fmtp:109 maxplaybackrate=32000;stereo=1",
"a=ptime:20",
"a=maxptime:20",
"a=rtpmap:9 G722/8000",
"a=rtpmap:0 PCMU/8000",
"a=rtpmap:8 PCMA/8000",
"a=rtpmap:101 telephone-event/8000",
"a=fmtp:101 0-15,66,32-34,67",
"a=ice-ufrag:00000000",
"a=ice-pwd:0000000000000000000000000000000",
"a=sendonly",
"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level",
"a=setup:actpass",
"a=rtcp-mux",
"a=msid:stream track",
"a=candidate:0 1 UDP 2130379007 10.0.0.36 62453 typ host",
"a=candidate:2 1 UDP 1694236671 24.6.134.204 62453 typ srflx raddr "
"10.0.0.36 rport 62453",
"a=candidate:3 1 UDP 100401151 162.222.183.171 49761 typ relay raddr "
"162.222.183.171 rport 49761",
"a=candidate:6 1 UDP 16515071 162.222.183.171 51858 typ relay raddr "
"162.222.183.171 rport 51858",
"a=candidate:3 2 UDP 100401150 162.222.183.171 62454 typ relay raddr "
"162.222.183.171 rport 62454",
"a=candidate:2 2 UDP 1694236670 24.6.134.204 55428 typ srflx raddr "
"10.0.0.36 rport 55428",
"a=candidate:6 2 UDP 16515070 162.222.183.171 50340 typ relay raddr "
"162.222.183.171 rport 50340",
"a=candidate:0 2 UDP 2130379006 10.0.0.36 55428 typ host",
"a=rtcp:62454 IN IP4 162.222.183.171",
"a=end-of-candidates",
"a=ssrc:5150",
"m=video 9 RTP/SAVPF 99 122 123",
"c=IN IP6 ::1",
"a=fingerprint:sha-1 "
"DF:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C",
"a=mid:second",
"a=rtpmap:98 AV1/90000",
"a=fmtp:98 profile=1;level-idx=1;tier=1;max-fs=3600;max-fr=30",
"a=rtpmap:122 red/90000",
"a=rtpmap:123 ulpfec/90000",
"a=fmtp:122 98/123",
"a=recvonly",
"a=rtcp-fb:98 nack",
"a=rtcp-fb:98 nack pli",
"a=rtcp-fb:98 ccm fir",
"a=rtcp-fb:121 nack",
"a=rtcp-fb:121 nack pli",
"a=rtcp-fb:121 ccm fir",
"a=setup:active",
"a=rtcp-mux",
"a=msid:streama tracka",
"a=msid:streamb trackb",
"a=candidate:0 1 UDP 2130379007 10.0.0.36 59530 typ host",
"a=candidate:0 2 UDP 2130379006 10.0.0.36 64378 typ host",
"a=candidate:2 2 UDP 1694236670 24.6.134.204 64378 typ srflx raddr "
"10.0.0.36 rport 64378",
"a=candidate:6 2 UDP 16515070 162.222.183.171 64941 typ relay raddr "
"162.222.183.171 rport 64941",
"a=candidate:6 1 UDP 16515071 162.222.183.171 64800 typ relay raddr "
"162.222.183.171 rport 64800",
"a=candidate:2 1 UDP 1694236671 24.6.134.204 59530 typ srflx raddr "
"10.0.0.36 rport 59530",
"a=candidate:3 1 UDP 100401151 162.222.183.171 62935 typ relay raddr "
"162.222.183.171 rport 62935",
"a=candidate:3 2 UDP 100401150 162.222.183.171 61026 typ relay raddr "
"162.222.183.171 rport 61026",
"a=rtcp:61026",
"a=end-of-candidates",
"a=ssrc:1111 foo",
"a=ssrc:1111 foo:bar",
"a=ssrc:1111 msid:1d0cdb4e-5934-4f0f-9f88-40392cb60d31 "
"315b086a-5cb6-4221-89de-caf0b038c79d",
"a=imageattr:120 send * recv *",
"a=imageattr:121 send [x=640,y=480] recv [x=640,y=480]",
"m=audio 9 RTP/SAVPF 0",
"a=mid:third",
"a=rtpmap:0 PCMU/8000",
"a=ice-options:foo bar",
"a=msid:noappdata",
"a=bundle-only"};
static std::string joinSdp(
const std::vector<std::string>& aSdp,
const std::string& aEndl) {
std::ostringstream result;
for (
const auto& line : aSdp) {
result << line << aEndl;
}
// Extra endl!
result << aEndl;
return result.str();
}
MOZ_RUNINIT
const std::string kBasicAudioVideoOffer =
joinSdp(kBasicAudioVideoOfferLines,
"\r\n");
MOZ_RUNINIT
const std::string kBasicAudioVideoOfferLinefeedOnly =
joinSdp(kBasicAudioVideoOfferLines,
"\n");
TEST_P(NewSdpTest, BasicAudioVideoSdpParse) { ParseSdp(kBasicAudioVideoOffer); }
MOZ_RUNINIT
const std::string kAv1AudioVideoOffer =
joinSdp(kBasicAudioVideoOfferLines,
"\r\n");
MOZ_RUNINIT
const std::string kAv1AudioVideoOfferLinefeedOnly =
joinSdp(kBasicAudioVideoOfferLines,
"\n");
TEST_P(NewSdpTest, Av1AudioVideoSdpParse) { ParseSdp(kAv1AudioVideoOffer); }
TEST_P(NewSdpTest, Av1AudioVideoSdpParseLinefeedOnly) {
ParseSdp(kAv1AudioVideoOfferLinefeedOnly);
}
TEST_P(NewSdpTest, CheckRemoveFmtp) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
SdpAttributeList& audioAttrList =
Sdp()->GetMediaSection(
0).GetAttributeList();
ASSERT_TRUE(audioAttrList.HasAttribute(SdpAttribute::kFmtpAttribute));
ASSERT_EQ(
2U, audioAttrList.GetFmtp().mFmtps.size());
ASSERT_TRUE(Sdp()->GetMediaSection(
0).FindFmtp(
"109"));
ASSERT_TRUE(Sdp()->GetMediaSection(
0).FindFmtp(
"101"));
Sdp()->GetMediaSection(
0).RemoveFmtp(
"101");
ASSERT_TRUE(audioAttrList.HasAttribute(SdpAttribute::kFmtpAttribute));
ASSERT_EQ(
1U, audioAttrList.GetFmtp().mFmtps.size());
ASSERT_TRUE(Sdp()->GetMediaSection(
0).FindFmtp(
"109"));
ASSERT_FALSE(Sdp()->GetMediaSection(
0).FindFmtp(
"101"));
Sdp()->GetMediaSection(
0).RemoveFmtp(
"109");
ASSERT_TRUE(audioAttrList.HasAttribute(SdpAttribute::kFmtpAttribute));
ASSERT_EQ(
0U, audioAttrList.GetFmtp().mFmtps.size());
ASSERT_FALSE(Sdp()->GetMediaSection(
0).FindFmtp(
"109"));
ASSERT_FALSE(Sdp()->GetMediaSection(
0).FindFmtp(
"101"));
// make sure we haven't disturbed the video fmtps
SdpAttributeList& videoAttrList =
Sdp()->GetMediaSection(
1).GetAttributeList();
ASSERT_TRUE(videoAttrList.HasAttribute(SdpAttribute::kFmtpAttribute));
ASSERT_EQ(
3U, videoAttrList.GetFmtp().mFmtps.size());
ASSERT_TRUE(Sdp()->GetMediaSection(
1).FindFmtp(
"120"));
ASSERT_TRUE(Sdp()->GetMediaSection(
1).FindFmtp(
"121"));
ASSERT_TRUE(Sdp()->GetMediaSection(
1).FindFmtp(
"122"));
}
TEST_P(NewSdpTest, CheckIceUfrag) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_TRUE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kIceUfragAttribute));
auto ice_ufrag = Sdp()->GetAttributeList().GetIceUfrag();
ASSERT_EQ(
"4a799b2e", ice_ufrag) <<
"Wrong ice-ufrag value";
ice_ufrag = Sdp()->GetMediaSection(
0).GetAttributeList().GetIceUfrag();
ASSERT_EQ(
"00000000", ice_ufrag) <<
"ice-ufrag isn't overridden";
ice_ufrag = Sdp()->GetMediaSection(
1).GetAttributeList().GetIceUfrag();
ASSERT_EQ(
"4a799b2e", ice_ufrag) <<
"ice-ufrag isn't carried to m-section";
}
TEST_P(NewSdpTest, CheckIcePwd) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_TRUE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kIcePwdAttribute));
auto ice_pwd = Sdp()->GetAttributeList().GetIcePwd();
ASSERT_EQ(
"e4cc12a910f106a0a744719425510e17", ice_pwd)
<<
"Wrong ice-pwd value";
ice_pwd = Sdp()->GetMediaSection(
0).GetAttributeList().GetIcePwd();
ASSERT_EQ(
"0000000000000000000000000000000", ice_pwd)
<<
"ice-pwd isn't overridden";
ice_pwd = Sdp()->GetMediaSection(
1).GetAttributeList().GetIcePwd();
ASSERT_EQ(
"e4cc12a910f106a0a744719425510e17", ice_pwd)
<<
"ice-pwd isn't carried to m-section";
}
TEST_P(NewSdpTest, CheckIceOptions) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_TRUE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kIceOptionsAttribute));
auto ice_options = Sdp()->GetAttributeList().GetIceOptions();
ASSERT_EQ(
2U, ice_options.mValues.size()) <<
"Wrong ice-options size";
ASSERT_EQ(
"trickle", ice_options.mValues[
0]) <<
"Wrong ice-options value";
ASSERT_EQ(
"foo", ice_options.mValues[
1]) <<
"Wrong ice-options value";
ASSERT_TRUE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kIceOptionsAttribute));
auto ice_options_media_level =
Sdp()->GetMediaSection(
2).GetAttributeList().GetIceOptions();
ASSERT_EQ(
2U, ice_options_media_level.mValues.size())
<<
"Wrong ice-options size";
ASSERT_EQ(
"foo", ice_options_media_level.mValues[
0])
<<
"Wrong ice-options value";
ASSERT_EQ(
"bar", ice_options_media_level.mValues[
1])
<<
"Wrong ice-options value";
}
TEST_P(NewSdpTest, CheckFingerprint) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_TRUE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kFingerprintAttribute));
auto fingerprints = Sdp()->GetAttributeList().GetFingerprint();
ASSERT_EQ(
1U, fingerprints.mFingerprints.size());
ASSERT_EQ(SdpFingerprintAttributeList::kSha256,
fingerprints.mFingerprints[
0].hashFunc)
<<
"Wrong hash function";
ASSERT_EQ(
"DF:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7:FA:FB:08:"
"3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C",
SdpFingerprintAttributeList::FormatFingerprint(
fingerprints.mFingerprints[
0].fingerprint))
<<
"Wrong fingerprint";
ASSERT_EQ(
0xdfU, fingerprints.mFingerprints[
0].fingerprint[
0])
<<
"first fingerprint element is iffy";
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount());
// Fallback to session level
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFingerprintAttribute));
fingerprints = Sdp()->GetMediaSection(
0).GetAttributeList().GetFingerprint();
ASSERT_EQ(
1U, fingerprints.mFingerprints.size());
ASSERT_EQ(SdpFingerprintAttributeList::kSha256,
fingerprints.mFingerprints[
0].hashFunc)
<<
"Wrong hash function";
ASSERT_EQ(
"DF:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7:FA:FB:08:"
"3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C",
SdpFingerprintAttributeList::FormatFingerprint(
fingerprints.mFingerprints[
0].fingerprint))
<<
"Wrong fingerprint";
ASSERT_EQ(
0xdfU, fingerprints.mFingerprints[
0].fingerprint[
0])
<<
"first fingerprint element is iffy";
// Media level
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kFingerprintAttribute));
fingerprints = Sdp()->GetMediaSection(
1).GetAttributeList().GetFingerprint();
ASSERT_EQ(
1U, fingerprints.mFingerprints.size());
ASSERT_EQ(SdpFingerprintAttributeList::kSha1,
fingerprints.mFingerprints[
0].hashFunc)
<<
"Wrong hash function";
ASSERT_EQ(
"DF:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:"
"08:6D:0F:4C",
SdpFingerprintAttributeList::FormatFingerprint(
fingerprints.mFingerprints[
0].fingerprint))
<<
"Wrong fingerprint";
ASSERT_EQ(
0xdfU, fingerprints.mFingerprints[
0].fingerprint[
0])
<<
"first fingerprint element is iffy";
}
TEST_P(NewSdpTest, CheckIdentity) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_TRUE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kIdentityAttribute));
auto identity = Sdp()->GetAttributeList().GetIdentity();
ASSERT_EQ(LONG_IDENTITY, identity) <<
"Wrong identity assertion";
}
TEST_P(NewSdpTest, CheckDtlsMessage) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_TRUE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kDtlsMessageAttribute));
auto dtls_message = Sdp()->GetAttributeList().GetDtlsMessage();
ASSERT_EQ(SdpDtlsMessageAttribute::kClient, dtls_message.mRole)
<<
"Wrong dtls-message role";
ASSERT_EQ(BASE64_DTLS_HELLO, dtls_message.mValue)
<<
"Wrong dtls-message value";
}
TEST_P(NewSdpTest, CheckNumberOfMediaSections) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
}
TEST_P(NewSdpTest, CheckMlines) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_EQ(SdpMediaSection::kAudio, Sdp()->GetMediaSection(
0).GetMediaType())
<<
"Wrong type for first media section";
ASSERT_EQ(SdpMediaSection::kRtpSavpf, Sdp()->GetMediaSection(
0).GetProtocol())
<<
"Wrong protocol for audio";
auto audio_formats = Sdp()->GetMediaSection(
0).GetFormats();
ASSERT_EQ(
5U, audio_formats.size()) <<
"Wrong number of formats for audio";
ASSERT_EQ(
"109", audio_formats[
0]);
ASSERT_EQ(
"9", audio_formats[
1]);
ASSERT_EQ(
"0", audio_formats[
2]);
ASSERT_EQ(
"8", audio_formats[
3]);
ASSERT_EQ(
"101", audio_formats[
4]);
ASSERT_EQ(SdpMediaSection::kVideo, Sdp()->GetMediaSection(
1).GetMediaType())
<<
"Wrong type for second media section";
ASSERT_EQ(SdpMediaSection::kRtpSavpf, Sdp()->GetMediaSection(
1).GetProtocol())
<<
"Wrong protocol for video";
auto video_formats = Sdp()->GetMediaSection(
1).GetFormats();
ASSERT_EQ(
4U, video_formats.size()) <<
"Wrong number of formats for video";
ASSERT_EQ(
"120", video_formats[
0]);
ASSERT_EQ(
"121", video_formats[
1]);
ASSERT_EQ(
"122", video_formats[
2]);
ASSERT_EQ(
"123", video_formats[
3]);
ASSERT_EQ(SdpMediaSection::kAudio, Sdp()->GetMediaSection(
2).GetMediaType())
<<
"Wrong type for third media section";
}
TEST_P(NewSdpTest, CheckSetup) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kSetupAttribute));
ASSERT_EQ(SdpSetupAttribute::kActpass,
Sdp()->GetMediaSection(
0).GetAttributeList().GetSetup().mRole);
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kSetupAttribute));
ASSERT_EQ(SdpSetupAttribute::kActive,
Sdp()->GetMediaSection(
1).GetAttributeList().GetSetup().mRole);
ASSERT_FALSE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kSetupAttribute));
}
TEST_P(NewSdpTest, CheckSsrc) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kSsrcAttribute));
auto ssrcs = Sdp()->GetMediaSection(
0).GetAttributeList().GetSsrc().mSsrcs;
ASSERT_EQ(
1U, ssrcs.size());
ASSERT_EQ(
5150U, ssrcs[
0].ssrc);
ASSERT_EQ(
"", ssrcs[
0].attribute);
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kSsrcAttribute));
ssrcs = Sdp()->GetMediaSection(
1).GetAttributeList().GetSsrc().mSsrcs;
ASSERT_EQ(
3U, ssrcs.size());
ASSERT_EQ(
1111U, ssrcs[
0].ssrc);
ASSERT_EQ(
"foo", ssrcs[
0].attribute);
ASSERT_EQ(
1111U, ssrcs[
1].ssrc);
ASSERT_EQ(
"foo:bar", ssrcs[
1].attribute);
ASSERT_EQ(
1111U, ssrcs[
2].ssrc);
ASSERT_EQ(
"msid:1d0cdb4e-5934-4f0f-9f88-40392cb60d31 "
"315b086a-5cb6-4221-89de-caf0b038c79d",
ssrcs[
2].attribute);
}
TEST_P(NewSdpTest, CheckRtpmap) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
const SdpMediaSection& audiosec = Sdp()->GetMediaSection(
0);
const SdpRtpmapAttributeList& rtpmap =
audiosec.GetAttributeList().GetRtpmap();
ASSERT_EQ(
5U, rtpmap.mRtpmaps.size())
<<
"Wrong number of rtpmap attributes for audio";
// Need to know name of type
CheckRtpmap(
"109", SdpRtpmapAttributeList::kOpus,
"opus",
48000,
2,
audiosec.GetFormats()[
0], rtpmap);
CheckRtpmap(
"9", SdpRtpmapAttributeList::kG722,
"G722",
8000,
1,
audiosec.GetFormats()[
1], rtpmap);
CheckRtpmap(
"0", SdpRtpmapAttributeList::kPCMU,
"PCMU",
8000,
1,
audiosec.GetFormats()[
2], rtpmap);
CheckRtpmap(
"8", SdpRtpmapAttributeList::kPCMA,
"PCMA",
8000,
1,
audiosec.GetFormats()[
3], rtpmap);
CheckRtpmap(
"101", SdpRtpmapAttributeList::kTelephoneEvent,
"telephone-event",
8000,
1, audiosec.GetFormats()[
4], rtpmap);
const SdpMediaSection& videosec = Sdp()->GetMediaSection(
1);
const SdpRtpmapAttributeList videoRtpmap =
videosec.GetAttributeList().GetRtpmap();
ASSERT_EQ(
4U, videoRtpmap.mRtpmaps.size())
<<
"Wrong number of rtpmap attributes for video";
CheckRtpmap(
"120", SdpRtpmapAttributeList::kVP8,
"VP8",
90000,
0,
videosec.GetFormats()[
0], videoRtpmap);
CheckRtpmap(
"121", SdpRtpmapAttributeList::kVP9,
"VP9",
90000,
0,
videosec.GetFormats()[
1], videoRtpmap);
CheckRtpmap(
"122", SdpRtpmapAttributeList::kRed,
"red",
90000,
0,
videosec.GetFormats()[
2], videoRtpmap);
CheckRtpmap(
"123", SdpRtpmapAttributeList::kUlpfec,
"ulpfec",
90000,
0,
videosec.GetFormats()[
3], videoRtpmap);
}
MOZ_RUNINIT
static const std::string kAudioWithTelephoneEvent =
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"t=0 0" CRLF
"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=mid:first" CRLF
"a=rtpmap:109 opus/48000/2" CRLF
"a=fmtp:109 maxplaybackrate=32000;stereo=1" CRLF
"a=ptime:20" CRLF
"a=maxptime:20" CRLF
"a=rtpmap:9 G722/8000" CRLF
"a=rtpmap:0 PCMU/8000" CRLF
"a=rtpmap:8 PCMA/8000" CRLF
"a=rtpmap:101 telephone-event/8000" CRLF;
TEST_P(NewSdpTest, CheckTelephoneEventNoFmtp) {
ParseSdp(kAudioWithTelephoneEvent);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
auto audio_format_params =
Sdp()->GetMediaSection(
0).GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
1U, audio_format_params.size());
// make sure we don't get a fmtp for codec 101
for (size_t i =
0; i < audio_format_params.size(); ++i) {
ASSERT_NE(
"101", audio_format_params[i].format);
}
}
TEST_P(NewSdpTest, CheckTelephoneEventWithDefaultEvents) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 0-15" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventWithBadCharacter) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 0-5." CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventIncludingCommas) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 0-15,66,67" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
CheckDtmfFmtp(
"0-15,66,67");
}
TEST_P(NewSdpTest, CheckTelephoneEventComplexEvents) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 0,1,2-4,5-15,66,67" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
CheckDtmfFmtp(
"0,1,2-4,5-15,66,67");
}
TEST_P(NewSdpTest, CheckTelephoneEventNoHyphen) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 5,6,7" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
CheckDtmfFmtp(
"5,6,7");
}
TEST_P(NewSdpTest, CheckTelephoneEventOnlyZero) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 0" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
CheckDtmfFmtp(
"0");
}
TEST_P(NewSdpTest, CheckTelephoneEventOnlyOne) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 1" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
CheckDtmfFmtp(
"1");
}
TEST_P(NewSdpTest, CheckTelephoneEventBadThreeDigit) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 123" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
// check for the default dtmf tones
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventBadThreeDigitWithHyphen) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 0-123" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
// check for the default dtmf tones
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventBadLeadingHyphen) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 -12" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
// check for the default dtmf tones
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventBadTrailingHyphen) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 12-" CRLF,
false);
}
TEST_P(NewSdpTest, CheckTelephoneEventBadTrailingHyphenInMiddle) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 1,12-,4" CRLF,
false);
}
TEST_P(NewSdpTest, CheckTelephoneEventBadLeadingComma) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 ,2,3" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
// check for the default dtmf tones
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventBadMultipleLeadingComma) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 ,,,2,3" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
// check for the default dtmf tones
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventBadConsecutiveCommas) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 1,,,,,,,,3" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
// check for the default dtmf tones
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventBadTrailingComma) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 1,2,3," CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
// check for the default dtmf tones
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventBadTwoHyphens) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 1-2-3" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
// check for the default dtmf tones
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventBadSixDigit) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 112233" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
// check for the default dtmf tones
CheckDtmfFmtp(
"0-15");
}
TEST_P(NewSdpTest, CheckTelephoneEventBadRangeReversed) {
ParseSdp(kAudioWithTelephoneEvent +
"a=fmtp:101 33-2" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
// check for the default dtmf tones
CheckDtmfFmtp(
"0-15");
}
MOZ_RUNINIT
static const std::string kVideoWithRedAndUlpfecSdp =
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"t=0 0" CRLF
"m=video 9 RTP/SAVPF 97 120 121 122 123" CRLF
"c=IN IP6 ::1" CRLF
"a=fingerprint:sha-1 "
"DF:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:A0:72:9B:14:08:6D:0F:4C" CRLF
"a=rtpmap:97 H264/90000" CRLF
"a=fmtp:97 profile-level-id=42a01e" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=fmtp:120 max-fs=3600;max-fr=30" CRLF
"a=rtpmap:121 VP9/90000" CRLF
"a=fmtp:121 max-fs=3600;max-fr=30" CRLF
"a=rtpmap:122 red/90000" CRLF
"a=rtpmap:123 ulpfec/90000" CRLF;
TEST_P(NewSdpTest, CheckRedNoFmtp) {
ParseSdp(kVideoWithRedAndUlpfecSdp);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
auto video_format_params =
Sdp()->GetMediaSection(
0).GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
3U, video_format_params.size());
// make sure we don't get a fmtp for codec 122
for (size_t i =
0; i < video_format_params.size(); ++i) {
ASSERT_NE(
"122", video_format_params[i].format);
}
}
TEST_P(NewSdpTest, CheckRedEmptyFmtp) {
// if serializing and re-parsing, we expect errors
if (::testing::get<
0>(GetParam())) {
ParseSdp(kVideoWithRedAndUlpfecSdp +
"a=fmtp:122" CRLF,
false);
}
else {
ParseSdp(kVideoWithRedAndUlpfecSdp +
"a=fmtp:122" CRLF,
false);
if (ResultsAreFromSipcc()) {
ASSERT_NE(
0U, ParseErrorCount());
}
else {
// This is the branch for the rust parser to check for warnings, as the
// rust parser will give a warning at that point instead of an error.
ASSERT_NE(
0U, ParseWarningCount());
}
}
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
auto video_format_params =
Sdp()->GetMediaSection(
0).GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
3U, video_format_params.size());
// make sure we don't get a fmtp for codec 122
for (size_t i =
0; i < video_format_params.size(); ++i) {
ASSERT_NE(
"122", video_format_params[i].format);
}
}
TEST_P(NewSdpTest, CheckRedFmtpWith2Codecs) {
ParseSdp(kVideoWithRedAndUlpfecSdp +
"a=fmtp:122 120/121" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
auto video_format_params =
Sdp()->GetMediaSection(
0).GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
4U, video_format_params.size());
ASSERT_EQ(
"122", video_format_params[
3].format);
ASSERT_TRUE(!!video_format_params[
3].parameters);
ASSERT_EQ(SdpRtpmapAttributeList::kRed,
video_format_params[
3].parameters->codec_type);
const SdpFmtpAttributeList::RedParameters* red_parameters(
static_cast<SdpFmtpAttributeList::RedParameters*>(
video_format_params[
3].parameters.get()));
ASSERT_EQ(
2U, red_parameters->encodings.size());
ASSERT_EQ(
120U, red_parameters->encodings[
0]);
ASSERT_EQ(
121U, red_parameters->encodings[
1]);
}
TEST_P(NewSdpTest, CheckRedFmtpWith3Codecs) {
ParseSdp(kVideoWithRedAndUlpfecSdp +
"a=fmtp:122 120/121/123" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
auto video_format_params =
Sdp()->GetMediaSection(
0).GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
4U, video_format_params.size());
ASSERT_EQ(
"122", video_format_params[
3].format);
ASSERT_TRUE(!!video_format_params[
3].parameters);
ASSERT_EQ(SdpRtpmapAttributeList::kRed,
video_format_params[
3].parameters->codec_type);
const SdpFmtpAttributeList::RedParameters* red_parameters(
static_cast<SdpFmtpAttributeList::RedParameters*>(
video_format_params[
3].parameters.get()));
ASSERT_EQ(
3U, red_parameters->encodings.size());
ASSERT_EQ(
120U, red_parameters->encodings[
0]);
ASSERT_EQ(
121U, red_parameters->encodings[
1]);
ASSERT_EQ(
123U, red_parameters->encodings[
2]);
}
MOZ_RUNINIT
const std::string kH264AudioVideoOffer =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=ice-ufrag:4a799b2e" CRLF
"a=ice-pwd:e4cc12a910f106a0a744719425510e17" CRLF
"a=ice-lite" CRLF
"a=msid-semantic:WMS stream streama" CRLF
"a=fingerprint:sha-256 "
"DF:2E:AC:8A:FD:0A:8E:99:BF:5D:E8:3C:E7:FA:FB:08:3B:3C:54:1D:D7:D4:05:77:"
"A0:72:9B:14:08:6D:0F:4C" CRLF
"a=group:BUNDLE first second" CRLF
"a=group:BUNDLE third" CRLF
"a=group:LS first third" CRLF
"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=mid:first" CRLF
"a=rtpmap:109 opus/48000/2" CRLF
"a=ptime:20" CRLF
"a=maxptime:20" CRLF
"a=rtpmap:9 G722/8000" CRLF
"a=rtpmap:0 PCMU/8000" CRLF
"a=rtpmap:8 PCMA/8000" CRLF
"a=rtpmap:101 telephone-event/8000" CRLF
"a=fmtp:109 maxplaybackrate=32000;stereo=1;useinbandfec=1" CRLF
"a=fmtp:101 0-15,66,32-34,67" CRLF
"a=ice-ufrag:00000000" CRLF
"a=ice-pwd:0000000000000000000000000000000" CRLF
"a=sendonly" CRLF
"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level" CRLF
"a=setup:actpass" CRLF
"a=rtcp-mux" CRLF
"a=msid:stream track" CRLF
"a=candidate:0 1 UDP 2130379007 10.0.0.36 62453 typ host" CRLF
"a=candidate:2 1 UDP 1694236671 24.6.134.204 62453 typ srflx raddr "
"10.0.0.36 rport 62453" CRLF
"a=candidate:3 1 UDP 100401151 162.222.183.171 49761 typ relay raddr "
"162.222.183.171 rport 49761" CRLF
"a=candidate:6 1 UDP 16515071 162.222.183.171 51858 typ relay raddr "
"162.222.183.171 rport 51858" CRLF
"a=candidate:3 2 UDP 100401150 162.222.183.171 62454 typ relay raddr "
"162.222.183.171 rport 62454" CRLF
"a=candidate:2 2 UDP 1694236670 24.6.134.204 55428 typ srflx raddr "
"10.0.0.36 rport 55428" CRLF
"a=candidate:6 2 UDP 16515070 162.222.183.171 50340 typ relay raddr "
"162.222.183.171 rport 50340" CRLF
"a=candidate:0 2 UDP 2130379006 10.0.0.36 55428 typ host" CRLF
"m=video 9 RTP/SAVPF 97 98 120" CRLF
"c=IN IP6 ::1" CRLF
"a=mid:second" CRLF
"a=rtpmap:97 H264/90000" CRLF
"a=fmtp:97 profile-level-id=42a01e" CRLF
"a=rtpmap:98 H264/90000" CRLF
"a=fmtp:98 "
"PROFILE=0;LEVEL=0;parameter-add=1;profile-level-id=42a00d;packetization-"
"mode=1;level-asymmetry-allowed=1;max-mbps=42000;max-fs=1400;max-cpb=1000;"
"max-dpb=1000;max-br=180000;usedtx=0;stereo=0;useinbandfec=0;cbr=0" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=fmtp:120 max-fs=3601;max-fr=31" CRLF
"a=recvonly" CRLF
"a=setup:active" CRLF
"a=rtcp-mux" CRLF
"a=msid:streama tracka" CRLF
"a=msid:streamb trackb" CRLF
"a=candidate:0 1 UDP 2130379007 10.0.0.36 59530 typ host" CRLF
"a=candidate:0 2 UDP 2130379006 10.0.0.36 64378 typ host" CRLF
"a=candidate:2 2 UDP 1694236670 24.6.134.204 64378 typ srflx raddr "
"10.0.0.36 rport 64378" CRLF
"a=candidate:6 2 UDP 16515070 162.222.183.171 64941 typ relay raddr "
"162.222.183.171 rport 64941" CRLF
"a=candidate:6 1 UDP 16515071 162.222.183.171 64800 typ relay raddr "
"162.222.183.171 rport 64800" CRLF
"a=candidate:2 1 UDP 1694236671 24.6.134.204 59530 typ srflx raddr "
"10.0.0.36 rport 59530" CRLF
"a=candidate:3 1 UDP 100401151 162.222.183.171 62935 typ relay raddr "
"162.222.183.171 rport 62935" CRLF
"a=candidate:3 2 UDP 100401150 162.222.183.171 61026 typ relay raddr "
"162.222.183.171 rport 61026" CRLF
"m=audio 9 RTP/SAVPF 0" CRLF
"a=mid:third" CRLF
"a=rtpmap:0 PCMU/8000" CRLF
"a=msid:noappdata" CRLF;
TEST_P(NewSdpTest, CheckFormatParameters) {
ParseSdp(kH264AudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
auto audio_format_params =
Sdp()->GetMediaSection(
0).GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
2U, audio_format_params.size());
ASSERT_EQ(
"109", audio_format_params[
0].format);
ASSERT_TRUE(!!audio_format_params[
0].parameters);
const SdpFmtpAttributeList::OpusParameters* opus_parameters =
static_cast<SdpFmtpAttributeList::OpusParameters*>(
audio_format_params[
0].parameters.get());
ASSERT_EQ(
32000U, opus_parameters->maxplaybackrate);
ASSERT_EQ(
1U, opus_parameters->stereo);
ASSERT_EQ(
1U, opus_parameters->useInBandFec);
ASSERT_EQ(
0U, opus_parameters->maxAverageBitrate);
ASSERT_EQ(
0U, opus_parameters->useDTX);
ASSERT_EQ(
0U, opus_parameters->useCbr);
ASSERT_EQ(
0U, opus_parameters->frameSizeMs);
ASSERT_EQ(
0U, opus_parameters->minFrameSizeMs);
ASSERT_EQ(
0U, opus_parameters->maxFrameSizeMs);
ASSERT_EQ(
"101", audio_format_params[
1].format);
ASSERT_TRUE(!!audio_format_params[
1].parameters);
const SdpFmtpAttributeList::TelephoneEventParameters* te_parameters =
static_cast<SdpFmtpAttributeList::TelephoneEventParameters*>(
audio_format_params[
1].parameters.get());
ASSERT_NE(
0U, te_parameters->dtmfTones.size());
ASSERT_EQ(
"0-15,66,32-34,67", te_parameters->dtmfTones);
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
auto video_format_params =
Sdp()->GetMediaSection(
1).GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
3U, video_format_params.size());
ASSERT_EQ(
"97", video_format_params[
0].format);
ASSERT_TRUE(!!video_format_params[
0].parameters);
ASSERT_EQ(SdpRtpmapAttributeList::kH264,
video_format_params[
0].parameters->codec_type);
const SdpFmtpAttributeList::H264Parameters* h264_parameters(
static_cast<SdpFmtpAttributeList::H264Parameters*>(
video_format_params[
0].parameters.get()));
ASSERT_EQ((uint32_t)
0x42a01e, h264_parameters->profile_level_id);
ASSERT_EQ(
0U, h264_parameters->packetization_mode);
ASSERT_FALSE(
static_cast<
bool>(h264_parameters->level_asymmetry_allowed));
ASSERT_EQ(
0U, h264_parameters->max_mbps);
ASSERT_EQ(
0U, h264_parameters->max_fs);
ASSERT_EQ(
0U, h264_parameters->max_cpb);
ASSERT_EQ(
0U, h264_parameters->max_dpb);
ASSERT_EQ(
0U, h264_parameters->max_br);
ASSERT_EQ(
"98", video_format_params[
1].format);
ASSERT_TRUE(!!video_format_params[
1].parameters);
ASSERT_EQ(SdpRtpmapAttributeList::kH264,
video_format_params[
1].parameters->codec_type);
h264_parameters =
static_cast<SdpFmtpAttributeList::H264Parameters*>(
video_format_params[
1].parameters.get());
ASSERT_EQ((uint32_t)
0x42a00d, h264_parameters->profile_level_id);
ASSERT_EQ(
1U, h264_parameters->packetization_mode);
ASSERT_TRUE(
static_cast<
bool>(h264_parameters->level_asymmetry_allowed));
ASSERT_EQ(
42000U, h264_parameters->max_mbps);
ASSERT_EQ(
1400U, h264_parameters->max_fs);
ASSERT_EQ(
1000U, h264_parameters->max_cpb);
ASSERT_EQ(
1000U, h264_parameters->max_dpb);
ASSERT_EQ(
180000U, h264_parameters->max_br);
ASSERT_EQ(
"120", video_format_params[
2].format);
ASSERT_TRUE(!!video_format_params[
2].parameters);
ASSERT_EQ(SdpRtpmapAttributeList::kVP8,
video_format_params[
2].parameters->codec_type);
const SdpFmtpAttributeList::VP8Parameters* vp8_parameters =
static_cast<SdpFmtpAttributeList::VP8Parameters*>(
video_format_params[
2].parameters.get());
ASSERT_EQ(
3601U, vp8_parameters->max_fs);
ASSERT_EQ(
31U, vp8_parameters->max_fr);
ASSERT_FALSE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
}
TEST_P(NewSdpTest, CheckPtime) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_EQ(
20U, Sdp()->GetMediaSection(
0).GetAttributeList().GetPtime());
ASSERT_FALSE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kPtimeAttribute));
}
TEST_P(NewSdpTest, CheckFlags) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kIceLiteAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kIceLiteAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kIceLiteAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kIceLiteAttribute));
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kRtcpMuxAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kRtcpMuxAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kBundleOnlyAttribute));
ASSERT_TRUE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kBundleOnlyAttribute));
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kEndOfCandidatesAttribute));
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kEndOfCandidatesAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kEndOfCandidatesAttribute));
}
TEST_P(NewSdpTest, CheckConnectionLines) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
const SdpConnection& conn1 = Sdp()->GetMediaSection(
0).GetConnection();
ASSERT_EQ(sdp::kIPv4, conn1.GetAddrType());
ASSERT_EQ(
"0.0.0.0", conn1.GetAddress());
ASSERT_EQ(
0U, conn1.GetTtl());
ASSERT_EQ(
0U, conn1.GetCount());
const SdpConnection& conn2 = Sdp()->GetMediaSection(
1).GetConnection();
ASSERT_EQ(sdp::kIPv6, conn2.GetAddrType());
ASSERT_EQ(
"::1", conn2.GetAddress());
ASSERT_EQ(
0U, conn2.GetTtl());
ASSERT_EQ(
0U, conn2.GetCount());
// tests that we can fall through to session level as appropriate
const SdpConnection& conn3 = Sdp()->GetMediaSection(
2).GetConnection();
ASSERT_EQ(sdp::kIPv4, conn3.GetAddrType());
ASSERT_EQ(
"224.0.0.1", conn3.GetAddress());
ASSERT_EQ(
100U, conn3.GetTtl());
ASSERT_EQ(
12U, conn3.GetCount());
}
TEST_P(NewSdpTest, CheckDirections) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(SdpDirectionAttribute::kSendonly,
Sdp()->GetMediaSection(
0).GetAttributeList().GetDirection());
ASSERT_EQ(SdpDirectionAttribute::kRecvonly,
Sdp()->GetMediaSection(
1).GetAttributeList().GetDirection());
ASSERT_EQ(SdpDirectionAttribute::kSendrecv,
Sdp()->GetMediaSection(
2).GetAttributeList().GetDirection());
}
TEST_P(NewSdpTest, CheckCandidates) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kCandidateAttribute));
auto audio_candidates =
Sdp()->GetMediaSection(
0).GetAttributeList().GetCandidate();
ASSERT_EQ(
8U, audio_candidates.size());
ASSERT_EQ(
"0 1 UDP 2130379007 10.0.0.36 62453 typ host", audio_candidates[
0]);
ASSERT_EQ(
"2 1 UDP 1694236671 24.6.134.204 62453 typ srflx raddr 10.0.0.36 rport "
"62453",
audio_candidates[
1]);
ASSERT_EQ(
"3 1 UDP 100401151 162.222.183.171 49761 typ relay raddr 162.222.183.171 "
"rport 49761",
audio_candidates[
2]);
ASSERT_EQ(
"6 1 UDP 16515071 162.222.183.171 51858 typ relay raddr 162.222.183.171 "
"rport 51858",
audio_candidates[
3]);
ASSERT_EQ(
"3 2 UDP 100401150 162.222.183.171 62454 typ relay raddr 162.222.183.171 "
"rport 62454",
audio_candidates[
4]);
ASSERT_EQ(
"2 2 UDP 1694236670 24.6.134.204 55428 typ srflx raddr 10.0.0.36 rport "
"55428",
audio_candidates[
5]);
ASSERT_EQ(
"6 2 UDP 16515070 162.222.183.171 50340 typ relay raddr 162.222.183.171 "
"rport 50340",
audio_candidates[
6]);
ASSERT_EQ(
"0 2 UDP 2130379006 10.0.0.36 55428 typ host", audio_candidates[
7]);
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kCandidateAttribute));
auto video_candidates =
Sdp()->GetMediaSection(
1).GetAttributeList().GetCandidate();
ASSERT_EQ(
8U, video_candidates.size());
ASSERT_EQ(
"0 1 UDP 2130379007 10.0.0.36 59530 typ host", video_candidates[
0]);
ASSERT_EQ(
"0 2 UDP 2130379006 10.0.0.36 64378 typ host", video_candidates[
1]);
ASSERT_EQ(
"2 2 UDP 1694236670 24.6.134.204 64378 typ srflx raddr 10.0.0.36 rport "
"64378",
video_candidates[
2]);
ASSERT_EQ(
"6 2 UDP 16515070 162.222.183.171 64941 typ relay raddr 162.222.183.171 "
"rport 64941",
video_candidates[
3]);
ASSERT_EQ(
"6 1 UDP 16515071 162.222.183.171 64800 typ relay raddr 162.222.183.171 "
"rport 64800",
video_candidates[
4]);
ASSERT_EQ(
"2 1 UDP 1694236671 24.6.134.204 59530 typ srflx raddr 10.0.0.36 rport "
"59530",
video_candidates[
5]);
ASSERT_EQ(
"3 1 UDP 100401151 162.222.183.171 62935 typ relay raddr 162.222.183.171 "
"rport 62935",
video_candidates[
6]);
ASSERT_EQ(
"3 2 UDP 100401150 162.222.183.171 61026 typ relay raddr 162.222.183.171 "
"rport 61026",
video_candidates[
7]);
ASSERT_FALSE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kCandidateAttribute));
}
TEST_P(NewSdpTest, CheckMid) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_EQ(
"first", Sdp()->GetMediaSection(
0).GetAttributeList().GetMid());
ASSERT_EQ(
"second", Sdp()->GetMediaSection(
1).GetAttributeList().GetMid());
ASSERT_EQ(
"third", Sdp()->GetMediaSection(
2).GetAttributeList().GetMid());
}
TEST_P(NewSdpTest, CheckMsid) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kMsidSemanticAttribute));
auto semantics = Sdp()->GetAttributeList().GetMsidSemantic().mMsidSemantics;
ASSERT_EQ(
2U, semantics.size());
ASSERT_EQ(
"WMS", semantics[
0].semantic);
ASSERT_EQ(
2U, semantics[
0].msids.size());
ASSERT_EQ(
"stream", semantics[
0].msids[
0]);
ASSERT_EQ(
"streama", semantics[
0].msids[
1]);
ASSERT_EQ(
"foo", semantics[
1].semantic);
ASSERT_EQ(
1U, semantics[
1].msids.size());
ASSERT_EQ(
"stream", semantics[
1].msids[
0]);
const SdpMsidAttributeList& msids1 =
Sdp()->GetMediaSection(
0).GetAttributeList().GetMsid();
ASSERT_EQ(
1U, msids1.mMsids.size());
ASSERT_EQ(
"stream", msids1.mMsids[
0].identifier);
ASSERT_EQ(
"track", msids1.mMsids[
0].appdata);
const SdpMsidAttributeList& msids2 =
Sdp()->GetMediaSection(
1).GetAttributeList().GetMsid();
ASSERT_EQ(
2U, msids2.mMsids.size());
ASSERT_EQ(
"streama", msids2.mMsids[
0].identifier);
ASSERT_EQ(
"tracka", msids2.mMsids[
0].appdata);
ASSERT_EQ(
"streamb", msids2.mMsids[
1].identifier);
ASSERT_EQ(
"trackb", msids2.mMsids[
1].appdata);
const SdpMsidAttributeList& msids3 =
Sdp()->GetMediaSection(
2).GetAttributeList().GetMsid();
ASSERT_EQ(
1U, msids3.mMsids.size());
ASSERT_EQ(
"noappdata", msids3.mMsids[
0].identifier);
ASSERT_EQ(
"", msids3.mMsids[
0].appdata);
}
TEST_P(NewSdpTest, CheckManyMsidSemantics) {
if (::testing::get<
0>(GetParam())) {
return;
}
std::ostringstream msid;
msid <<
"a=msid-semantic: foo";
for (size_t i =
0; i < SDP_MAX_MEDIA_STREAMS +
1; ++i) {
msid <<
" " << i;
}
msid << CRLF;
std::string offer =
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"t=0 0" CRLF;
offer += msid.str();
offer +=
"m=video 56436 RTP/SAVPF 120" CRLF
"b=CT:1000" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
ParseSdp(offer);
auto semantics = Sdp()->GetAttributeList().GetMsidSemantic().mMsidSemantics;
ASSERT_EQ(
1U, semantics.size());
// Only sipcc is limited by SDP_MAX_MEDIA_STREAMS, the Rust parser
// will parse all of the msids.
ASSERT_GE(semantics[
0].msids.size(),
static_cast<size_t>(SDP_MAX_MEDIA_STREAMS));
}
TEST_P(NewSdpTest, CheckRid) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp());
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kRidAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kRidAttribute));
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kRidAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kRidAttribute));
const SdpRidAttributeList& rids =
Sdp()->GetMediaSection(
1).GetAttributeList().GetRid();
ASSERT_EQ(
2U, rids.mRids.size());
ASSERT_EQ(
"bar", rids.mRids[
0].id);
ASSERT_EQ(sdp::kRecv, rids.mRids[
0].direction);
ASSERT_EQ(
1U, rids.mRids[
0].formats.size());
ASSERT_EQ(
120U, rids.mRids[
0].formats[
0]);
ASSERT_EQ(
800U, rids.mRids[
0].constraints.maxWidth);
ASSERT_EQ(
600U, rids.mRids[
0].constraints.maxHeight);
ASSERT_EQ(
"bar123", rids.mRids[
1].id);
ASSERT_EQ(sdp::kRecv, rids.mRids[
1].direction);
ASSERT_EQ(
0U, rids.mRids[
1].formats.size());
ASSERT_EQ(
1920U, rids.mRids[
1].constraints.maxWidth);
ASSERT_EQ(
1080U, rids.mRids[
1].constraints.maxHeight);
}
TEST_P(NewSdpTest, CheckMediaLevelIceUfrag) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kIceUfragAttribute,
true));
ASSERT_EQ(
"00000000",
Sdp()->GetMediaSection(
0).GetAttributeList().GetIceUfrag());
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kIceUfragAttribute,
false));
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kIceUfragAttribute,
true));
ASSERT_EQ(
"4a799b2e",
Sdp()->GetMediaSection(
1).GetAttributeList().GetIceUfrag());
}
TEST_P(NewSdpTest, CheckMediaLevelIcePwd) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kIcePwdAttribute));
ASSERT_EQ(
"0000000000000000000000000000000",
Sdp()->GetMediaSection(
0).GetAttributeList().GetIcePwd());
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kIcePwdAttribute));
ASSERT_EQ(
"e4cc12a910f106a0a744719425510e17",
Sdp()->GetMediaSection(
1).GetAttributeList().GetIcePwd());
}
TEST_P(NewSdpTest, CheckGroups) {
ParseSdp(kBasicAudioVideoOffer);
const SdpGroupAttributeList& group = Sdp()->GetAttributeList().GetGroup();
const SdpGroupAttributeList::Group& group1 = group.mGroups[
0];
ASSERT_EQ(SdpGroupAttributeList::kBundle, group1.semantics);
ASSERT_EQ(
2U, group1.tags.size());
ASSERT_EQ(
"first", group1.tags[
0]);
ASSERT_EQ(
"second", group1.tags[
1]);
const SdpGroupAttributeList::Group& group2 = group.mGroups[
1];
ASSERT_EQ(SdpGroupAttributeList::kBundle, group2.semantics);
ASSERT_EQ(
1U, group2.tags.size());
ASSERT_EQ(
"third", group2.tags[
0]);
const SdpGroupAttributeList::Group& group3 = group.mGroups[
2];
ASSERT_EQ(SdpGroupAttributeList::kLs, group3.semantics);
ASSERT_EQ(
2U, group3.tags.size());
ASSERT_EQ(
"first", group3.tags[
0]);
ASSERT_EQ(
"third", group3.tags[
1]);
}
TEST_P(NewSdpTest, CheckManyGroups) {
std::ostringstream bundle;
bundle <<
"a=group:BUNDLE";
for (size_t i =
0; i < SDP_MAX_MEDIA_STREAMS +
1; ++i) {
bundle <<
" " << i;
}
bundle << CRLF;
std::string offer =
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"t=0 0" CRLF;
offer += bundle.str();
offer +=
"m=video 56436 RTP/SAVPF 120" CRLF
"b=CT:1000" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// Rust will reserialize what Sipcc serializes to, but otherwise they will
// differ.
ParseSdp(offer,
true,
::testing::get<
0>(GetParam()) && ::testing::get<
1>(GetParam()));
const SdpGroupAttributeList& group = Sdp()->GetAttributeList().GetGroup();
const SdpGroupAttributeList::Group& group1 = group.mGroups[
0];
ASSERT_EQ(SdpGroupAttributeList::kBundle, group1.semantics);
// Only sipcc is limited by SDP_MAX_MEDIA_STREAMS, the Rust parser
// will parse all of the groups.
ASSERT_GE(group1.tags.size(),
static_cast<size_t>(SDP_MAX_MEDIA_STREAMS));
}
// SDP from a basic A/V call with data channel FFX/FFX
MOZ_RUNINIT
const std::string kBasicAudioVideoDataOffer =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 27987 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"t=0 0" CRLF
"a=ice-ufrag:8a39d2ae" CRLF
"a=ice-pwd:601d53aba51a318351b3ecf5ee00048f" CRLF
"a=fingerprint:sha-256 "
"30:FF:8E:2B:AC:9D:ED:70:18:10:67:C8:AE:9E:68:F3:86:53:51:B0:AC:31:B7:BE:"
"6D:CF:A4:2E:D3:6E:B4:28" CRLF
"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:109 opus/48000/2" CRLF
"a=ptime:20" CRLF
"a=rtpmap:9 G722/8000" CRLF
"a=rtpmap:0 PCMU/8000" CRLF
"a=rtpmap:8 PCMA/8000" CRLF
"a=rtpmap:101 telephone-event/8000" CRLF
"a=fmtp:101 0-15" CRLF
"a=sendrecv" CRLF
"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level" CRLF
"a=extmap:2/sendonly some_extension" CRLF
"a=extmap:3 some_other_extension some_params some more params" CRLF
"a=setup:actpass" CRLF
"a=rtcp-mux" CRLF
"m=video 9 RTP/SAVPF 120 126 97" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=rtpmap:126 H264/90000" CRLF
"a=fmtp:126 profile-level-id=42e01f;packetization-mode=1" CRLF
"a=rtpmap:97 H264/90000" CRLF
"a=fmtp:97 profile-level-id=42e01f" CRLF
"a=sendrecv" CRLF
// sipcc barfs on this, despite that it is valid syntax
// Do we care about fixing?
//"a=rtcp-fb:120 ack" CRLF // Should be ignored by sipcc
"a=rtcp-fb:120 ack rpsi" CRLF
"a=rtcp-fb:120 ack app foo" CRLF
"a=rtcp-fb:120 ack foo" CRLF
// Should be ignored
"a=rtcp-fb:120 nack" CRLF
"a=rtcp-fb:120 nack sli" CRLF
"a=rtcp-fb:120 nack pli" CRLF
"a=rtcp-fb:120 nack rpsi" CRLF
"a=rtcp-fb:120 nack app foo" CRLF
"a=rtcp-fb:120 nack foo" CRLF
// Should be ignored
"a=rtcp-fb:120 ccm fir" CRLF
"a=rtcp-fb:120 ccm tmmbr" CRLF
"a=rtcp-fb:120 ccm tstr" CRLF
"a=rtcp-fb:120 ccm vbcm" CRLF
"a=rtcp-fb:120 ccm foo" CRLF
// Should be ignored
"a=rtcp-fb:120 trr-int 10" CRLF
"a=rtcp-fb:120 goog-remb" CRLF
"a=rtcp-fb:120 foo" CRLF
// Should be ignored
"a=rtcp-fb:126 nack" CRLF
"a=rtcp-fb:126 nack pli" CRLF
"a=rtcp-fb:126 ccm fir" CRLF
"a=rtcp-fb:97 nack" CRLF
"a=rtcp-fb:97 nack pli" CRLF
"a=rtcp-fb:97 ccm fir" CRLF
"a=rtcp-fb:* ccm tmmbr" CRLF
"a=rtcp-fb:120 transport-cc" CRLF
"a=setup:actpass" CRLF
"a=rtcp-mux" CRLF
"m=application 9 DTLS/SCTP 5000" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=sctpmap:5000 webrtc-datachannel 16" CRLF
"a=setup:actpass" CRLF;
TEST_P(NewSdpTest, BasicAudioVideoDataSdpParse) {
ParseSdp(kBasicAudioVideoDataOffer,
true);
ASSERT_EQ(
0U, ParseErrorCount())
<<
"Got parse errors: " << SerializeParseErrors();
}
TEST_P(NewSdpTest, CheckApplicationParameters) {
ParseSdp(kBasicAudioVideoDataOffer,
true);
ASSERT_TRUE(!!Sdp());
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_EQ(SdpMediaSection::kAudio, Sdp()->GetMediaSection(
0).GetMediaType())
<<
"Wrong type for first media section";
ASSERT_EQ(SdpMediaSection::kVideo, Sdp()->GetMediaSection(
1).GetMediaType())
<<
"Wrong type for second media section";
ASSERT_EQ(SdpMediaSection::kApplication,
Sdp()->GetMediaSection(
2).GetMediaType())
<<
"Wrong type for third media section";
ASSERT_EQ(SdpMediaSection::kDtlsSctp, Sdp()->GetMediaSection(
2).GetProtocol())
<<
"Wrong protocol for application";
auto app_formats = Sdp()->GetMediaSection(
2).GetFormats();
ASSERT_EQ(
1U, app_formats.size()) <<
"Wrong number of formats for audio";
ASSERT_EQ(
"5000", app_formats[
0]);
const SdpConnection& conn3 = Sdp()->GetMediaSection(
2).GetConnection();
ASSERT_EQ(sdp::kIPv4, conn3.GetAddrType());
ASSERT_EQ(
"0.0.0.0", conn3.GetAddress());
ASSERT_EQ(
0U, conn3.GetTtl());
ASSERT_EQ(
0U, conn3.GetCount());
ASSERT_TRUE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kSetupAttribute));
ASSERT_EQ(SdpSetupAttribute::kActpass,
Sdp()->GetMediaSection(
2).GetAttributeList().GetSetup().mRole);
}
TEST_P(NewSdpTest, CheckExtmap) {
ParseSdp(kBasicAudioVideoDataOffer,
true);
ASSERT_TRUE(!!Sdp());
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kExtmapAttribute));
auto extmaps =
Sdp()->GetMediaSection(
0).GetAttributeList().GetExtmap().mExtmaps;
ASSERT_EQ(
3U, extmaps.size());
ASSERT_EQ(
1U, extmaps[
0].entry);
ASSERT_FALSE(extmaps[
0].direction_specified);
ASSERT_EQ(
"urn:ietf:params:rtp-hdrext:ssrc-audio-level",
extmaps[
0].extensionname);
ASSERT_EQ(
"", extmaps[
0].extensionattributes);
ASSERT_EQ(
2U, extmaps[
1].entry);
ASSERT_TRUE(extmaps[
1].direction_specified);
ASSERT_EQ(SdpDirectionAttribute::kSendonly, extmaps[
1].direction);
ASSERT_EQ(
"some_extension", extmaps[
1].extensionname);
ASSERT_EQ(
"", extmaps[
1].extensionattributes);
ASSERT_EQ(
3U, extmaps[
2].entry);
ASSERT_FALSE(extmaps[
2].direction_specified);
ASSERT_EQ(
"some_other_extension", extmaps[
2].extensionname);
ASSERT_EQ(
"some_params some more params", extmaps[
2].extensionattributes);
}
TEST_P(NewSdpTest, CheckRtcpFb) {
ParseSdp(kBasicAudioVideoDataOffer,
true);
ASSERT_TRUE(!!Sdp());
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
auto& video_attrs = Sdp()->GetMediaSection(
1).GetAttributeList();
ASSERT_TRUE(video_attrs.HasAttribute(SdpAttribute::kRtcpFbAttribute));
auto& rtcpfbs = video_attrs.GetRtcpFb().mFeedbacks;
if (ResultsAreFromSipcc()) {
ASSERT_EQ(
21U, rtcpfbs.size());
}
else {
ASSERT_EQ(
"WEBRTCSDP", mResults->ParserName());
std::stringstream os;
Sdp()->Serialize(os);
// Reserialized results should be the same
if (::testing::get<
1>(GetParam())) {
ASSERT_EQ(
21U, rtcpfbs.size());
}
else {
ASSERT_EQ(
21U, rtcpfbs.size());
}
}
CheckRtcpFb(rtcpfbs[
0],
"120", SdpRtcpFbAttributeList::kAck,
"rpsi");
CheckRtcpFb(rtcpfbs[
1],
"120", SdpRtcpFbAttributeList::kAck,
"app",
"foo");
CheckRtcpFb(rtcpfbs[
2],
"120", SdpRtcpFbAttributeList::kNack,
"");
CheckRtcpFb(rtcpfbs[
3],
"120", SdpRtcpFbAttributeList::kNack,
"sli");
CheckRtcpFb(rtcpfbs[
4],
"120", SdpRtcpFbAttributeList::kNack,
"pli");
CheckRtcpFb(rtcpfbs[
5],
"120", SdpRtcpFbAttributeList::kNack,
"rpsi");
CheckRtcpFb(rtcpfbs[
6],
"120", SdpRtcpFbAttributeList::kNack,
"app",
"foo");
CheckRtcpFb(rtcpfbs[
7],
"120", SdpRtcpFbAttributeList::kCcm,
"fir");
CheckRtcpFb(rtcpfbs[
8],
"120", SdpRtcpFbAttributeList::kCcm,
"tmmbr");
CheckRtcpFb(rtcpfbs[
9],
"120", SdpRtcpFbAttributeList::kCcm,
"tstr");
CheckRtcpFb(rtcpfbs[
10],
"120", SdpRtcpFbAttributeList::kCcm,
"vbcm");
CheckRtcpFb(rtcpfbs[
11],
"120", SdpRtcpFbAttributeList::kTrrInt,
"10");
CheckRtcpFb(rtcpfbs[
12],
"120", SdpRtcpFbAttributeList::kRemb,
"");
CheckRtcpFb(rtcpfbs[
13],
"126", SdpRtcpFbAttributeList::kNack,
"");
CheckRtcpFb(rtcpfbs[
14],
"126", SdpRtcpFbAttributeList::kNack,
"pli");
CheckRtcpFb(rtcpfbs[
15],
"126", SdpRtcpFbAttributeList::kCcm,
"fir");
CheckRtcpFb(rtcpfbs[
16],
"97", SdpRtcpFbAttributeList::kNack,
"");
CheckRtcpFb(rtcpfbs[
17],
"97", SdpRtcpFbAttributeList::kNack,
"pli");
CheckRtcpFb(rtcpfbs[
18],
"97", SdpRtcpFbAttributeList::kCcm,
"fir");
CheckRtcpFb(rtcpfbs[
19],
"*", SdpRtcpFbAttributeList::kCcm,
"tmmbr");
CheckRtcpFb(rtcpfbs[
20],
"120", SdpRtcpFbAttributeList::kTransportCC,
"");
}
TEST_P(NewSdpTest, CheckRtcp) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp());
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kRtcpAttribute));
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kRtcpAttribute));
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kRtcpAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kRtcpAttribute));
auto& rtcpAttr_0 = Sdp()->GetMediaSection(
0).GetAttributeList().GetRtcp();
ASSERT_EQ(
62454U, rtcpAttr_0.mPort);
ASSERT_EQ(sdp::kInternet, rtcpAttr_0.mNetType);
ASSERT_EQ(sdp::kIPv4, rtcpAttr_0.mAddrType);
ASSERT_EQ(
"162.222.183.171", rtcpAttr_0.mAddress);
auto& rtcpAttr_1 = Sdp()->GetMediaSection(
1).GetAttributeList().GetRtcp();
ASSERT_EQ(
61026U, rtcpAttr_1.mPort);
ASSERT_EQ(
"", rtcpAttr_1.mAddress);
}
TEST_P(NewSdpTest, CheckImageattr) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp());
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kImageattrAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kImageattrAttribute));
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kImageattrAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kImageattrAttribute));
const SdpImageattrAttributeList& imageattrs =
Sdp()->GetMediaSection(
1).GetAttributeList().GetImageattr();
ASSERT_EQ(
2U, imageattrs.mImageattrs.size());
const SdpImageattrAttributeList::Imageattr& imageattr_0(
imageattrs.mImageattrs[
0]);
ASSERT_TRUE(imageattr_0.pt.isSome());
ASSERT_EQ(
120U, *imageattr_0.pt);
ASSERT_TRUE(imageattr_0.sendAll);
ASSERT_TRUE(imageattr_0.recvAll);
const SdpImageattrAttributeList::Imageattr& imageattr_1(
imageattrs.mImageattrs[
1]);
ASSERT_TRUE(imageattr_1.pt.isSome());
ASSERT_EQ(
121U, *imageattr_1.pt);
ASSERT_FALSE(imageattr_1.sendAll);
ASSERT_FALSE(imageattr_1.recvAll);
ASSERT_EQ(
1U, imageattr_1.sendSets.size());
ASSERT_EQ(
1U, imageattr_1.sendSets[
0].xRange.discreteValues.size());
ASSERT_EQ(
640U, imageattr_1.sendSets[
0].xRange.discreteValues.front());
ASSERT_EQ(
1U, imageattr_1.sendSets[
0].yRange.discreteValues.size());
ASSERT_EQ(
480U, imageattr_1.sendSets[
0].yRange.discreteValues.front());
ASSERT_EQ(
1U, imageattr_1.recvSets.size());
ASSERT_EQ(
1U, imageattr_1.recvSets[
0].xRange.discreteValues.size());
ASSERT_EQ(
640U, imageattr_1.recvSets[
0].xRange.discreteValues.front());
ASSERT_EQ(
1U, imageattr_1.recvSets[
0].yRange.discreteValues.size());
ASSERT_EQ(
480U, imageattr_1.recvSets[
0].yRange.discreteValues.front());
}
TEST_P(NewSdpTest, CheckSimulcast) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp());
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kSimulcastAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kSimulcastAttribute));
ASSERT_TRUE(Sdp()->GetMediaSection(
1).GetAttributeList().HasAttribute(
SdpAttribute::kSimulcastAttribute));
ASSERT_FALSE(Sdp()->GetMediaSection(
2).GetAttributeList().HasAttribute(
SdpAttribute::kSimulcastAttribute));
const SdpSimulcastAttribute& simulcast =
Sdp()->GetMediaSection(
1).GetAttributeList().GetSimulcast();
ASSERT_EQ(
2U, simulcast.recvVersions.size());
ASSERT_EQ(
0U, simulcast.sendVersions.size());
ASSERT_EQ(
1U, simulcast.recvVersions[
0].choices.size());
ASSERT_EQ(
"bar", simulcast.recvVersions[
0].choices[
0].rid);
ASSERT_EQ(
1U, simulcast.recvVersions[
1].choices.size());
ASSERT_EQ(
"bar123", simulcast.recvVersions[
1].choices[
0].rid);
}
TEST_P(NewSdpTest, CheckSctpmap) {
ParseSdp(kBasicAudioVideoDataOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
const SdpMediaSection& appsec = Sdp()->GetMediaSection(
2);
ASSERT_TRUE(
appsec.GetAttributeList().HasAttribute(SdpAttribute::kSctpmapAttribute));
const SdpSctpmapAttributeList& sctpmap =
appsec.GetAttributeList().GetSctpmap();
ASSERT_EQ(
1U, sctpmap.mSctpmaps.size())
<<
"Wrong number of sctpmap attributes";
ASSERT_EQ(
1U, appsec.GetFormats().size());
// Need to know name of type
CheckSctpmap(
"5000",
"webrtc-datachannel",
16, appsec.GetFormats()[
0],
sctpmap);
}
TEST_P(NewSdpTest, CheckMaxPtime) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kMaxptimeAttribute));
ASSERT_EQ(Sdp()->GetMediaSection(
0).GetAttributeList().GetMaxptime(),
20U);
}
MOZ_RUNINIT
const std::string kNewSctpportOfferDraft21 =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 27987 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"t=0 0" CRLF
"a=ice-ufrag:8a39d2ae" CRLF
"a=ice-pwd:601d53aba51a318351b3ecf5ee00048f" CRLF
"a=fingerprint:sha-256 "
"30:FF:8E:2B:AC:9D:ED:70:18:10:67:C8:AE:9E:68:F3:86:53:51:B0:AC:31:B7:BE:"
"6D:CF:A4:2E:D3:6E:B4:28" CRLF
"m=application 9 UDP/DTLS/SCTP webrtc-datachannel" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=sctp-port:5000" CRLF
"a=max-message-size:10000" CRLF
"a=setup:actpass" CRLF;
TEST_P(NewSdpTest, NewSctpportSdpParse) {
ParseSdp(kNewSctpportOfferDraft21,
false);
}
INSTANTIATE_TEST_SUITE_P(RoundTripSerialize, NewSdpTest,
::testing::Combine(::testing::
Bool(),
::testing::
Bool()));
MOZ_RUNINIT
const std::string kCandidateInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=candidate:0 1 UDP 2130379007 10.0.0.36 62453 typ host" CRLF
"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:109 opus/48000/2" CRLF;
// This may or may not parse, but if it does, the errant candidate attribute
// should be ignored.
TEST_P(NewSdpTest, CheckCandidateInSessionLevel) {
ParseSdp(kCandidateInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kCandidateAttribute));
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kCandidateAttribute));
}
}
MOZ_RUNINIT
const std::string kBundleOnlyInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=bundle-only" CRLF
"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:109 opus/48000/2" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckBundleOnlyInSessionLevel) {
ParseSdp(kBundleOnlyInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kBundleOnlyAttribute));
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kBundleOnlyAttribute));
}
}
MOZ_RUNINIT
const std::string kFmtpInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=fmtp:109 0-15" CRLF
"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:109 opus/48000/2" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckFmtpInSessionLevel) {
ParseSdp(kFmtpInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kFmtpAttribute));
}
}
MOZ_RUNINIT
const std::string kIceMismatchInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=ice-mismatch" CRLF
"m=audio 9 RTP/SAVPF 109 9 0 8 101" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:109 opus/48000/2" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckIceMismatchInSessionLevel) {
ParseSdp(kIceMismatchInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kIceMismatchAttribute));
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kIceMismatchAttribute));
}
}
MOZ_RUNINIT
const std::string kImageattrInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=imageattr:120 send * recv *" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckImageattrInSessionLevel) {
ParseSdp(kImageattrInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kImageattrAttribute));
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kImageattrAttribute));
}
}
MOZ_RUNINIT
const std::string kLabelInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=label:foobar" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckLabelInSessionLevel) {
ParseSdp(kLabelInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kLabelAttribute));
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kLabelAttribute));
}
}
MOZ_RUNINIT
const std::string kMaxptimeInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=maxptime:100" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckMaxptimeInSessionLevel) {
ParseSdp(kMaxptimeInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kMaxptimeAttribute));
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kMaxptimeAttribute));
}
}
MOZ_RUNINIT
const std::string kMidInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=mid:foobar" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckMidInSessionLevel) {
ParseSdp(kMidInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kMidAttribute));
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kMidAttribute));
}
}
MOZ_RUNINIT
const std::string kMsidInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=msid:foobar" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckMsidInSessionLevel) {
ParseSdp(kMsidInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kMsidAttribute));
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kMsidAttribute));
}
}
MOZ_RUNINIT
const std::string kPtimeInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=ptime:50" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckPtimeInSessionLevel) {
ParseSdp(kPtimeInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kPtimeAttribute));
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kPtimeAttribute));
}
}
MOZ_RUNINIT
const std::string kRemoteCandidatesInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=remote-candidates:0 10.0.0.1 5555" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckRemoteCandidatesInSessionLevel) {
ParseSdp(kRemoteCandidatesInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kRemoteCandidatesAttribute));
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kRemoteCandidatesAttribute));
}
}
MOZ_RUNINIT
const std::string kRtcpInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=rtcp:5555" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckRtcpInSessionLevel) {
ParseSdp(kRtcpInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kRtcpAttribute));
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kRtcpAttribute));
}
}
MOZ_RUNINIT
const std::string kRtcpFbInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=rtcp-fb:120 nack" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckRtcpFbInSessionLevel) {
ParseSdp(kRtcpFbInSessionSDP,
false,
true);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kRtcpFbAttribute));
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kRtcpFbAttribute));
}
}
MOZ_RUNINIT
const std::string kRtcpMuxInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=rtcp-mux" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckRtcpMuxInSessionLevel) {
ParseSdp(kRtcpMuxInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kRtcpMuxAttribute));
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kRtcpMuxAttribute));
}
}
MOZ_RUNINIT
const std::string kRtcpRsizeInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=rtcp-rsize" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckRtcpRsizeInSessionLevel) {
ParseSdp(kRtcpRsizeInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kRtcpRsizeAttribute));
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kRtcpRsizeAttribute));
}
}
MOZ_RUNINIT
const std::string kRtpmapInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckRtpmapInSessionLevel) {
ParseSdp(kRtpmapInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kRtpmapAttribute));
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kRtpmapAttribute));
}
}
MOZ_RUNINIT
const std::string kSctpmapInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=sctpmap:5000" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckSctpmapInSessionLevel) {
ParseSdp(kSctpmapInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kSctpmapAttribute));
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kSctpmapAttribute));
}
}
MOZ_RUNINIT
const std::string kSsrcInSessionSDP =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"a=ssrc:5000" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
// This may or may not parse, but if it does, the errant attribute
// should be ignored.
TEST_P(NewSdpTest, CheckSsrcInSessionLevel) {
ParseSdp(kSsrcInSessionSDP,
false);
if (Sdp()) {
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kSsrcAttribute));
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kSsrcAttribute));
}
}
MOZ_RUNINIT
const std::string kMalformedImageattr =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=imageattr:flob" CRLF;
TEST_P(NewSdpTest, CheckMalformedImageattr) {
if (::testing::get<
0>(GetParam())) {
// Don't do a parse/serialize before running this test
return;
}
ParseSdp(kMalformedImageattr,
false);
ASSERT_NE(
0U, ParseErrorCount());
}
TEST_P(NewSdpTest, ParseInvalidSimulcastNoSuchSendRid) {
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"t=0 0" CRLF
"m=video 56436 RTP/SAVPF 120" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=sendrecv" CRLF
"a=simulcast:send 9" CRLF
"a=rid:9 recv max-width=800;max-height=600" CRLF,
false);
ASSERT_NE(
0U, ParseErrorCount());
}
TEST_P(NewSdpTest, ParseInvalidSimulcastNoSuchRecvRid) {
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"t=0 0" CRLF
"m=video 56436 RTP/SAVPF 120" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=sendrecv" CRLF
"a=simulcast:recv 9" CRLF
"a=rid:9 send max-width=800;max-height=600" CRLF,
false);
ASSERT_NE(
0U, ParseErrorCount());
}
TEST_P(NewSdpTest, ParseSimulcastNotSending) {
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"t=0 0" CRLF
"m=video 56436 RTP/SAVPF 120" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=recvonly" CRLF
"a=simulcast:send 120" CRLF
"a=rid:120 send" CRLF,
false);
ASSERT_EQ(
0U, ParseErrorCount());
}
TEST_P(NewSdpTest, ParseSimulcastNotReceiving) {
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"t=0 0" CRLF
"m=video 56436 RTP/SAVPF 120" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=sendonly" CRLF
"a=simulcast:recv 120" CRLF
"a=rid:120 recv" CRLF,
false);
ASSERT_EQ(
0U, ParseErrorCount());
}
TEST_P(NewSdpTest, ParseInvalidRidNoSuchPt) {
SKIP_TEST_WITH_SIPCC_PARSER
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"t=0 0" CRLF
"m=video 56436 RTP/SAVPF 120" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=sendrecv" CRLF
"a=simulcast:recv rid=9" CRLF
"a=rid:9 recv pt=101;max-width=800;max-height=600" CRLF,
false);
ASSERT_NE(
0U, ParseErrorCount());
}
MOZ_RUNINIT
const std::string kNoAttributes =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=rtpmap:120 VP8/90000" CRLF;
TEST_P(NewSdpTest, CheckNoAttributes) {
ParseSdp(kNoAttributes);
for (
auto a =
static_cast<size_t>(SdpAttribute::kFirstAttribute);
a <=
static_cast<size_t>(SdpAttribute::kLastAttribute); ++a) {
SdpAttribute::AttributeType type =
static_cast<SdpAttribute::AttributeType>(a);
// rtpmap is a special case right now, we throw parse errors if it is
// missing, and then insert one.
// direction is another special case that gets a default if not present
if (type != SdpAttribute::kRtpmapAttribute &&
type != SdpAttribute::kDirectionAttribute) {
ASSERT_FALSE(
Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(type))
<<
"Attribute " << a <<
" should not have been present at media level";
ASSERT_FALSE(Sdp()->GetAttributeList().HasAttribute(type))
<<
"Attribute " << a <<
" should not have been present at session level";
}
}
ASSERT_FALSE(
Sdp()->GetAttributeList().HasAttribute(SdpAttribute::kRtpmapAttribute));
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kDirectionAttribute));
ASSERT_EQ(SdpDirectionAttribute::kSendrecv,
Sdp()->GetMediaSection(
0).GetAttributeList().GetDirection());
ASSERT_TRUE(Sdp()->GetAttributeList().HasAttribute(
SdpAttribute::kDirectionAttribute));
ASSERT_EQ(SdpDirectionAttribute::kSendrecv,
Sdp()->GetAttributeList().GetDirection());
}
MOZ_RUNINIT
const std::string kMediaLevelDtlsMessage =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"c=IN IP4 0.0.0.0" CRLF
"a=dtls-message:client " BASE64_DTLS_HELLO CRLF
"a=rtpmap:120 VP8/90000" CRLF;
TEST_P(NewSdpTest, CheckMediaLevelDtlsMessage) {
ParseSdp(kMediaLevelDtlsMessage);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
// dtls-message is not defined for use at the media level; we don't
// parse it
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kDtlsMessageAttribute));
}
TEST_P(NewSdpTest, CheckSetPort) {
// Parse any valid sdp with a media section
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"t=0 0" CRLF
"m=video 56436 RTP/SAVPF 120" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=sendonly" CRLF,
false);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
constexpr
unsigned int expectedParesPort =
56436;
unsigned int currentPort = Sdp()->GetMediaSection(
0).GetPort();
ASSERT_EQ(expectedParesPort, currentPort);
Sdp()->GetMediaSection(
0).SetPort(currentPort +
1);
ASSERT_EQ(currentPort +
1, Sdp()->GetMediaSection(
0).GetPort());
}
TEST_P(NewSdpTest, CheckAddCodec) {
// Parse any valid sdp with a media section
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"t=0 0" CRLF
"m=video 56436 RTP/SAVPF 120" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=sendonly" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount());
ASSERT_EQ(
1U, Sdp()->GetMediaSection(
0).GetFormats().size());
ASSERT_EQ(
1U,
Sdp()->GetMediaSection(
0).GetAttributeList().GetRtpmap().mRtpmaps.size());
Sdp()->GetMediaSection(
0).AddCodec(
"110",
"opus",
48000,
2);
ASSERT_EQ(
2U, Sdp()->GetMediaSection(
0).GetFormats().size());
const auto& rtpmaps =
Sdp()->GetMediaSection(
0).GetAttributeList().GetRtpmap();
ASSERT_EQ(
2U, rtpmaps.mRtpmaps.size());
ASSERT_TRUE(rtpmaps.HasEntry(
"120"));
ASSERT_TRUE(rtpmaps.HasEntry(
"110"));
const auto aRtpmap = rtpmaps.GetEntry(
"110");
ASSERT_EQ(aRtpmap.pt,
"110");
ASSERT_EQ(aRtpmap.codec, SdpRtpmapAttributeList::kOpus);
ASSERT_EQ(aRtpmap.name,
"opus");
ASSERT_EQ(aRtpmap.clock,
48000U);
ASSERT_EQ(aRtpmap.channels,
2U);
}
TEST_P(NewSdpTest, CheckClearCodecs) {
// Parse any valid sdp with a media section
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"t=0 0" CRLF
"m=video 56436 RTP/SAVPF 120 110" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=sendonly" CRLF
"a=rtpmap:110 opus/48000" CRLF);
// SIPCC strips the channels on opus so the /2 was omitted
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount());
ASSERT_EQ(
2U, Sdp()->GetMediaSection(
0).GetFormats().size());
ASSERT_EQ(
2U,
Sdp()->GetMediaSection(
0).GetAttributeList().GetRtpmap().mRtpmaps.size());
Sdp()->GetMediaSection(
0).ClearCodecs();
ASSERT_EQ(
0U, Sdp()->GetMediaSection(
0).GetFormats().size());
ASSERT_FALSE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kRtpmapAttribute));
}
TEST_P(NewSdpTest, CheckAddMediaSection) {
ParseSdp(kBasicAudioVideoOffer);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
3U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections";
Sdp()->AddMediaSection(
SdpMediaSection::kVideo, SdpDirectionAttribute::Direction::kSendrecv,
58000, SdpMediaSection::kUdpDtlsSctp, sdp::kIPv4,
"127.0.0.1");
ASSERT_EQ(
4U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections after adding media section";
const SdpMediaSection& newMediaSection = Sdp()->GetMediaSection(
3);
ASSERT_EQ(SdpMediaSection::kVideo, newMediaSection.GetMediaType());
ASSERT_EQ(SdpDirectionAttribute::Direction::kSendrecv,
newMediaSection.GetDirectionAttribute().mValue);
ASSERT_EQ(
58000U, newMediaSection.GetPort());
ASSERT_EQ(SdpMediaSection::kUdpDtlsSctp, newMediaSection.GetProtocol());
ASSERT_EQ(sdp::kIPv4, newMediaSection.GetConnection().GetAddrType());
ASSERT_EQ(
"127.0.0.1", newMediaSection.GetConnection().GetAddress());
Sdp()->AddMediaSection(SdpMediaSection::kAudio,
SdpDirectionAttribute::Direction::kSendonly,
14006,
SdpMediaSection::kTcpDtlsRtpSavpf, sdp::kIPv6,
"2607:f8b0:4004:801::2013");
ASSERT_EQ(
5U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections after adding media section";
const SdpMediaSection& nextNewMediaSection = Sdp()->GetMediaSection(
4);
ASSERT_EQ(SdpMediaSection::kAudio, nextNewMediaSection.GetMediaType());
ASSERT_EQ(SdpDirectionAttribute::Direction::kSendonly,
nextNewMediaSection.GetDirectionAttribute().mValue);
ASSERT_EQ(
14006U, nextNewMediaSection.GetPort());
ASSERT_EQ(SdpMediaSection::kTcpDtlsRtpSavpf,
nextNewMediaSection.GetProtocol());
ASSERT_EQ(sdp::kIPv6, nextNewMediaSection.GetConnection().GetAddrType());
ASSERT_EQ(
"2607:f8b0:4004:801::2013",
nextNewMediaSection.GetConnection().GetAddress());
if (!ResultsAreFromSipcc()) {
// All following AddMediaSection calls are expected to fail
// SdpMediaSection::kDccpRtpAvp is expected to cause a failure
Sdp()->AddMediaSection(SdpMediaSection::kAudio,
SdpDirectionAttribute::Direction::kSendonly,
14006,
SdpMediaSection::kDccpRtpAvp, sdp::kIPv6,
"2607:f8b0:4004:801::2013");
ASSERT_EQ(
5U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections after adding media section";
// sdp::kAddrTypeNone is expected to cause a failure
Sdp()->AddMediaSection(SdpMediaSection::kAudio,
SdpDirectionAttribute::Direction::kSendonly,
14006,
SdpMediaSection::kDtlsSctp, sdp::kAddrTypeNone,
"2607:f8b0:4004:801::2013");
ASSERT_EQ(
5U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections after adding media section";
// "NOT:AN.IP.ADDRESS" is expected to cause a failure
Sdp()->AddMediaSection(SdpMediaSection::kAudio,
SdpDirectionAttribute::Direction::kSendonly,
14006,
SdpMediaSection::kTcpDtlsRtpSavpf, sdp::kIPv6,
"NOT:AN.IP.ADDRESS");
ASSERT_EQ(
5U, Sdp()->GetMediaSectionCount())
<<
"Wrong number of media sections after adding media section";
}
}
TEST_P(NewSdpTest, CheckAddDataChannel_Draft05) {
// Parse any valid sdp with a media section
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"t=0 0" CRLF
"m=application 56436 DTLS/SCTP 5000" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount());
auto& mediaSection = Sdp()->GetMediaSection(
0);
mediaSection.AddDataChannel(
"webrtc-datachannel",
6000,
16,
0);
ASSERT_FALSE(mediaSection.GetAttributeList().HasAttribute(
SdpAttribute::kMaxMessageSizeAttribute));
ASSERT_TRUE(mediaSection.GetAttributeList().HasAttribute(
SdpAttribute::kSctpmapAttribute));
ASSERT_TRUE(mediaSection.GetAttributeList().GetSctpmap().HasEntry(
"6000"));
ASSERT_EQ(
16U,
mediaSection.GetAttributeList().GetSctpmap().GetFirstEntry().streams);
ASSERT_EQ(
"webrtc-datachannel",
mediaSection.GetAttributeList().GetSctpmap().GetFirstEntry().name);
mediaSection.AddDataChannel(
"webrtc-datachannel",
15000,
8,
1800);
ASSERT_TRUE(mediaSection.GetAttributeList().HasAttribute(
SdpAttribute::kMaxMessageSizeAttribute));
ASSERT_EQ(
1800U, mediaSection.GetAttributeList().GetMaxMessageSize());
ASSERT_TRUE(mediaSection.GetAttributeList().HasAttribute(
SdpAttribute::kSctpmapAttribute));
ASSERT_TRUE(mediaSection.GetAttributeList().GetSctpmap().HasEntry(
"15000"));
ASSERT_EQ(
8U, mediaSection.GetAttributeList().GetSctpmap().GetFirstEntry().streams);
}
TEST_P(NewSdpTest, CheckAddDataChannel) {
ParseSdp(
"v=0" CRLF
"o=- 4294967296 2 IN IP4 127.0.0.1" CRLF
"s=SIP Call" CRLF
"c=IN IP4 198.51.100.7" CRLF
"b=CT:5000" CRLF
"t=0 0" CRLF
"m=application 56436 UDP/DTLS/SCTP webrtc-datachannel" CRLF);
ASSERT_TRUE(!!Sdp())
<<
"Parse failed: " << SerializeParseErrors();
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount());
auto& mediaSection = Sdp()->GetMediaSection(
0);
mediaSection.AddDataChannel(
"webrtc-datachannel",
6000,
16,
0);
ASSERT_FALSE(mediaSection.GetAttributeList().HasAttribute(
SdpAttribute::kMaxMessageSizeAttribute));
ASSERT_TRUE(mediaSection.GetAttributeList().HasAttribute(
SdpAttribute::kSctpPortAttribute));
ASSERT_EQ(
6000U, mediaSection.GetAttributeList().GetSctpPort());
mediaSection.AddDataChannel(
"webrtc-datachannel",
15000,
8,
1800);
ASSERT_TRUE(mediaSection.GetAttributeList().HasAttribute(
SdpAttribute::kMaxMessageSizeAttribute));
ASSERT_EQ(
1800U, mediaSection.GetAttributeList().GetMaxMessageSize());
ASSERT_TRUE(mediaSection.GetAttributeList().HasAttribute(
SdpAttribute::kSctpPortAttribute));
ASSERT_EQ(
15000U, mediaSection.GetAttributeList().GetSctpPort());
}
TEST(NewSdpTestNoFixture, CheckParsingResultComparer)
{
auto check_comparison = [](
const std::string sdp_string) {
SipccSdpParser sipccParser;
RsdparsaSdpParser rustParser;
auto print_errors =
[](
const mozilla::UniquePtr<SdpParser::Results>& results,
const char* name) {
for (
const auto& e : results->Errors()) {
std::cerr << name <<
" Line " << e.first <<
": " << e.second;
}
};
auto sipccResults = sipccParser.Parse(sdp_string);
auto sipccSdp = std::move(sipccResults->Sdp());
print_errors(sipccResults,
"sipcc");
auto rustResults = rustParser.Parse(sdp_string);
auto rustSdp = std::move(rustResults->Sdp());
print_errors(rustResults,
"webrtc-sdp");
ParsingResultComparer comparer;
return sipccSdp && rustSdp
? comparer.Compare(*rustSdp, *sipccSdp, sdp_string)
:
false;
};
ASSERT_TRUE(check_comparison(kBasicAudioVideoOffer));
ASSERT_TRUE(check_comparison(kBasicAudioVideoOfferLinefeedOnly));
ASSERT_TRUE(check_comparison(kH264AudioVideoOffer));
// Check the Fmtp comprison
const std::string kBasicOpusFmtp1 =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"a=rtpmap:120 opus/48000/1" CRLF
"a=fmtp:120 stereo=1;useinbandfec=1" CRLF;
ASSERT_TRUE(check_comparison(kBasicOpusFmtp1));
const std::string kBasicOpusFmtp2 =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"a=rtpmap:120 opus/48000" CRLF
"a=fmtp:120 useinbandfec=1;stereo=1;maxplaybackrate=32000" CRLF;
ASSERT_TRUE(check_comparison(kBasicOpusFmtp2));
const std::string kBasicVP8Fmtp1 =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=fmtp:120 max-fs=3600;max-fr=60" CRLF;
ASSERT_TRUE(check_comparison(kBasicVP8Fmtp1));
//
const std::string kBasicVP8Fmtp2 =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"a=rtpmap:120 VP8/90000" CRLF
"a=fmtp:120 max-fr=60;max-fs=3600" CRLF;
ASSERT_TRUE(check_comparison(kBasicVP8Fmtp2));
const std::string kBasicH264Fmtp1 =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"a=rtpmap:120 H264/90000" CRLF
"a=fmtp:120 profile-level-id=42a01e;level_asymmetry_allowed=1" CRLF;
ASSERT_TRUE(check_comparison(kBasicH264Fmtp1));
const std::string kBasicH264Fmtp2 =
"v=0" CRLF
"o=Mozilla-SIPUA-35.0a1 5184 0 IN IP4 0.0.0.0" CRLF
"s=SIP Call" CRLF
"c=IN IP4 224.0.0.1/100/12" CRLF
"t=0 0" CRLF
"m=video 9 RTP/SAVPF 120" CRLF
"a=rtpmap:120 H264/90000" CRLF
"a=fmtp:120 "
"level_asymmetry_allowed=1;profile-level-id=42a01e;max_fs=3600" CRLF;
ASSERT_TRUE(check_comparison(kBasicH264Fmtp2));
}
TEST(NewSdpTestNoFixture, CheckAttributeTypeSerialize)
{
for (
auto a =
static_cast<size_t>(SdpAttribute::kFirstAttribute);
a <=
static_cast<size_t>(SdpAttribute::kLastAttribute); ++a) {
SdpAttribute::AttributeType type =
static_cast<SdpAttribute::AttributeType>(a);
// Direction attributes are handled a little differently
if (type != SdpAttribute::kDirectionAttribute) {
std::ostringstream os;
os << type;
ASSERT_NE(
"", os.str());
}
}
}
static SdpImageattrAttributeList::XYRange ParseXYRange(
const std::string& input) {
std::istringstream is(input +
",");
std::string error;
SdpImageattrAttributeList::XYRange range;
EXPECT_TRUE(range.Parse(is, &error)) << error;
EXPECT_EQ(
',', is.get());
EXPECT_EQ(EOF, is.get());
return range;
}
TEST(NewSdpTestNoFixture, CheckImageattrXYRangeParseValid)
{
{
SdpImageattrAttributeList::XYRange range(ParseXYRange(
"640"));
ASSERT_EQ(
1U, range.discreteValues.size());
ASSERT_EQ(
640U, range.discreteValues[
0]);
}
{
SdpImageattrAttributeList::XYRange range(ParseXYRange(
"[320,640]"));
ASSERT_EQ(
2U, range.discreteValues.size());
ASSERT_EQ(
320U, range.discreteValues[
0]);
ASSERT_EQ(
640U, range.discreteValues[
1]);
}
{
SdpImageattrAttributeList::XYRange range(ParseXYRange(
"[320,640,1024]"));
ASSERT_EQ(
3U, range.discreteValues.size());
ASSERT_EQ(
320U, range.discreteValues[
0]);
ASSERT_EQ(
640U, range.discreteValues[
1]);
ASSERT_EQ(
1024U, range.discreteValues[
2]);
}
{
SdpImageattrAttributeList::XYRange range(ParseXYRange(
"[320:640]"));
ASSERT_EQ(
0U, range.discreteValues.size());
ASSERT_EQ(
320U, range.min);
ASSERT_EQ(
1U, range.step);
ASSERT_EQ(
640U, range.max);
}
{
SdpImageattrAttributeList::XYRange range(ParseXYRange(
"[320:16:640]"));
ASSERT_EQ(
0U, range.discreteValues.size());
ASSERT_EQ(
320U, range.min);
ASSERT_EQ(
16U, range.step);
ASSERT_EQ(
640U, range.max);
}
}
template <
typename T>
void ParseInvalid(
const std::string& input, size_t last) {
std::istringstream is(input);
T parsed;
std::string error;
ASSERT_FALSE(parsed.Parse(is, &error))
<<
"\'" << input <<
"\' should not have parsed successfully";
is.clear();
ASSERT_EQ(last,
static_cast<size_t>(is.tellg()))
<<
"Parse failed at unexpected location:" << std::endl
<< input << std::endl
<< std::string(is.tellg(),
' ') <<
"^" << std::endl;
// For a human to eyeball to make sure the error strings look sane
std::cout <<
"\"" << input << "\
" - " << error << std::endl;
}
TEST(NewSdpTestNoFixture, CheckImageattrXYRangeParseInvalid)
{
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[-1",
1);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[-",
1);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[-v",
1);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:-1",
5);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:16:-1",
8);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640,-1",
5);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640,-]",
5);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"-v",
0);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"-1",
0);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"",
0);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[",
1);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[v",
1);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[",
1);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[ 640",
1);
// It looks like the overflow detection only happens once the whole number
// is scanned...
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[99999999999999999:",
18);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640",
4);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:",
5);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:v",
5);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:16",
7);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:16:",
8);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:16:v",
8);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:16:320]",
11);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:16:320",
11);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:16:320v",
11);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:1024",
9);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:320]",
8);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640:1024v",
9);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640,",
5);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640,v",
5);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640]",
4);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640x",
4);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"[640,]",
5);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
" ",
0);
ParseInvalid<SdpImageattrAttributeList::XYRange>(
"v",
0);
}
static SdpImageattrAttributeList::SRange ParseSRange(
const std::string& input) {
std::istringstream is(input +
",");
std::string error;
SdpImageattrAttributeList::SRange range;
EXPECT_TRUE(range.Parse(is, &error)) << error;
EXPECT_EQ(
',', is.get());
EXPECT_EQ(EOF, is.get());
return range;
}
TEST(NewSdpTestNoFixture, CheckImageattrSRangeParseValid)
{
{
SdpImageattrAttributeList::SRange range(ParseSRange(
"0.1"));
ASSERT_EQ(
1U, range.discreteValues.size());
ASSERT_FLOAT_EQ(
0.
1f, range.discreteValues[
0]);
}
{
SdpImageattrAttributeList::SRange range(ParseSRange(
"[0.1,0.2]"));
ASSERT_EQ(
2U, range.discreteValues.size());
ASSERT_FLOAT_EQ(
0.
1f, range.discreteValues[
0]);
ASSERT_FLOAT_EQ(
0.
2f, range.discreteValues[
1]);
}
{
SdpImageattrAttributeList::SRange range(ParseSRange(
"[0.1,0.2,0.3]"));
ASSERT_EQ(
3U, range.discreteValues.size());
ASSERT_FLOAT_EQ(
0.
1f, range.discreteValues[
0]);
ASSERT_FLOAT_EQ(
0.
2f, range.discreteValues[
1]);
ASSERT_FLOAT_EQ(
0.
3f, range.discreteValues[
2]);
}
{
SdpImageattrAttributeList::SRange range(ParseSRange(
"[0.1-0.2]"));
ASSERT_EQ(
0U, range.discreteValues.size());
ASSERT_FLOAT_EQ(
0.
1f, range.min);
ASSERT_FLOAT_EQ(
0.
2f, range.max);
}
}
TEST(NewSdpTestNoFixture, CheckImageattrSRangeParseInvalid)
{
ParseInvalid<SdpImageattrAttributeList::SRange>(
"",
0);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[",
1);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[v",
1);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[-1",
1);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[",
1);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[-",
1);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[v",
1);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[ 0.2",
1);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[10.1-",
5);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.08-",
5);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2",
4);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2-",
5);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2-v",
5);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2--1",
5);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2-0.3",
8);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2-0.1]",
8);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2-0.3v",
8);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2,",
5);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2,v",
5);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2,-1",
5);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2]",
4);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2v",
4);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2,]",
5);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"[0.2,-]",
5);
ParseInvalid<SdpImageattrAttributeList::SRange>(
" ",
0);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"v",
0);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"-v",
0);
ParseInvalid<SdpImageattrAttributeList::SRange>(
"-1",
0);
}
static SdpImageattrAttributeList::PRange ParsePRange(
const std::string& input) {
std::istringstream is(input +
",");
std::string error;
SdpImageattrAttributeList::PRange range;
EXPECT_TRUE(range.Parse(is, &error)) << error;
EXPECT_EQ(
',', is.get());
EXPECT_EQ(EOF, is.get());
return range;
}
TEST(NewSdpTestNoFixture, CheckImageattrPRangeParseValid)
{
SdpImageattrAttributeList::PRange range(ParsePRange(
"[0.1000-9.9999]"));
ASSERT_FLOAT_EQ(
0.
1f, range.min);
ASSERT_FLOAT_EQ(
9.
9999f, range.max);
}
TEST(NewSdpTestNoFixture, CheckImageattrPRangeParseInvalid)
{
ParseInvalid<SdpImageattrAttributeList::PRange>(
"",
0);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[",
1);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[v",
1);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[-1",
1);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[",
1);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[-",
1);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[v",
1);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[ 0.2",
1);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[10.1-",
5);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.08-",
5);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2",
4);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2-",
5);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2-v",
5);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2--1",
5);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2-0.3",
8);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2-0.1]",
8);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2-0.3v",
8);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2,",
4);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2:",
4);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2]",
4);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"[0.2v",
4);
ParseInvalid<SdpImageattrAttributeList::PRange>(
" ",
0);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"v",
0);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"-x",
0);
ParseInvalid<SdpImageattrAttributeList::PRange>(
"-1",
0);
}
static SdpImageattrAttributeList::Set ParseSet(
const std::string& input) {
std::istringstream is(input +
" ");
std::string error;
SdpImageattrAttributeList::Set set;
EXPECT_TRUE(set.Parse(is, &error)) << error;
EXPECT_EQ(
' ', is.get());
EXPECT_EQ(EOF, is.get());
return set;
}
TEST(NewSdpTestNoFixture, CheckImageattrSetParseValid)
{
{
SdpImageattrAttributeList::Set set(ParseSet(
"[x=320,y=240]"));
ASSERT_EQ(
1U, set.xRange.discreteValues.size());
ASSERT_EQ(
320U, set.xRange.discreteValues[
0]);
ASSERT_EQ(
1U, set.yRange.discreteValues.size());
ASSERT_EQ(
240U, set.yRange.discreteValues[
0]);
ASSERT_FALSE(set.sRange.IsSet());
ASSERT_FALSE(set.pRange.IsSet());
ASSERT_FLOAT_EQ(
0.
5f, set.qValue);
}
{
SdpImageattrAttributeList::Set set(ParseSet(
"[X=320,Y=240]"));
ASSERT_EQ(
1U, set.xRange.discreteValues.size());
ASSERT_EQ(
320U, set.xRange.discreteValues[
0]);
ASSERT_EQ(
1U, set.yRange.discreteValues.size());
ASSERT_EQ(
240U, set.yRange.discreteValues[
0]);
ASSERT_FALSE(set.sRange.IsSet());
ASSERT_FALSE(set.pRange.IsSet());
ASSERT_FLOAT_EQ(
0.
5f, set.qValue);
}
{
SdpImageattrAttributeList::Set set(ParseSet(
"[x=320,y=240,par=[0.1-0.2]]"));
ASSERT_EQ(
1U, set.xRange.discreteValues.size());
ASSERT_EQ(
320U, set.xRange.discreteValues[
0]);
ASSERT_EQ(
1U, set.yRange.discreteValues.size());
ASSERT_EQ(
240U, set.yRange.discreteValues[
0]);
ASSERT_FALSE(set.sRange.IsSet());
ASSERT_TRUE(set.pRange.IsSet());
ASSERT_FLOAT_EQ(
0.
1f, set.pRange.min);
ASSERT_FLOAT_EQ(
0.
2f, set.pRange.max);
ASSERT_FLOAT_EQ(
0.
5f, set.qValue);
}
{
SdpImageattrAttributeList::Set set(ParseSet(
"[x=320,y=240,sar=[0.1-0.2]]"));
ASSERT_EQ(
1U, set.xRange.discreteValues.size());
ASSERT_EQ(
320U, set.xRange.discreteValues[
0]);
ASSERT_EQ(
1U, set.yRange.discreteValues.size());
ASSERT_EQ(
240U, set.yRange.discreteValues[
0]);
ASSERT_TRUE(set.sRange.IsSet());
ASSERT_FLOAT_EQ(
0.
1f, set.sRange.min);
ASSERT_FLOAT_EQ(
0.
2f, set.sRange.max);
ASSERT_FALSE(set.pRange.IsSet());
ASSERT_FLOAT_EQ(
0.
5f, set.qValue);
}
{
SdpImageattrAttributeList::Set set(ParseSet(
"[x=320,y=240,q=0.1]"));
ASSERT_EQ(
1U, set.xRange.discreteValues.size());
ASSERT_EQ(
320U, set.xRange.discreteValues[
0]);
ASSERT_EQ(
1U, set.yRange.discreteValues.size());
ASSERT_EQ(
240U, set.yRange.discreteValues[
0]);
ASSERT_FALSE(set.sRange.IsSet());
ASSERT_FALSE(set.pRange.IsSet());
ASSERT_FLOAT_EQ(
0.
1f, set.qValue);
}
{
SdpImageattrAttributeList::Set set(
ParseSet(
"[x=320,y=240,par=[0.1-0.2],sar=[0.3-0.4],q=0.6]"));
ASSERT_EQ(
1U, set.xRange.discreteValues.size());
ASSERT_EQ(
320U, set.xRange.discreteValues[
0]);
ASSERT_EQ(
1U, set.yRange.discreteValues.size());
ASSERT_EQ(
240U, set.yRange.discreteValues[
0]);
ASSERT_TRUE(set.sRange.IsSet());
ASSERT_FLOAT_EQ(
0.
3f, set.sRange.min);
ASSERT_FLOAT_EQ(
0.
4f, set.sRange.max);
ASSERT_TRUE(set.pRange.IsSet());
ASSERT_FLOAT_EQ(
0.
1f, set.pRange.min);
ASSERT_FLOAT_EQ(
0.
2f, set.pRange.max);
ASSERT_FLOAT_EQ(
0.
6f, set.qValue);
}
{
SdpImageattrAttributeList::Set set(ParseSet(
"[x=320,y=240,foo=bar,q=0.1]"));
ASSERT_EQ(
1U, set.xRange.discreteValues.size());
ASSERT_EQ(
320U, set.xRange.discreteValues[
0]);
ASSERT_EQ(
1U, set.yRange.discreteValues.size());
ASSERT_EQ(
240U, set.yRange.discreteValues[
0]);
ASSERT_FALSE(set.sRange.IsSet());
ASSERT_FALSE(set.pRange.IsSet());
ASSERT_FLOAT_EQ(
0.
1f, set.qValue);
}
{
SdpImageattrAttributeList::Set set(
ParseSet(
"[x=320,y=240,foo=bar,q=0.1,bar=baz]"));
ASSERT_EQ(
1U, set.xRange.discreteValues.size());
ASSERT_EQ(
320U, set.xRange.discreteValues[
0]);
ASSERT_EQ(
1U, set.yRange.discreteValues.size());
ASSERT_EQ(
240U, set.yRange.discreteValues[
0]);
ASSERT_FALSE(set.sRange.IsSet());
ASSERT_FALSE(set.pRange.IsSet());
ASSERT_FLOAT_EQ(
0.
1f, set.qValue);
}
{
SdpImageattrAttributeList::Set set(
ParseSet(
"[x=320,y=240,foo=[bar],q=0.1,bar=[baz]]"));
ASSERT_EQ(
1U, set.xRange.discreteValues.size());
ASSERT_EQ(
320U, set.xRange.discreteValues[
0]);
ASSERT_EQ(
1U, set.yRange.discreteValues.size());
ASSERT_EQ(
240U, set.yRange.discreteValues[
0]);
ASSERT_FALSE(set.sRange.IsSet());
ASSERT_FALSE(set.pRange.IsSet());
ASSERT_FLOAT_EQ(
0.
1f, set.qValue);
}
{
SdpImageattrAttributeList::Set set(
ParseSet(
"[x=320,y=240,foo=[par=foo,sar=bar],q=0.1,bar=[baz]]"));
ASSERT_EQ(
1U, set.xRange.discreteValues.size());
ASSERT_EQ(
320U, set.xRange.discreteValues[
0]);
ASSERT_EQ(
1U, set.yRange.discreteValues.size());
ASSERT_EQ(
240U, set.yRange.discreteValues[
0]);
ASSERT_FALSE(set.sRange.IsSet());
ASSERT_FALSE(set.pRange.IsSet());
ASSERT_FLOAT_EQ(
0.
1f, set.qValue);
}
}
TEST(NewSdpTestNoFixture, CheckImageattrSetParseInvalid)
{
ParseInvalid<SdpImageattrAttributeList::Set>(
"",
0);
ParseInvalid<SdpImageattrAttributeList::Set>(
"x",
0);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[",
1);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[=",
2);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x",
2);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[y=",
3);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=[",
4);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320",
6);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320v",
6);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,",
7);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,=",
8);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,x",
8);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,x=",
9);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=[",
10);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240",
12);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240x",
12);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,",
13);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,q=",
15);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,q=v",
15);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,q=0.5",
18);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,q=0.5,",
19);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,q=0.5,]",
20);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,q=0.5,=]",
20);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,q=0.5,sar=v]",
23);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,q=0.5,q=0.4",
21);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,sar=",
17);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,sar=v",
17);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,sar=[0.5-0.6],sar=[0.7-0.8]",
31);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,par=",
17);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,par=x",
17);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,par=[0.5-0.6],par=[0.7-0.8]",
31);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,foo=",
17);
ParseInvalid<SdpImageattrAttributeList::Set>(
"[x=320,y=240,foo=x",
18);
}
static SdpImageattrAttributeList::Imageattr ParseImageattr(
const std::string& input) {
std::istringstream is(input);
std::string error;
SdpImageattrAttributeList::Imageattr imageattr;
EXPECT_TRUE(imageattr.Parse(is, &error)) << error;
EXPECT_TRUE(is.eof());
return imageattr;
}
TEST(NewSdpTestNoFixture, CheckImageattrParseValid)
{
{
SdpImageattrAttributeList::Imageattr imageattr(ParseImageattr(
"* send *"));
ASSERT_FALSE(imageattr.pt.isSome());
ASSERT_TRUE(imageattr.sendAll);
ASSERT_TRUE(imageattr.sendSets.empty());
ASSERT_FALSE(imageattr.recvAll);
ASSERT_TRUE(imageattr.recvSets.empty());
}
{
SdpImageattrAttributeList::Imageattr imageattr(ParseImageattr(
"* SEND *"));
ASSERT_FALSE(imageattr.pt.isSome());
ASSERT_TRUE(imageattr.sendAll);
ASSERT_TRUE(imageattr.sendSets.empty());
ASSERT_FALSE(imageattr.recvAll);
ASSERT_TRUE(imageattr.recvSets.empty());
}
{
SdpImageattrAttributeList::Imageattr imageattr(ParseImageattr(
"* recv *"));
ASSERT_FALSE(imageattr.pt.isSome());
ASSERT_FALSE(imageattr.sendAll);
ASSERT_TRUE(imageattr.sendSets.empty());
ASSERT_TRUE(imageattr.recvAll);
ASSERT_TRUE(imageattr.recvSets.empty());
}
{
SdpImageattrAttributeList::Imageattr imageattr(ParseImageattr(
"* RECV *"));
ASSERT_FALSE(imageattr.pt.isSome());
ASSERT_FALSE(imageattr.sendAll);
ASSERT_TRUE(imageattr.sendSets.empty());
ASSERT_TRUE(imageattr.recvAll);
ASSERT_TRUE(imageattr.recvSets.empty());
}
{
SdpImageattrAttributeList::Imageattr imageattr(
ParseImageattr(
"* recv * send *"));
ASSERT_FALSE(imageattr.pt.isSome());
ASSERT_TRUE(imageattr.sendAll);
ASSERT_TRUE(imageattr.sendSets.empty());
ASSERT_TRUE(imageattr.recvAll);
ASSERT_TRUE(imageattr.recvSets.empty());
}
{
SdpImageattrAttributeList::Imageattr imageattr(
ParseImageattr(
"* send * recv *"));
ASSERT_FALSE(imageattr.pt.isSome());
ASSERT_TRUE(imageattr.sendAll);
ASSERT_TRUE(imageattr.sendSets.empty());
ASSERT_TRUE(imageattr.recvAll);
ASSERT_TRUE(imageattr.recvSets.empty());
}
{
SdpImageattrAttributeList::Imageattr imageattr(
ParseImageattr(
"8 send * recv *"));
ASSERT_EQ(
8U, *imageattr.pt);
ASSERT_TRUE(imageattr.sendAll);
ASSERT_TRUE(imageattr.sendSets.empty());
ASSERT_TRUE(imageattr.recvAll);
ASSERT_TRUE(imageattr.recvSets.empty());
}
{
SdpImageattrAttributeList::Imageattr imageattr(
ParseImageattr(
"8 send [x=320,y=240] recv *"));
ASSERT_EQ(
8U, *imageattr.pt);
ASSERT_FALSE(imageattr.sendAll);
ASSERT_EQ(
1U, imageattr.sendSets.size());
ASSERT_EQ(
1U, imageattr.sendSets[
0].xRange.discreteValues.size());
ASSERT_EQ(
320U, imageattr.sendSets[
0].xRange.discreteValues[
0]);
ASSERT_EQ(
1U, imageattr.sendSets[
0].yRange.discreteValues.size());
ASSERT_EQ(
240U, imageattr.sendSets[
0].yRange.discreteValues[
0]);
ASSERT_TRUE(imageattr.recvAll);
ASSERT_TRUE(imageattr.recvSets.empty());
}
{
SdpImageattrAttributeList::Imageattr imageattr(
ParseImageattr(
"8 send [x=320,y=240] [x=640,y=480] recv *"));
ASSERT_EQ(
8U, *imageattr.pt);
ASSERT_FALSE(imageattr.sendAll);
ASSERT_EQ(
2U, imageattr.sendSets.size());
ASSERT_EQ(
1U, imageattr.sendSets[
0].xRange.discreteValues.size());
ASSERT_EQ(
320U, imageattr.sendSets[
0].xRange.discreteValues[
0]);
ASSERT_EQ(
1U, imageattr.sendSets[
0].yRange.discreteValues.size());
ASSERT_EQ(
240U, imageattr.sendSets[
0].yRange.discreteValues[
0]);
ASSERT_EQ(
1U, imageattr.sendSets[
1].xRange.discreteValues.size());
ASSERT_EQ(
640U, imageattr.sendSets[
1].xRange.discreteValues[
0]);
ASSERT_EQ(
1U, imageattr.sendSets[
1].yRange.discreteValues.size());
ASSERT_EQ(
480U, imageattr.sendSets[
1].yRange.discreteValues[
0]);
ASSERT_TRUE(imageattr.recvAll);
ASSERT_TRUE(imageattr.recvSets.empty());
}
{
SdpImageattrAttributeList::Imageattr imageattr(
ParseImageattr(
"8 send * recv [x=320,y=240]"));
ASSERT_EQ(
8U, *imageattr.pt);
ASSERT_FALSE(imageattr.recvAll);
ASSERT_EQ(
1U, imageattr.recvSets.size());
ASSERT_EQ(
1U, imageattr.recvSets[
0].xRange.discreteValues.size());
ASSERT_EQ(
320U, imageattr.recvSets[
0].xRange.discreteValues[
0]);
ASSERT_EQ(
1U, imageattr.recvSets[
0].yRange.discreteValues.size());
ASSERT_EQ(
240U, imageattr.recvSets[
0].yRange.discreteValues[
0]);
ASSERT_TRUE(imageattr.sendAll);
ASSERT_TRUE(imageattr.sendSets.empty());
}
{
SdpImageattrAttributeList::Imageattr imageattr(
ParseImageattr(
"8 send * recv [x=320,y=240] [x=640,y=480]"));
ASSERT_EQ(
8U, *imageattr.pt);
ASSERT_FALSE(imageattr.recvAll);
ASSERT_EQ(
2U, imageattr.recvSets.size());
ASSERT_EQ(
1U, imageattr.recvSets[
0].xRange.discreteValues.size());
ASSERT_EQ(
320U, imageattr.recvSets[
0].xRange.discreteValues[
0]);
ASSERT_EQ(
1U, imageattr.recvSets[
0].yRange.discreteValues.size());
ASSERT_EQ(
240U, imageattr.recvSets[
0].yRange.discreteValues[
0]);
ASSERT_EQ(
1U, imageattr.recvSets[
1].xRange.discreteValues.size());
ASSERT_EQ(
640U, imageattr.recvSets[
1].xRange.discreteValues[
0]);
ASSERT_EQ(
1U, imageattr.recvSets[
1].yRange.discreteValues.size());
ASSERT_EQ(
480U, imageattr.recvSets[
1].yRange.discreteValues[
0]);
ASSERT_TRUE(imageattr.sendAll);
ASSERT_TRUE(imageattr.sendSets.empty());
}
}
TEST(NewSdpTestNoFixture, CheckImageattrParseInvalid)
{
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"",
0);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
" ",
0);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"-1",
0);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"99999 ",
5);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"*",
1);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* sen",
5);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* vcer *",
6);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* send x",
7);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* send [x=640,y=480] [",
22);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* send * sen",
12);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* send * vcer *",
13);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* send * send *",
13);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* recv * recv *",
13);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* send * recv x",
14);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* send * recv [x=640,y=480] [",
29);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* send * recv [x=640,y=480] *",
28);
ParseInvalid<SdpImageattrAttributeList::Imageattr>(
"* send * recv [x=640,y=480] foobajooba",
28);
}
TEST(NewSdpTestNoFixture, CheckImageattrXYRangeSerialization)
{
SdpImageattrAttributeList::XYRange range;
std::stringstream os;
range.min =
320;
range.max =
640;
range.Serialize(os);
ASSERT_EQ(
"[320:640]", os.str());
os.str(
"");
// clear
range.step =
16;
range.Serialize(os);
ASSERT_EQ(
"[320:16:640]", os.str());
os.str(
"");
// clear
range.min =
0;
range.max =
0;
range.discreteValues.push_back(
320);
range.Serialize(os);
ASSERT_EQ(
"320", os.str());
os.str(
"");
range.discreteValues.push_back(
640);
range.Serialize(os);
ASSERT_EQ(
"[320,640]", os.str());
}
TEST(NewSdpTestNoFixture, CheckImageattrSRangeSerialization)
{
SdpImageattrAttributeList::SRange range;
std::ostringstream os;
range.min =
0.
1f;
range.max =
0.
9999f;
range.Serialize(os);
ASSERT_EQ(
"[0.1000-0.9999]", os.str());
os.str(
"");
range.min =
0.
0f;
range.max =
0.
0f;
range.discreteValues.push_back(
0.
1f);
range.Serialize(os);
ASSERT_EQ(
"0.1000", os.str());
os.str(
"");
range.discreteValues.push_back(
0.
5f);
range.Serialize(os);
ASSERT_EQ(
"[0.1000,0.5000]", os.str());
}
TEST(NewSdpTestNoFixture, CheckImageattrPRangeSerialization)
{
SdpImageattrAttributeList::PRange range;
std::ostringstream os;
range.min =
0.
1f;
range.max =
0.
9999f;
range.Serialize(os);
ASSERT_EQ(
"[0.1000-0.9999]", os.str());
}
TEST(NewSdpTestNoFixture, CheckImageattrSetSerialization)
{
SdpImageattrAttributeList::Set set;
std::ostringstream os;
set.xRange.discreteValues.push_back(
640);
set.yRange.discreteValues.push_back(
480);
set.Serialize(os);
ASSERT_EQ(
"[x=640,y=480]", os.str());
os.str(
"");
set.qValue =
0.
00f;
set.Serialize(os);
ASSERT_EQ(
"[x=640,y=480,q=0.00]", os.str());
os.str(
"");
set.qValue =
0.
10f;
set.Serialize(os);
ASSERT_EQ(
"[x=640,y=480,q=0.10]", os.str());
os.str(
"");
set.qValue =
1.
00f;
set.Serialize(os);
ASSERT_EQ(
"[x=640,y=480,q=1.00]", os.str());
os.str(
"");
set.sRange.discreteValues.push_back(
1.
1f);
set.Serialize(os);
ASSERT_EQ(
"[x=640,y=480,sar=1.1000,q=1.00]", os.str());
os.str(
"");
set.pRange.min =
0.
9f;
set.pRange.max =
1.
1f;
set.Serialize(os);
ASSERT_EQ(
"[x=640,y=480,sar=1.1000,par=[0.9000-1.1000],q=1.00]", os.str());
os.str(
"");
}
TEST(NewSdpTestNoFixture, CheckImageattrSerialization)
{
SdpImageattrAttributeList::Imageattr imageattr;
std::ostringstream os;
imageattr.sendAll =
true;
imageattr.pt = Some<uint16_t>(
8U);
imageattr.Serialize(os);
ASSERT_EQ(
"8 send *", os.str());
os.str(
"");
imageattr.pt.reset();
;
imageattr.Serialize(os);
ASSERT_EQ(
"* send *", os.str());
os.str(
"");
imageattr.sendAll =
false;
imageattr.recvAll =
true;
imageattr.Serialize(os);
ASSERT_EQ(
"* recv *", os.str());
os.str(
"");
imageattr.sendAll =
true;
imageattr.Serialize(os);
ASSERT_EQ(
"* send * recv *", os.str());
os.str(
"");
imageattr.sendAll =
false;
imageattr.sendSets.push_back(SdpImageattrAttributeList::Set());
imageattr.sendSets.back().xRange.discreteValues.push_back(
320);
imageattr.sendSets.back().yRange.discreteValues.push_back(
240);
imageattr.Serialize(os);
ASSERT_EQ(
"* send [x=320,y=240] recv *", os.str());
os.str(
"");
imageattr.sendSets.push_back(SdpImageattrAttributeList::Set());
imageattr.sendSets.back().xRange.discreteValues.push_back(
640);
imageattr.sendSets.back().yRange.discreteValues.push_back(
480);
imageattr.Serialize(os);
ASSERT_EQ(
"* send [x=320,y=240] [x=640,y=480] recv *", os.str());
os.str(
"");
imageattr.recvAll =
false;
imageattr.recvSets.push_back(SdpImageattrAttributeList::Set());
imageattr.recvSets.back().xRange.discreteValues.push_back(
320);
imageattr.recvSets.back().yRange.discreteValues.push_back(
240);
imageattr.Serialize(os);
ASSERT_EQ(
"* send [x=320,y=240] [x=640,y=480] recv [x=320,y=240]", os.str());
os.str(
"");
imageattr.recvSets.push_back(SdpImageattrAttributeList::Set());
imageattr.recvSets.back().xRange.discreteValues.push_back(
640);
imageattr.recvSets.back().yRange.discreteValues.push_back(
480);
imageattr.Serialize(os);
ASSERT_EQ(
"* send [x=320,y=240] [x=640,y=480] recv [x=320,y=240] [x=640,y=480]",
os.str());
os.str(
"");
}
TEST(NewSdpTestNoFixture, CheckSimulcastVersionSerialize)
{
std::ostringstream os;
SdpSimulcastAttribute::Version version;
version.choices.push_back(SdpSimulcastAttribute::Encoding(
"8",
false));
version.Serialize(os);
ASSERT_EQ(
"8", os.str());
os.str(
"");
version.choices.push_back(SdpSimulcastAttribute::Encoding(
"9",
true));
version.Serialize(os);
ASSERT_EQ(
"8,~9", os.str());
os.str(
"");
version.choices.push_back(SdpSimulcastAttribute::Encoding(
"0",
false));
version.Serialize(os);
ASSERT_EQ(
"8,~9,0", os.str());
os.str(
"");
}
static SdpSimulcastAttribute::Version ParseSimulcastVersion(
const std::string& input) {
std::istringstream is(input +
";");
std::string error;
SdpSimulcastAttribute::Version version;
EXPECT_TRUE(version.Parse(is, &error)) << error;
EXPECT_EQ(
';', is.get());
EXPECT_EQ(EOF, is.get());
return version;
}
TEST(NewSdpTestNoFixture, CheckSimulcastVersionValidParse)
{
{
SdpSimulcastAttribute::Version version(ParseSimulcastVersion(
"1"));
ASSERT_EQ(
1U, version.choices.size());
ASSERT_EQ(
"1", version.choices[
0].rid);
ASSERT_FALSE(version.choices[
0].paused);
}
{
SdpSimulcastAttribute::Version version(ParseSimulcastVersion(
"1,~2"));
ASSERT_EQ(
2U, version.choices.size());
ASSERT_EQ(
"1", version.choices[
0].rid);
ASSERT_EQ(
"2", version.choices[
1].rid);
ASSERT_FALSE(version.choices[
0].paused);
ASSERT_TRUE(version.choices[
1].paused);
}
}
TEST(NewSdpTestNoFixture, CheckSimulcastVersionInvalidParse)
{
ParseInvalid<SdpSimulcastAttribute::Version>(
"",
0);
ParseInvalid<SdpSimulcastAttribute::Version>(
",",
0);
ParseInvalid<SdpSimulcastAttribute::Version>(
";",
0);
ParseInvalid<SdpSimulcastAttribute::Version>(
" ",
0);
ParseInvalid<SdpSimulcastAttribute::Version>(
"8,",
2);
ParseInvalid<SdpSimulcastAttribute::Version>(
"8, ",
2);
ParseInvalid<SdpSimulcastAttribute::Version>(
"8,,",
2);
ParseInvalid<SdpSimulcastAttribute::Version>(
"8,;",
2);
}
TEST(NewSdpTestNoFixture, CheckSimulcastVersionsSerialize)
{
std::ostringstream os;
SdpSimulcastAttribute::Versions versions;
versions.push_back(SdpSimulcastAttribute::Version());
versions.back().choices.push_back(
SdpSimulcastAttribute::Encoding(
"8",
false));
versions.Serialize(os);
ASSERT_EQ(
"8", os.str());
os.str(
"");
versions.push_back(SdpSimulcastAttribute::Version());
versions.Serialize(os);
ASSERT_EQ(
"8", os.str());
os.str(
"");
versions.back().choices.push_back(SdpSimulcastAttribute::Encoding(
"9",
true));
versions.Serialize(os);
ASSERT_EQ(
"8;~9", os.str());
os.str(
"");
versions.push_back(SdpSimulcastAttribute::Version());
versions.back().choices.push_back(
SdpSimulcastAttribute::Encoding(
"0",
false));
versions.Serialize(os);
ASSERT_EQ(
"8;~9;0", os.str());
os.str(
"");
}
static SdpSimulcastAttribute::Versions ParseSimulcastVersions(
const std::string& input) {
std::istringstream is(input +
" ");
std::string error;
SdpSimulcastAttribute::Versions list;
EXPECT_TRUE(list.Parse(is, &error)) << error;
EXPECT_EQ(
' ', is.get());
EXPECT_EQ(EOF, is.get());
return list;
}
TEST(NewSdpTestNoFixture, CheckSimulcastVersionsValidParse)
{
{
SdpSimulcastAttribute::Versions versions(ParseSimulcastVersions(
"8"));
ASSERT_EQ(
1U, versions.size());
ASSERT_EQ(
1U, versions[
0].choices.size());
ASSERT_EQ(
"8", versions[
0].choices[
0].rid);
ASSERT_FALSE(versions[
0].choices[
0].paused);
}
{
SdpSimulcastAttribute::Versions versions(ParseSimulcastVersions(
"~8,9"));
ASSERT_EQ(
1U, versions.size());
ASSERT_EQ(
2U, versions[
0].choices.size());
ASSERT_EQ(
"8", versions[
0].choices[
0].rid);
ASSERT_EQ(
"9", versions[
0].choices[
1].rid);
ASSERT_TRUE(versions[
0].choices[
0].paused);
ASSERT_FALSE(versions[
0].choices[
1].paused);
}
{
SdpSimulcastAttribute::Versions versions(ParseSimulcastVersions(
"8,9;~10"));
ASSERT_EQ(
2U, versions.size());
ASSERT_EQ(
2U, versions[
0].choices.size());
ASSERT_EQ(
"8", versions[
0].choices[
0].rid);
ASSERT_EQ(
"9", versions[
0].choices[
1].rid);
ASSERT_FALSE(versions[
0].choices[
0].paused);
ASSERT_FALSE(versions[
0].choices[
1].paused);
ASSERT_EQ(
1U, versions[
1].choices.size());
ASSERT_EQ(
"10", versions[
1].choices[
0].rid);
ASSERT_TRUE(versions[
1].choices[
0].paused);
}
}
TEST(NewSdpTestNoFixture, CheckSimulcastVersionsInvalidParse)
{
ParseInvalid<SdpSimulcastAttribute::Versions>(
"",
0);
ParseInvalid<SdpSimulcastAttribute::Versions>(
";",
0);
ParseInvalid<SdpSimulcastAttribute::Versions>(
"8;",
2);
ParseInvalid<SdpSimulcastAttribute::Versions>(
"8;;",
2);
}
TEST(NewSdpTestNoFixture, CheckSimulcastSerialize)
{
std::ostringstream os;
SdpSimulcastAttribute simulcast;
simulcast.recvVersions.push_back(SdpSimulcastAttribute::Version());
simulcast.recvVersions.back().choices.push_back(
SdpSimulcastAttribute::Encoding(
"8",
false));
simulcast.Serialize(os);
ASSERT_EQ(
"a=simulcast:recv 8" CRLF, os.str());
os.str(
"");
simulcast.sendVersions.push_back(SdpSimulcastAttribute::Version());
simulcast.sendVersions.back().choices.push_back(
SdpSimulcastAttribute::Encoding(
"9",
true));
simulcast.Serialize(os);
ASSERT_EQ(
"a=simulcast:send ~9 recv 8" CRLF, os.str());
}
static SdpSimulcastAttribute ParseSimulcast(
const std::string& input) {
std::istringstream is(input);
std::string error;
SdpSimulcastAttribute simulcast;
EXPECT_TRUE(simulcast.Parse(is, &error)) << error;
EXPECT_TRUE(is.eof());
return simulcast;
}
TEST(NewSdpTestNoFixture, CheckSimulcastValidParse)
{
{
SdpSimulcastAttribute simulcast(ParseSimulcast(
"send 8"));
ASSERT_EQ(
1U, simulcast.sendVersions.size());
ASSERT_EQ(
1U, simulcast.sendVersions[
0].choices.size());
ASSERT_EQ(
"8", simulcast.sendVersions[
0].choices[
0].rid);
ASSERT_FALSE(simulcast.sendVersions[
0].choices[
0].paused);
ASSERT_EQ(
0U, simulcast.recvVersions.size());
}
{
SdpSimulcastAttribute simulcast(ParseSimulcast(
" SEND 8"));
ASSERT_EQ(
1U, simulcast.sendVersions.size());
ASSERT_EQ(
1U, simulcast.sendVersions[
0].choices.size());
ASSERT_EQ(
"8", simulcast.sendVersions[
0].choices[
0].rid);
ASSERT_FALSE(simulcast.sendVersions[
0].choices[
0].paused);
ASSERT_EQ(
0U, simulcast.recvVersions.size());
}
{
SdpSimulcastAttribute simulcast(ParseSimulcast(
"recv 8"));
ASSERT_EQ(
1U, simulcast.recvVersions.size());
ASSERT_EQ(
1U, simulcast.recvVersions[
0].choices.size());
ASSERT_EQ(
"8", simulcast.recvVersions[
0].choices[
0].rid);
ASSERT_FALSE(simulcast.recvVersions[
0].choices[
0].paused);
ASSERT_EQ(
0U, simulcast.sendVersions.size());
}
{
SdpSimulcastAttribute simulcast(
ParseSimulcast(
"send 8,9;~101;97,~98 recv 101,120;97"));
ASSERT_EQ(
3U, simulcast.sendVersions.size());
ASSERT_EQ(
2U, simulcast.sendVersions[
0].choices.size());
ASSERT_EQ(
"8", simulcast.sendVersions[
0].choices[
0].rid);
ASSERT_EQ(
"9", simulcast.sendVersions[
0].choices[
1].rid);
ASSERT_FALSE(simulcast.sendVersions[
0].choices[
0].paused);
ASSERT_FALSE(simulcast.sendVersions[
0].choices[
1].paused);
ASSERT_EQ(
1U, simulcast.sendVersions[
1].choices.size());
ASSERT_EQ(
"101", simulcast.sendVersions[
1].choices[
0].rid);
ASSERT_TRUE(simulcast.sendVersions[
1].choices[
0].paused);
ASSERT_EQ(
2U, simulcast.sendVersions[
2].choices.size());
ASSERT_EQ(
"97", simulcast.sendVersions[
2].choices[
0].rid);
ASSERT_EQ(
"98", simulcast.sendVersions[
2].choices[
1].rid);
ASSERT_FALSE(simulcast.sendVersions[
2].choices[
0].paused);
ASSERT_TRUE(simulcast.sendVersions[
2].choices[
1].paused);
ASSERT_EQ(
2U, simulcast.recvVersions.size());
ASSERT_EQ(
2U, simulcast.recvVersions[
0].choices.size());
ASSERT_EQ(
"101", simulcast.recvVersions[
0].choices[
0].rid);
ASSERT_EQ(
"120", simulcast.recvVersions[
0].choices[
1].rid);
ASSERT_EQ(
1U, simulcast.recvVersions[
1].choices.size());
ASSERT_EQ(
"97", simulcast.recvVersions[
1].choices[
0].rid);
}
}
TEST(NewSdpTestNoFixture, CheckSimulcastInvalidParse)
{
ParseInvalid<SdpSimulcastAttribute>(
"",
0);
ParseInvalid<SdpSimulcastAttribute>(
" ",
1);
ParseInvalid<SdpSimulcastAttribute>(
"vcer ",
4);
ParseInvalid<SdpSimulcastAttribute>(
" send 8 send ",
12);
ParseInvalid<SdpSimulcastAttribute>(
" recv 8 recv ",
12);
}
static SdpRidAttributeList::Rid ParseRid(
const std::string& input) {
std::istringstream is(input);
std::string error;
SdpRidAttributeList::Rid rid;
EXPECT_TRUE(rid.Parse(is, &error)) << error;
EXPECT_TRUE(is.eof());
return rid;
}
TEST(NewSdpTestNoFixture, CheckRidValidParse)
{
{
SdpRidAttributeList::Rid rid(ParseRid(
"1 send"));
ASSERT_EQ(
"1", rid.id);
ASSERT_EQ(sdp::kSend, rid.direction);
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"1 send pt=96;max-width=800"));
ASSERT_EQ(
"1", rid.id);
ASSERT_EQ(sdp::kSend, rid.direction);
ASSERT_EQ(
1U, rid.formats.size());
ASSERT_EQ(
96U, rid.formats[
0]);
ASSERT_EQ(
800U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"1 send pt=96,97,98;max-width=800"));
ASSERT_EQ(
"1", rid.id);
ASSERT_EQ(sdp::kSend, rid.direction);
ASSERT_EQ(
3U, rid.formats.size());
ASSERT_EQ(
96U, rid.formats[
0]);
ASSERT_EQ(
97U, rid.formats[
1]);
ASSERT_EQ(
98U, rid.formats[
2]);
ASSERT_EQ(
800U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send pt=96"));
ASSERT_EQ(
1U, rid.formats.size());
ASSERT_EQ(
96U, rid.formats[
0]);
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
// This is not technically permitted by the BNF, but the parse code is simpler
// if we allow it. If we decide to stop allowing this, this will need to be
// converted to an invalid parse test-case.
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send max-br=30000;pt=96"));
ASSERT_EQ(
1U, rid.formats.size());
ASSERT_EQ(
96U, rid.formats[
0]);
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
30000U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send pt=96,97,98"));
ASSERT_EQ(
3U, rid.formats.size());
ASSERT_EQ(
96U, rid.formats[
0]);
ASSERT_EQ(
97U, rid.formats[
1]);
ASSERT_EQ(
98U, rid.formats[
2]);
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send max-width=800"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
800U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send max-height=640"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
640U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send max-fps=30"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_EQ(
30.
0, *rid.constraints.maxFps);
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send max-fs=3600"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
3600U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send max-br=30000"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
30000U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send max-pps=9216000"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
9216000U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send depend=foo"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
1U, rid.dependIds.size());
ASSERT_EQ(
"foo", rid.dependIds[
0]);
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send max-foo=20"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(ParseRid(
"foo send depend=foo,bar"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
0U, rid.constraints.maxWidth);
ASSERT_EQ(
0U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
2U, rid.dependIds.size());
ASSERT_EQ(
"foo", rid.dependIds[
0]);
ASSERT_EQ(
"bar", rid.dependIds[
1]);
}
{
SdpRidAttributeList::Rid rid(
ParseRid(
"foo send max-width=800;max-height=600"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
800U, rid.constraints.maxWidth);
ASSERT_EQ(
600U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(
ParseRid(
"foo send pt=96,97;max-width=800;max-height=600"));
ASSERT_EQ(
2U, rid.formats.size());
ASSERT_EQ(
96U, rid.formats[
0]);
ASSERT_EQ(
97U, rid.formats[
1]);
ASSERT_EQ(
800U, rid.constraints.maxWidth);
ASSERT_EQ(
600U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
{
SdpRidAttributeList::Rid rid(
ParseRid(
"foo send depend=foo,bar;max-width=800;max-height=600"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
800U, rid.constraints.maxWidth);
ASSERT_EQ(
600U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
2U, rid.dependIds.size());
ASSERT_EQ(
"foo", rid.dependIds[
0]);
ASSERT_EQ(
"bar", rid.dependIds[
1]);
}
{
SdpRidAttributeList::Rid rid(
ParseRid(
"foo send max-foo=20;max-width=800;max-height=600"));
ASSERT_EQ(
0U, rid.formats.size());
ASSERT_EQ(
800U, rid.constraints.maxWidth);
ASSERT_EQ(
600U, rid.constraints.maxHeight);
ASSERT_FALSE(rid.constraints.maxFps.isSome());
ASSERT_EQ(
0U, rid.constraints.maxFs);
ASSERT_EQ(
0U, rid.constraints.maxBr);
ASSERT_EQ(
0U, rid.constraints.maxPps);
ASSERT_EQ(
0U, rid.dependIds.size());
}
}
TEST(NewSdpTestNoFixture, CheckRidInvalidParse)
{
ParseInvalid<SdpRidAttributeList::Rid>(
"",
0);
ParseInvalid<SdpRidAttributeList::Rid>(
" ",
0);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo",
3);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo ",
4);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo ",
5);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo bar",
7);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo recv ",
9);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo recv pt=",
12);
ParseInvalid<SdpRidAttributeList::Rid>(
" ",
0);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send pt",
11);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send pt=",
12);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send pt=x",
12);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send pt=-1",
12);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send pt=96,",
15);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send pt=196",
15);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send max-width",
18);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send max-width=",
19);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send max-width=x",
19);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send max-width=-1",
19);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send max-width=800;",
23);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send max-width=800; ",
24);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send depend=",
16);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send depend=,",
16);
ParseInvalid<SdpRidAttributeList::Rid>(
"foo send depend=1,",
18);
ParseInvalid<SdpRidAttributeList::Rid>(
"0123456789az-_",
14);
}
TEST(NewSdpTestNoFixture, CheckRidSerialize)
{
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.formats.push_back(
96);
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send pt=96", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.formats.push_back(
96);
rid.formats.push_back(
97);
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send pt=96,97", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.constraints.maxWidth =
800;
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send max-width=800", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.constraints.maxHeight =
600;
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send max-height=600", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.constraints.maxFps = Some(
30);
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send max-fps=30", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.constraints.maxFs =
3600;
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send max-fs=3600", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.constraints.maxBr =
30000;
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send max-br=30000", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.constraints.maxPps =
9216000;
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send max-pps=9216000", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.dependIds.push_back(
"foo");
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send depend=foo", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.dependIds.push_back(
"foo");
rid.dependIds.push_back(
"bar");
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send depend=foo,bar", os.str());
}
{
SdpRidAttributeList::Rid rid;
rid.id =
"foo";
rid.direction = sdp::kSend;
rid.formats.push_back(
96);
rid.constraints.maxBr =
30000;
std::ostringstream os;
rid.Serialize(os);
ASSERT_EQ(
"foo send pt=96;max-br=30000", os.str());
}
}
TEST_F(SdpTest, hugeSdp) {
std::string offer =
"v=0\r\n"
"o=- 1109973417102828257 2 IN IP4 127.0.0.1\r\n"
"s=-\r\n"
"t=0 0\r\n"
"a=group:BUNDLE audio video\r\n"
"a=msid-semantic: WMS 1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIP\r\n"
"m=audio 32952 UDP/TLS/RTP/SAVPF 111 103 104 0 8 107 106 105 13 126\r\n"
"c=IN IP4 128.64.32.16\r\n"
"a=rtcp:32952 IN IP4 128.64.32.16\r\n"
"a=candidate:77142221 1 udp 2113937151 192.168.137.1 54081 typ host "
"generation 0\r\n"
"a=candidate:77142221 2 udp 2113937151 192.168.137.1 54081 typ host "
"generation 0\r\n"
"a=candidate:983072742 1 udp 2113937151 172.22.0.56 54082 typ host "
"generation 0\r\n"
"a=candidate:983072742 2 udp 2113937151 172.22.0.56 54082 typ host "
"generation 0\r\n"
"a=candidate:2245074553 1 udp 1845501695 32.64.128.1 62397 typ srflx "
"raddr 192.168.137.1 rport 54081 generation 0\r\n"
"a=candidate:2245074553 2 udp 1845501695 32.64.128.1 62397 typ srflx "
"raddr 192.168.137.1 rport 54081 generation 0\r\n"
"a=candidate:2479353907 1 udp 1845501695 32.64.128.1 54082 typ srflx "
"raddr 172.22.0.56 rport 54082 generation 0\r\n"
"a=candidate:2479353907 2 udp 1845501695 32.64.128.1 54082 typ srflx "
"raddr 172.22.0.56 rport 54082 generation 0\r\n"
"a=candidate:1243276349 1 tcp 1509957375 192.168.137.1 0 typ host "
"generation 0\r\n"
"a=candidate:1243276349 2 tcp 1509957375 192.168.137.1 0 typ host "
"generation 0\r\n"
"a=candidate:1947960086 1 tcp 1509957375 172.22.0.56 0 typ host "
"generation 0\r\n"
"a=candidate:1947960086 2 tcp 1509957375 172.22.0.56 0 typ host "
"generation 0\r\n"
"a=candidate:1808221584 1 udp 33562367 128.64.32.16 32952 typ relay "
"raddr 32.64.128.1 rport 62398 generation 0\r\n"
"a=candidate:1808221584 2 udp 33562367 128.64.32.16 32952 typ relay "
"raddr 32.64.128.1 rport 62398 generation 0\r\n"
"a=candidate:507872740 1 udp 33562367 128.64.32.16 40975 typ relay raddr "
"32.64.128.1 rport 54085 generation 0\r\n"
"a=candidate:507872740 2 udp 33562367 128.64.32.16 40975 typ relay raddr "
"32.64.128.1 rport 54085 generation 0\r\n"
"a=ice-ufrag:xQuJwjX3V3eMA81k\r\n"
"a=ice-pwd:ZUiRmjS2GDhG140p73dAsSVP\r\n"
"a=ice-options:google-ice\r\n"
"a=fingerprint:sha-256 "
"59:4A:8B:73:A7:73:53:71:88:D7:4D:58:28:0C:79:72:31:29:9B:05:37:DD:58:43:"
"C2:D4:85:A2:B3:66:38:7A\r\n"
"a=setup:active\r\n"
"a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level\r\n"
"a=sendrecv\r\n"
"a=mid:audio\r\n"
"a=rtcp-mux\r\n"
"a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
"inline:/U44g3ULdtapeiSg+T3n6dDLBKIjpOhb/NXAL/2b\r\n"
"a=rtpmap:111 opus/48000/2\r\n"
"a=fmtp:111 minptime=10\r\n"
"a=rtpmap:103 ISAC/16000\r\n"
"a=rtpmap:104 ISAC/32000\r\n"
"a=rtpmap:0 PCMU/8000\r\n"
"a=rtpmap:8 PCMA/8000\r\n"
"a=rtpmap:107 CN/48000\r\n"
"a=rtpmap:106 CN/32000\r\n"
"a=rtpmap:105 CN/16000\r\n"
"a=rtpmap:13 CN/8000\r\n"
"a=rtpmap:126 telephone-event/8000\r\n"
"a=maxptime:60\r\n"
"a=ssrc:2271517329 cname:mKDNt7SQf6pwDlIn\r\n"
"a=ssrc:2271517329 msid:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIP "
"1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIPa0\r\n"
"a=ssrc:2271517329 mslabel:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIP\r\n"
"a=ssrc:2271517329 label:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIPa0\r\n"
"m=video 32952 UDP/TLS/RTP/SAVPF 100 116 117\r\n"
"c=IN IP4 128.64.32.16\r\n"
"a=rtcp:32952 IN IP4 128.64.32.16\r\n"
"a=candidate:77142221 1 udp 2113937151 192.168.137.1 54081 typ host "
"generation 0\r\n"
"a=candidate:77142221 2 udp 2113937151 192.168.137.1 54081 typ host "
"generation 0\r\n"
"a=candidate:983072742 1 udp 2113937151 172.22.0.56 54082 typ host "
"generation 0\r\n"
"a=candidate:983072742 2 udp 2113937151 172.22.0.56 54082 typ host "
"generation 0\r\n"
"a=candidate:2245074553 1 udp 1845501695 32.64.128.1 62397 typ srflx "
"raddr 192.168.137.1 rport 54081 generation 0\r\n"
"a=candidate:2245074553 2 udp 1845501695 32.64.128.1 62397 typ srflx "
"raddr 192.168.137.1 rport 54081 generation 0\r\n"
"a=candidate:2479353907 1 udp 1845501695 32.64.128.1 54082 typ srflx "
"raddr 172.22.0.56 rport 54082 generation 0\r\n"
"a=candidate:2479353907 2 udp 1845501695 32.64.128.1 54082 typ srflx "
"raddr 172.22.0.56 rport 54082 generation 0\r\n"
"a=candidate:1243276349 1 tcp 1509957375 192.168.137.1 0 typ host "
"generation 0\r\n"
"a=candidate:1243276349 2 tcp 1509957375 192.168.137.1 0 typ host "
"generation 0\r\n"
"a=candidate:1947960086 1 tcp 1509957375 172.22.0.56 0 typ host "
"generation 0\r\n"
"a=candidate:1947960086 2 tcp 1509957375 172.22.0.56 0 typ host "
"generation 0\r\n"
"a=candidate:1808221584 1 udp 33562367 128.64.32.16 32952 typ relay "
"raddr 32.64.128.1 rport 62398 generation 0\r\n"
"a=candidate:1808221584 2 udp 33562367 128.64.32.16 32952 typ relay "
"raddr 32.64.128.1 rport 62398 generation 0\r\n"
"a=candidate:507872740 1 udp 33562367 128.64.32.16 40975 typ relay raddr "
"32.64.128.1 rport 54085 generation 0\r\n"
"a=candidate:507872740 2 udp 33562367 128.64.32.16 40975 typ relay raddr "
"32.64.128.1 rport 54085 generation 0\r\n"
"a=ice-ufrag:xQuJwjX3V3eMA81k\r\n"
"a=ice-pwd:ZUiRmjS2GDhG140p73dAsSVP\r\n"
"a=ice-options:google-ice\r\n"
"a=fingerprint:sha-256 "
"59:4A:8B:73:A7:73:53:71:88:D7:4D:58:28:0C:79:72:31:29:9B:05:37:DD:58:43:"
"C2:D4:85:A2:B3:66:38:7A\r\n"
"a=setup:active\r\n"
"a=extmap:2 urn:ietf:params:rtp-hdrext:toffset\r\n"
"a=extmap:3 "
"http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time\r\n"
"a=extmap:6 "
"http://www.webrtc.org/experiments/rtp-hdrext/playout-delay\r\n"
"a=sendrecv\r\n"
"a=mid:video\r\n"
"a=rtcp-mux\r\n"
"a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
"inline:/U44g3ULdtapeiSg+T3n6dDLBKIjpOhb/NXAL/2b\r\n"
"a=rtpmap:100 VP8/90000\r\n"
"a=rtcp-fb:100 ccm fir\r\n"
"a=rtcp-fb:100 nack\r\n"
"a=rtcp-fb:100 goog-remb\r\n"
"a=rtpmap:116 red/90000\r\n"
"a=rtpmap:117 ulpfec/90000\r\n"
"a=ssrc:54724160 cname:mKDNt7SQf6pwDlIn\r\n"
"a=ssrc:54724160 msid:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIP "
"1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIPv0\r\n"
"a=ssrc:54724160 mslabel:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIP\r\n"
"a=ssrc:54724160 label:1PBxet5BYh0oYodwsvNM4k6KiO2eWCX40VIPv0\r\n";
ParseSdp(offer);
}
TEST_P(NewSdpTest, CheckSsrcGroup) {
ParseSdp(kVideoSdp +
"a=ssrc-group:\r\n",
false);
ParseSdp(kVideoSdp +
"a=ssrc-group:BLAH\r\n",
false);
ParseSdp(kVideoSdp +
"a=ssrc-group:FID\r\n",
false);
ParseSdp(kVideoSdp +
"a=ssrc-group:FID 1 2 3 four\r\n",
false);
ParseSdp(kVideoSdp +
"a=ssrc-group:FID 1\r\n");
std::array<
char,
8192> gigantic = {{
0}};
gigantic.fill(
'A');
gigantic[gigantic.size() -
1] =
0;
ParseSdp(kVideoSdp +
"a=ssrc-group:" + gigantic.data() +
"\r\n",
false);
ParseSdp(kVideoSdp +
"a=ssrc-group:fid 1\r\n");
ParseSdp(kVideoSdp +
"a=ssrc-group:FID \r\n",
false);
ParseSdp(kVideoSdp +
"a=ssrc-group:FID 0\r\n");
ParseSdp(kVideoSdp +
"a=ssrc-group:FID 9999999999\r\n",
false);
ParseSdp(kVideoSdp +
"a=ssrc-group:FID 99999999999999999999\r\n",
false);
ParseSdp(kVideoSdp +
"a=ssrc-group:FID 1twothree\r\n",
false);
ParseSdp(kVideoSdp +
"a=ssrc-group:FID -1\r\n",
false);
ParseSdp(kVideoSdp +
"a=ssrc-group:FID 3156517279 2673335628\r\n");
ASSERT_EQ(
1U, Sdp()->GetMediaSectionCount());
const SdpSsrcGroupAttributeList& group =
Sdp()->GetMediaSection(
0).GetAttributeList().GetSsrcGroup();
ASSERT_EQ(
1U, group.mSsrcGroups.size());
ASSERT_EQ(SdpSsrcGroupAttributeList::Semantics::kFid,
group.mSsrcGroups[
0].semantics);
ASSERT_EQ(
2U, group.mSsrcGroups[
0].ssrcs.size());
ASSERT_EQ(
3156517279U, group.mSsrcGroups[
0].ssrcs[
0]);
ASSERT_EQ(
2673335628U, group.mSsrcGroups[
0].ssrcs[
1]);
}
TEST_P(NewSdpTest, CheckSsrcGroupSerialization) {
std::vector ssrcs = {
3156517279U,
2673335628U};
{
SdpSsrcGroupAttributeList list;
list.PushEntry(SdpSsrcGroupAttributeList::Semantics::kFec, ssrcs);
CheckSerialize(
"a=ssrc-group:FEC 3156517279 2673335628\r\n", list);
}
{
SdpSsrcGroupAttributeList list;
list.PushEntry(SdpSsrcGroupAttributeList::Semantics::kFid, ssrcs);
CheckSerialize(
"a=ssrc-group:FID 3156517279 2673335628\r\n", list);
}
{
SdpSsrcGroupAttributeList list;
list.PushEntry(SdpSsrcGroupAttributeList::Semantics::kFecFr, ssrcs);
CheckSerialize(
"a=ssrc-group:FEC-FR 3156517279 2673335628\r\n", list);
}
{
SdpSsrcGroupAttributeList list;
list.PushEntry(SdpSsrcGroupAttributeList::Semantics::kDup, ssrcs);
CheckSerialize(
"a=ssrc-group:DUP 3156517279 2673335628\r\n", list);
}
{
SdpSsrcGroupAttributeList list;
list.PushEntry(SdpSsrcGroupAttributeList::Semantics::kSim, ssrcs);
CheckSerialize(
"a=ssrc-group:SIM 3156517279 2673335628\r\n", list);
}
}
TEST_P(NewSdpTest, CheckRtxApt) {
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96",
false);
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=120; apt=124\r\n");
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=",
false);
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=blah",
false);
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 "
"apt=999999999999999999999999999999",
false);
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=-120\r\n",
false);
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=1twenty\r\n",
false);
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 APT=120\r\n");
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=120\r\n");
const SdpMediaSection& msec = Sdp()->GetMediaSection(
0);
ASSERT_EQ(
1U, msec.GetFormats().size());
ASSERT_EQ(
2U, msec.GetAttributeList().GetRtpmap().mRtpmaps.size());
const SdpRtpmapAttributeList::Rtpmap& rtpmap =
msec.GetAttributeList().GetRtpmap().GetEntry(
"96");
ASSERT_EQ(rtpmap.pt,
"96");
ASSERT_EQ(rtpmap.codec, SdpRtpmapAttributeList::CodecType::kRtx);
ASSERT_EQ(rtpmap.name,
"rtx");
ASSERT_EQ(rtpmap.clock,
90000U);
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
const auto& format_params = msec.GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
1U, format_params.size());
ASSERT_EQ(
"96", format_params[
0].format);
ASSERT_EQ(SdpRtpmapAttributeList::CodecType::kRtx,
format_params[
0].parameters->codec_type);
ASSERT_EQ(
static_cast<uint8_t>(
120),
static_cast<SdpFmtpAttributeList::RtxParameters*>(
format_params[
0].parameters.get())
->apt);
ASSERT_EQ(Nothing(),
static_cast<SdpFmtpAttributeList::RtxParameters*>(
format_params[
0].parameters.get())
->rtx_time);
}
TEST_P(NewSdpTest, CheckRtxAptRtxTime) {
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=120;rtx-time=",
false);
ParseSdp(
kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=120;rtx-time=blah",
false);
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 "
"apt=120;rtx-time=9999999999999999999999999999999",
false);
ParseSdp(
kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=120;rtx-time=-3000",
false);
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=120;rtx-time=3thousand",
false);
{
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=120;RTX-TIME=3000\r\n");
const SdpMediaSection& msec = Sdp()->GetMediaSection(
0);
ASSERT_EQ(
1U, msec.GetFormats().size());
ASSERT_EQ(
2U, msec.GetAttributeList().GetRtpmap().mRtpmaps.size());
const SdpRtpmapAttributeList::Rtpmap& rtpmap =
msec.GetAttributeList().GetRtpmap().GetEntry(
"96");
ASSERT_EQ(rtpmap.pt,
"96");
ASSERT_EQ(rtpmap.codec, SdpRtpmapAttributeList::CodecType::kRtx);
ASSERT_EQ(rtpmap.name,
"rtx");
ASSERT_EQ(rtpmap.clock,
90000U);
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
const auto& format_params = msec.GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
1U, format_params.size());
ASSERT_EQ(
"96", format_params[
0].format);
ASSERT_EQ(SdpRtpmapAttributeList::CodecType::kRtx,
format_params[
0].parameters->codec_type);
ASSERT_EQ(
static_cast<uint8_t>(
120),
static_cast<SdpFmtpAttributeList::RtxParameters*>(
format_params[
0].parameters.get())
->apt);
ASSERT_EQ(Some(
3000U),
static_cast<SdpFmtpAttributeList::RtxParameters*>(
format_params[
0].parameters.get())
->rtx_time);
}
{
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 "
"apt=120;rtx-time=3000;rtx-time=3300\r\n");
const SdpMediaSection& msec = Sdp()->GetMediaSection(
0);
ASSERT_EQ(
1U, msec.GetFormats().size());
ASSERT_EQ(
2U, msec.GetAttributeList().GetRtpmap().mRtpmaps.size());
const SdpRtpmapAttributeList::Rtpmap& rtpmap =
msec.GetAttributeList().GetRtpmap().GetEntry(
"96");
ASSERT_EQ(rtpmap.pt,
"96");
ASSERT_EQ(rtpmap.codec, SdpRtpmapAttributeList::CodecType::kRtx);
ASSERT_EQ(rtpmap.name,
"rtx");
ASSERT_EQ(rtpmap.clock,
90000U);
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
const auto& format_params = msec.GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
1U, format_params.size());
ASSERT_EQ(
"96", format_params[
0].format);
ASSERT_EQ(SdpRtpmapAttributeList::CodecType::kRtx,
format_params[
0].parameters->codec_type);
ASSERT_EQ(
static_cast<uint8_t>(
120),
static_cast<SdpFmtpAttributeList::RtxParameters*>(
format_params[
0].parameters.get())
->apt);
// Last rtx-time wins. This parameter is unused by our implementation
// anyway.
ASSERT_EQ(Some(
3300U),
static_cast<SdpFmtpAttributeList::RtxParameters*>(
format_params[
0].parameters.get())
->rtx_time);
}
{
ParseSdp(kVideoSdp +
"a=rtpmap:96 rtx/90000\r\na=fmtp:96 apt=120;rtx-time=3000\r\n");
const SdpMediaSection& msec = Sdp()->GetMediaSection(
0);
ASSERT_EQ(
1U, msec.GetFormats().size());
ASSERT_EQ(
2U, msec.GetAttributeList().GetRtpmap().mRtpmaps.size());
const SdpRtpmapAttributeList::Rtpmap& rtpmap =
msec.GetAttributeList().GetRtpmap().GetEntry(
"96");
ASSERT_EQ(rtpmap.pt,
"96");
ASSERT_EQ(rtpmap.codec, SdpRtpmapAttributeList::CodecType::kRtx);
ASSERT_EQ(rtpmap.name,
"rtx");
ASSERT_EQ(rtpmap.clock,
90000U);
ASSERT_TRUE(Sdp()->GetMediaSection(
0).GetAttributeList().HasAttribute(
SdpAttribute::kFmtpAttribute));
const auto& format_params = msec.GetAttributeList().GetFmtp().mFmtps;
ASSERT_EQ(
1U, format_params.size());
ASSERT_EQ(
"96", format_params[
0].format);
ASSERT_EQ(SdpRtpmapAttributeList::CodecType::kRtx,
format_params[
0].parameters->codec_type);
ASSERT_EQ(
static_cast<uint8_t>(
120),
static_cast<SdpFmtpAttributeList::RtxParameters*>(
format_params[
0].parameters.get())
->apt);
ASSERT_EQ(Some(
3000U),
static_cast<SdpFmtpAttributeList::RtxParameters*>(
format_params[
0].parameters.get())
->rtx_time);
}
}
}
// End namespace test.
