admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Making RtpSender tests cover BWE with overhead.

Browse Source 
BUG=webrtc:7418, webrtc:6315

Review-Url: https://codereview.webrtc.org/2783743003
Cr-Commit-Position: refs/heads/master@{#17499}
This commit is contained in:
minyue 2017-04-03 01:10:33 -07:00 committed by Commit bot
parent c5d62e29ca
commit 3a407eee1c
1 changed files with 96 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -132,7 +132,12 @@ class MockTransportFeedbackObserver : public TransportFeedbackObserver {
MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketFeedback>()); MOCK_CONST_METHOD0(GetTransportFeedbackVector, std::vector<PacketFeedback>());
}; };
class RtpSenderTest : public ::testing::Test { class MockOverheadObserver : public OverheadObserver {
public:
MOCK_METHOD1(OnOverheadChanged, void(size_t overhead_bytes_per_packet));
};
class RtpSenderTest : public ::testing::TestWithParam<bool> {
protected: protected:
RtpSenderTest() RtpSenderTest()
: fake_clock_(kStartTime), : fake_clock_(kStartTime),
@ -142,7 +147,9 @@ class RtpSenderTest : public ::testing::Test {
rtp_sender_(), rtp_sender_(),
payload_(kPayload), payload_(kPayload),
transport_(), transport_(),
kMarkerBit(true) {} kMarkerBit(true),
field_trials_(GetParam() ? "WebRTC-SendSideBwe-WithOverhead/Enabled/"
: "") {}
void SetUp() override { SetUpRtpSender(true); } void SetUp() override { SetUpRtpSender(true); }
@ -169,6 +176,7 @@ class RtpSenderTest : public ::testing::Test {
int payload_; int payload_;
LoopbackTransportTest transport_; LoopbackTransportTest transport_;
const bool kMarkerBit; const bool kMarkerBit;
test::ScopedFieldTrials field_trials_;
void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) { void VerifyRTPHeaderCommon(const RTPHeader& rtp_header) {
VerifyRTPHeaderCommon(rtp_header, kMarkerBit, 0); VerifyRTPHeaderCommon(rtp_header, kMarkerBit, 0);
@ -247,7 +255,7 @@ class RtpSenderVideoTest : public RtpSenderTest {
std::unique_ptr<RTPSenderVideo> rtp_sender_video_; std::unique_ptr<RTPSenderVideo> rtp_sender_video_;
}; };
TEST_F(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) { TEST_P(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) {
// Configure rtp_sender with csrc. // Configure rtp_sender with csrc.
std::vector<uint32_t> csrcs; std::vector<uint32_t> csrcs;
csrcs.push_back(0x23456789); csrcs.push_back(0x23456789);
@ -260,7 +268,7 @@ TEST_F(RtpSenderTestWithoutPacer, AllocatePacketSetCsrc) {
EXPECT_EQ(csrcs, packet->Csrcs()); EXPECT_EQ(csrcs, packet->Csrcs());
} }
TEST_F(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) { TEST_P(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
// Configure rtp_sender with extensions. // Configure rtp_sender with extensions.
ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( ASSERT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransmissionTimeOffset, kRtpExtensionTransmissionTimeOffset,
@ -288,7 +296,7 @@ TEST_F(RtpSenderTestWithoutPacer, AllocatePacketReserveExtensions) {
EXPECT_FALSE(packet->HasExtension<VideoOrientation>()); EXPECT_FALSE(packet->HasExtension<VideoOrientation>());
} }
TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberAdvanceSequenceNumber) { TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberAdvanceSequenceNumber) {
auto packet = rtp_sender_->AllocatePacket(); auto packet = rtp_sender_->AllocatePacket();
ASSERT_TRUE(packet); ASSERT_TRUE(packet);
const uint16_t sequence_number = rtp_sender_->SequenceNumber(); const uint16_t sequence_number = rtp_sender_->SequenceNumber();
@ -299,7 +307,7 @@ TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberAdvanceSequenceNumber) {
EXPECT_EQ(sequence_number + 1, rtp_sender_->SequenceNumber()); EXPECT_EQ(sequence_number + 1, rtp_sender_->SequenceNumber());
} }
TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberFailsOnNotSending) { TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberFailsOnNotSending) {
auto packet = rtp_sender_->AllocatePacket(); auto packet = rtp_sender_->AllocatePacket();
ASSERT_TRUE(packet); ASSERT_TRUE(packet);
@ -307,7 +315,7 @@ TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberFailsOnNotSending) {
EXPECT_FALSE(rtp_sender_->AssignSequenceNumber(packet.get())); EXPECT_FALSE(rtp_sender_->AssignSequenceNumber(packet.get()));
} }
TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPadding) { TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPadding) {
constexpr size_t kPaddingSize = 100; constexpr size_t kPaddingSize = 100;
auto packet = rtp_sender_->AllocatePacket(); auto packet = rtp_sender_->AllocatePacket();
ASSERT_TRUE(packet); ASSERT_TRUE(packet);
@ -324,7 +332,7 @@ TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberMayAllowPadding) {
EXPECT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo())); EXPECT_TRUE(rtp_sender_->TimeToSendPadding(kPaddingSize, PacedPacketInfo()));
} }
TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) { TEST_P(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) {
constexpr size_t kPaddingSize = 100; constexpr size_t kPaddingSize = 100;
auto packet = rtp_sender_->AllocatePacket(); auto packet = rtp_sender_->AllocatePacket();
ASSERT_TRUE(packet); ASSERT_TRUE(packet);
@ -339,7 +347,37 @@ TEST_F(RtpSenderTestWithoutPacer, AssignSequenceNumberSetPaddingTimestamps) {
EXPECT_EQ(kTimestamp, transport_.last_sent_packet().Timestamp()); EXPECT_EQ(kTimestamp, transport_.last_sent_packet().Timestamp());
} }
TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) { TEST_P(RtpSenderTestWithoutPacer,
TransportFeedbackObserverGetsCorrectByteCount) {
constexpr int kRtpOverheadBytesPerPacket = 12 + 8;
testing::NiceMock<MockOverheadObserver> mock_overhead_observer;
rtp_sender_.reset(new RTPSender(
false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
&feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
nullptr, &retransmission_rate_limiter_, &mock_overhead_observer));
rtp_sender_->SetSSRC(kSsrc);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId));
EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
.WillOnce(testing::Return(kTransportSequenceNumber));
const size_t expected_bytes =
GetParam() ? sizeof(kPayloadData) + kGenericHeaderLength +
kRtpOverheadBytesPerPacket
: sizeof(kPayloadData) + kGenericHeaderLength;
EXPECT_CALL(feedback_observer_,
AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber,
expected_bytes, PacedPacketInfo()))
.Times(1);
EXPECT_CALL(mock_overhead_observer,
OnOverheadChanged(kRtpOverheadBytesPerPacket))
.Times(1);
SendGenericPayload();
}
TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
rtp_sender_.reset(new RTPSender( rtp_sender_.reset(new RTPSender(
false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_, false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
&feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_, &feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
@ -354,10 +392,10 @@ TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
EXPECT_CALL(send_packet_observer_, EXPECT_CALL(send_packet_observer_,
OnSendPacket(kTransportSequenceNumber, _, _)) OnSendPacket(kTransportSequenceNumber, _, _))
.Times(1); .Times(1);
EXPECT_CALL(
feedback_observer_, EXPECT_CALL(feedback_observer_,
AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber, AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber, _,
sizeof(kPayloadData) + kGenericHeaderLength, PacedPacketInfo())) PacedPacketInfo()))
.Times(1); .Times(1);
SendGenericPayload(); SendGenericPayload();
@ -369,11 +407,11 @@ TEST_F(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
EXPECT_EQ(transport_.last_packet_id_, transport_seq_no); EXPECT_EQ(transport_.last_packet_id_, transport_seq_no);
} }
TEST_F(RtpSenderTestWithoutPacer, NoAllocationIfNotRegistered) { TEST_P(RtpSenderTestWithoutPacer, NoAllocationIfNotRegistered) {
SendGenericPayload(); SendGenericPayload();
} }
TEST_F(RtpSenderTestWithoutPacer, OnSendPacketUpdated) { TEST_P(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId)); kTransportSequenceNumberExtensionId));
@ -386,7 +424,7 @@ TEST_F(RtpSenderTestWithoutPacer, OnSendPacketUpdated) {
SendGenericPayload(); SendGenericPayload();
} }
TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) { TEST_P(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
rtp_sender_.reset(new RTPSender( rtp_sender_.reset(new RTPSender(
false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr, false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
&seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr, &seq_num_allocator_, &feedback_observer_, nullptr, nullptr, nullptr,
@ -405,10 +443,9 @@ TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
EXPECT_CALL(send_packet_observer_, EXPECT_CALL(send_packet_observer_,
OnSendPacket(kTransportSequenceNumber, _, _)) OnSendPacket(kTransportSequenceNumber, _, _))
.Times(1); .Times(1);
EXPECT_CALL( EXPECT_CALL(feedback_observer_,
feedback_observer_, AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber, _,
AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber, PacedPacketInfo()))
sizeof(kPayloadData) + kGenericHeaderLength, PacedPacketInfo()))
.Times(1); .Times(1);
SendGenericPayload(); SendGenericPayload();
@ -423,7 +460,7 @@ TEST_F(RtpSenderTest, SendsPacketsWithTransportSequenceNumber) {
EXPECT_EQ(transport_.last_packet_id_, transport_seq_no); EXPECT_EQ(transport_.last_packet_id_, transport_seq_no);
} }
TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) { TEST_P(RtpSenderTest, TrafficSmoothingWithExtensions) {
EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
kSsrc, kSeqNum, _, _, _)); kSsrc, kSeqNum, _, _, _));
EXPECT_CALL(mock_rtc_event_log_, EXPECT_CALL(mock_rtc_event_log_,
@ -468,7 +505,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingWithExtensions) {
EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
} }
TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) { TEST_P(RtpSenderTest, TrafficSmoothingRetransmits) {
EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
kSsrc, kSeqNum, _, _, _)); kSsrc, kSeqNum, _, _, _));
EXPECT_CALL(mock_rtc_event_log_, EXPECT_CALL(mock_rtc_event_log_,
@ -521,7 +558,7 @@ TEST_F(RtpSenderTest, TrafficSmoothingRetransmits) {
// This test sends 1 regular video packet, then 4 padding packets, and then // This test sends 1 regular video packet, then 4 padding packets, and then
// 1 more regular packet. // 1 more regular packet.
TEST_F(RtpSenderTest, SendPadding) { TEST_P(RtpSenderTest, SendPadding) {
// Make all (non-padding) packets go to send queue. // Make all (non-padding) packets go to send queue.
EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority, EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
kSsrc, kSeqNum, _, _, _)); kSsrc, kSeqNum, _, _, _));
@ -629,7 +666,7 @@ TEST_F(RtpSenderTest, SendPadding) {
EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime); EXPECT_EQ(expected_send_time, rtp_header.extension.absoluteSendTime);
} }
TEST_F(RtpSenderTest, OnSendPacketUpdated) { TEST_P(RtpSenderTest, OnSendPacketUpdated) {
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId)); kTransportSequenceNumberExtensionId));
@ -651,7 +688,7 @@ TEST_F(RtpSenderTest, OnSendPacketUpdated) {
EXPECT_EQ(1, transport_.packets_sent()); EXPECT_EQ(1, transport_.packets_sent());
} }
TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) { TEST_P(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber, kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId)); kTransportSequenceNumberExtensionId));
@ -671,7 +708,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedForRetransmits) {
EXPECT_EQ(1, transport_.packets_sent()); EXPECT_EQ(1, transport_.packets_sent());
} }
TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) { TEST_P(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
rtp_sender_.reset(new RTPSender( rtp_sender_.reset(new RTPSender(
false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr, false, &fake_clock_, &transport_, &mock_paced_sender_, nullptr,
nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr, nullptr /* TransportSequenceNumberAllocator */, nullptr, nullptr, nullptr,
@ -697,7 +734,7 @@ TEST_F(RtpSenderTest, OnSendPacketNotUpdatedWithoutSeqNumAllocator) {
EXPECT_EQ(1, transport_.packets_sent()); EXPECT_EQ(1, transport_.packets_sent());
} }
TEST_F(RtpSenderTest, SendRedundantPayloads) { TEST_P(RtpSenderTest, SendRedundantPayloads) {
MockTransport transport; MockTransport transport;
rtp_sender_.reset(new RTPSender( rtp_sender_.reset(new RTPSender(
false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr, false, &fake_clock_, &transport, &mock_paced_sender_, nullptr, nullptr,
@ -766,7 +803,7 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
rtp_sender_->TimeToSendPadding(999, PacedPacketInfo())); rtp_sender_->TimeToSendPadding(999, PacedPacketInfo()));
} }
TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) { TEST_P(RtpSenderTestWithoutPacer, SendGenericVideo) {
char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC"; char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
const uint8_t payload_type = 127; const uint8_t payload_type = 127;
ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000, ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
@ -800,7 +837,7 @@ TEST_F(RtpSenderTestWithoutPacer, SendGenericVideo) {
EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(payload)); EXPECT_THAT(sent_payload.subview(1), ElementsAreArray(payload));
} }
TEST_F(RtpSenderTest, SendFlexfecPackets) { TEST_P(RtpSenderTest, SendFlexfecPackets) {
constexpr int kMediaPayloadType = 127; constexpr int kMediaPayloadType = 127;
constexpr int kFlexfecPayloadType = 118; constexpr int kFlexfecPayloadType = 118;
constexpr uint32_t kMediaSsrc = 1234; constexpr uint32_t kMediaSsrc = 1234;
@ -855,7 +892,7 @@ TEST_F(RtpSenderTest, SendFlexfecPackets) {
EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc()); EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
} }
TEST_F(RtpSenderTestWithoutPacer, SendFlexfecPackets) { TEST_P(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
constexpr int kMediaPayloadType = 127; constexpr int kMediaPayloadType = 127;
constexpr int kFlexfecPayloadType = 118; constexpr int kFlexfecPayloadType = 118;
constexpr uint32_t kMediaSsrc = 1234; constexpr uint32_t kMediaSsrc = 1234;
@ -894,7 +931,7 @@ TEST_F(RtpSenderTestWithoutPacer, SendFlexfecPackets) {
EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc()); EXPECT_EQ(kFlexfecSsrc, flexfec_packet.Ssrc());
} }
TEST_F(RtpSenderTest, FecOverheadRate) { TEST_P(RtpSenderTest, FecOverheadRate) {
constexpr int kMediaPayloadType = 127; constexpr int kMediaPayloadType = 127;
constexpr int kFlexfecPayloadType = 118; constexpr int kFlexfecPayloadType = 118;
constexpr uint32_t kMediaSsrc = 1234; constexpr uint32_t kMediaSsrc = 1234;
@ -940,7 +977,7 @@ TEST_F(RtpSenderTest, FecOverheadRate) {
rtp_sender_->FecOverheadRate(), 500); rtp_sender_->FecOverheadRate(), 500);
} }
TEST_F(RtpSenderTest, FrameCountCallbacks) { TEST_P(RtpSenderTest, FrameCountCallbacks) {
class TestCallback : public FrameCountObserver { class TestCallback : public FrameCountObserver {
public: public:
TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {} TestCallback() : FrameCountObserver(), num_calls_(0), ssrc_(0) {}
@ -995,7 +1032,7 @@ TEST_F(RtpSenderTest, FrameCountCallbacks) {
rtp_sender_.reset(); rtp_sender_.reset();
} }
TEST_F(RtpSenderTest, BitrateCallbacks) { TEST_P(RtpSenderTest, BitrateCallbacks) {
class TestCallback : public BitrateStatisticsObserver { class TestCallback : public BitrateStatisticsObserver {
public: public:
TestCallback() TestCallback()
@ -1088,7 +1125,7 @@ class RtpSenderAudioTest : public RtpSenderTest {
} }
}; };
TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) { TEST_P(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
class TestCallback : public StreamDataCountersCallback { class TestCallback : public StreamDataCountersCallback {
public: public:
TestCallback() : StreamDataCountersCallback(), ssrc_(0), counters_() {} TestCallback() : StreamDataCountersCallback(), ssrc_(0), counters_() {}
@ -1186,7 +1223,7 @@ TEST_F(RtpSenderTestWithoutPacer, StreamDataCountersCallbacks) {
rtp_sender_->RegisterRtpStatisticsCallback(nullptr); rtp_sender_->RegisterRtpStatisticsCallback(nullptr);
} }
TEST_F(RtpSenderAudioTest, SendAudio) { TEST_P(RtpSenderAudioTest, SendAudio) {
char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME"; char payload_name[RTP_PAYLOAD_NAME_SIZE] = "PAYLOAD_NAME";
const uint8_t payload_type = 127; const uint8_t payload_type = 127;
ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000, ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 48000,
@ -1201,7 +1238,7 @@ TEST_F(RtpSenderAudioTest, SendAudio) {
EXPECT_THAT(sent_payload, ElementsAreArray(payload)); EXPECT_THAT(sent_payload, ElementsAreArray(payload));
} }
TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) { TEST_P(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel)); EXPECT_EQ(0, rtp_sender_->SetAudioLevel(kAudioLevel));
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel, EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
kAudioLevelExtensionId)); kAudioLevelExtensionId));
@ -1233,7 +1270,7 @@ TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
// This test checks the marker bit for the first packet and the consequent // This test checks the marker bit for the first packet and the consequent
// packets of the same telephone event. Since it is specifically for DTMF // packets of the same telephone event. Since it is specifically for DTMF
// events, ignoring audio packets and sending kEmptyFrame instead of those. // events, ignoring audio packets and sending kEmptyFrame instead of those.
TEST_F(RtpSenderAudioTest, CheckMarkerBitForTelephoneEvents) { TEST_P(RtpSenderAudioTest, CheckMarkerBitForTelephoneEvents) {
const char* kDtmfPayloadName = "telephone-event"; const char* kDtmfPayloadName = "telephone-event";
const uint32_t kPayloadFrequency = 8000; const uint32_t kPayloadFrequency = 8000;
const uint8_t kPayloadType = 126; const uint8_t kPayloadType = 126;
@ -1271,7 +1308,7 @@ TEST_F(RtpSenderAudioTest, CheckMarkerBitForTelephoneEvents) {
EXPECT_FALSE(transport_.last_sent_packet().Marker()); EXPECT_FALSE(transport_.last_sent_packet().Marker());
} }
TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) { TEST_P(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
const char* kPayloadName = "GENERIC"; const char* kPayloadName = "GENERIC";
const uint8_t kPayloadType = 127; const uint8_t kPayloadType = 127;
rtp_sender_->SetSSRC(1234); rtp_sender_->SetSSRC(1234);
@ -1318,7 +1355,7 @@ TEST_F(RtpSenderTestWithoutPacer, BytesReportedCorrectly) {
rtp_stats.transmitted.TotalBytes() + rtx_stats.transmitted.TotalBytes()); rtp_stats.transmitted.TotalBytes() + rtx_stats.transmitted.TotalBytes());
} }
TEST_F(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) { TEST_P(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
const int32_t kPacketSize = 1400; const int32_t kPacketSize = 1400;
const int32_t kNumPackets = 30; const int32_t kNumPackets = 30;
@ -1350,7 +1387,7 @@ TEST_F(RtpSenderTestWithoutPacer, RespectsNackBitrateLimit) {
EXPECT_EQ(kNumPackets * 2, transport_.packets_sent()); EXPECT_EQ(kNumPackets * 2, transport_.packets_sent());
} }
TEST_F(RtpSenderVideoTest, KeyFrameHasCVO) { TEST_P(RtpSenderVideoTest, KeyFrameHasCVO) {
uint8_t kFrame[kMaxPacketLength]; uint8_t kFrame[kMaxPacketLength];
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, kVideoRotationExtensionId)); kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@ -1367,7 +1404,7 @@ TEST_F(RtpSenderVideoTest, KeyFrameHasCVO) {
EXPECT_EQ(kVideoRotation_0, rotation); EXPECT_EQ(kVideoRotation_0, rotation);
} }
TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) { TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
uint8_t kFrame[kMaxPacketLength]; uint8_t kFrame[kMaxPacketLength];
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, kVideoRotationExtensionId)); kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@ -1389,7 +1426,7 @@ TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
EXPECT_EQ(kVideoRotation_0, rotation); EXPECT_EQ(kVideoRotation_0, rotation);
} }
TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) { TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
uint8_t kFrame[kMaxPacketLength]; uint8_t kFrame[kMaxPacketLength];
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension( EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, kVideoRotationExtensionId)); kRtpExtensionVideoRotation, kVideoRotationExtensionId));
@ -1412,7 +1449,7 @@ TEST_F(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
// Make sure rotation is parsed correctly when the Camera (C) and Flip (F) bits // Make sure rotation is parsed correctly when the Camera (C) and Flip (F) bits
// are set in the CVO byte. // are set in the CVO byte.
TEST_F(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) { TEST_P(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) {
// Test extracting rotation when Camera (C) and Flip (F) bits are zero. // Test extracting rotation when Camera (C) and Flip (F) bits are zero.
EXPECT_EQ(kVideoRotation_0, ConvertCVOByteToVideoRotation(0)); EXPECT_EQ(kVideoRotation_0, ConvertCVOByteToVideoRotation(0));
EXPECT_EQ(kVideoRotation_90, ConvertCVOByteToVideoRotation(1)); EXPECT_EQ(kVideoRotation_90, ConvertCVOByteToVideoRotation(1));
@ -1431,14 +1468,7 @@ TEST_F(RtpSenderVideoTest, SendVideoWithCameraAndFlipCVO) {
ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3)); ConvertCVOByteToVideoRotation(flip_bit | camera_bit | 3));
} }
namespace { TEST_P(RtpSenderTest, OnOverheadChanged) {
class MockOverheadObserver : public OverheadObserver {
public:
MOCK_METHOD1(OnOverheadChanged, void(size_t overhead_bytes_per_packet));
};
} // namespace
TEST_F(RtpSenderTest, OnOverheadChanged) {
MockOverheadObserver mock_overhead_observer; MockOverheadObserver mock_overhead_observer;
rtp_sender_.reset( rtp_sender_.reset(
new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
@ -1459,7 +1489,7 @@ TEST_F(RtpSenderTest, OnOverheadChanged) {
SendGenericPayload(); SendGenericPayload();
} }
TEST_F(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) { TEST_P(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
MockOverheadObserver mock_overhead_observer; MockOverheadObserver mock_overhead_observer;
rtp_sender_.reset( rtp_sender_.reset(
new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr, new RTPSender(false, &fake_clock_, &transport_, nullptr, nullptr, nullptr,
@ -1472,34 +1502,7 @@ TEST_F(RtpSenderTest, DoesNotUpdateOverheadOnEqualSize) {
SendGenericPayload(); SendGenericPayload();
} }
TEST_F(RtpSenderTest, AddOverheadToTransportFeedbackObserver) { TEST_P(RtpSenderTest, SendAudioPadding) {
constexpr int kRtpOverheadBytesPerPacket = 12 + 8;
test::ScopedFieldTrials override_field_trials(
"WebRTC-SendSideBwe-WithOverhead/Enabled/");
testing::NiceMock<MockOverheadObserver> mock_overhead_observer;
rtp_sender_.reset(new RTPSender(
false, &fake_clock_, &transport_, nullptr, nullptr, &seq_num_allocator_,
&feedback_observer_, nullptr, nullptr, nullptr, &mock_rtc_event_log_,
nullptr, &retransmission_rate_limiter_, &mock_overhead_observer));
rtp_sender_->SetSSRC(kSsrc);
EXPECT_EQ(0, rtp_sender_->RegisterRtpHeaderExtension(
kRtpExtensionTransportSequenceNumber,
kTransportSequenceNumberExtensionId));
EXPECT_CALL(seq_num_allocator_, AllocateSequenceNumber())
.WillOnce(testing::Return(kTransportSequenceNumber));
EXPECT_CALL(feedback_observer_,
AddPacket(rtp_sender_->SSRC(), kTransportSequenceNumber,
sizeof(kPayloadData) + kGenericHeaderLength +
kRtpOverheadBytesPerPacket,
PacedPacketInfo()))
.Times(1);
EXPECT_CALL(mock_overhead_observer,
OnOverheadChanged(kRtpOverheadBytesPerPacket))
.Times(1);
SendGenericPayload();
}
TEST_F(RtpSenderTest, SendAudioPadding) {
MockTransport transport; MockTransport transport;
const bool kEnableAudio = true; const bool kEnableAudio = true;
rtp_sender_.reset(new RTPSender( rtp_sender_.reset(new RTPSender(
@ -1525,4 +1528,17 @@ TEST_F(RtpSenderTest, SendAudioPadding) {
kMinPaddingSize, kMinPaddingSize,
rtp_sender_->TimeToSendPadding(kMinPaddingSize - 5, PacedPacketInfo())); rtp_sender_->TimeToSendPadding(kMinPaddingSize - 5, PacedPacketInfo()));
} }
INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
RtpSenderTest,
::testing::Bool());
INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
RtpSenderTestWithoutPacer,
::testing::Bool());
INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
RtpSenderVideoTest,
::testing::Bool());
INSTANTIATE_TEST_CASE_P(WithAndWithoutOverhead,
RtpSenderAudioTest,
::testing::Bool());
} // namespace webrtc } // namespace webrtc