Validates sending RTCP before RTP.

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc

 /*
  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 279 matching lines @@
 }
 
 TEST_F(RtpRtcpImplTest, Rtt) {
   RTPHeader header;
   header.timestamp = 1;
   header.sequenceNumber = 123;
   header.ssrc = kSenderSsrc;
   header.headerLength = 12;
   receiver_.receive_statistics_->IncomingPacket(header, 100, false);
 
+  // Send Frame before sending a SR.

[stefan-webrtc, 2016/07/20 09:13:31]

super nit: it should be "an SR", I think

[danilchap, 2016/07/20 10:09:49]

Done.

+  SendFrame(&sender_, kBaseLayerTid);
   // Sender module should send a SR.
   EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
 
   // Receiver module should send a RR with a response to the last received SR.
   clock_.AdvanceTimeMilliseconds(1000);
   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
 
   // Verify RTT.
   int64_t rtt;
   int64_t avg_rtt;
@@ skipping 26 matching lines @@
 }
 
 TEST_F(RtpRtcpImplTest, RttForReceiverOnly) {
   receiver_.impl_->SetRtcpXrRrtrStatus(true);
 
   // Receiver module should send a Receiver time reference report (RTRR).
   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
 
   // Sender module should send a response to the last received RTRR (DLRR).
   clock_.AdvanceTimeMilliseconds(1000);
+  // Send Frame before sending a SR.
+  SendFrame(&sender_, kBaseLayerTid);
   EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
 
   // Verify RTT.
   EXPECT_EQ(0, receiver_.rtt_stats_.LastProcessedRtt());
   EXPECT_EQ(0, receiver_.impl_->rtt_ms());
   receiver_.impl_->Process();
   EXPECT_NEAR(2 * kOneWayNetworkDelayMs,
               receiver_.rtt_stats_.LastProcessedRtt(), 1);
   EXPECT_NEAR(2 * kOneWayNetworkDelayMs, receiver_.impl_->rtt_ms(), 1);
 }
@@ skipping 99 matching lines @@
   rtp3.first_packet_time_ms = kStartTimeMs + 10;
   sum.Add(rtp3);
   EXPECT_EQ(kStartTimeMs, sum.first_packet_time_ms);  // Holds oldest time.
 }
 
 TEST_F(RtpRtcpImplTest, SendsInitialNackList) {
   // Send module sends a NACK.
   const uint16_t kNackLength = 1;
   uint16_t nack_list[kNackLength] = {123};
   EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
+  // Send Frame before sending a compound RTCP that starts with SR.
+  SendFrame(&sender_, kBaseLayerTid);
   EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
   EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
   EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
 }
 
 TEST_F(RtpRtcpImplTest, SendsExtendedNackList) {
   // Send module sends a NACK.
   const uint16_t kNackLength = 1;
   uint16_t nack_list[kNackLength] = {123};
   EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
+  // Send Frame before sending a compound RTCP that starts with SR.
+  SendFrame(&sender_, kBaseLayerTid);
   EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
   EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
   EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
 
   // Same list not re-send.
   EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
   EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
   EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
 
   // Only extended list sent.
   const uint16_t kNackExtLength = 2;
   uint16_t nack_list_ext[kNackExtLength] = {123, 124};
   EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list_ext, kNackExtLength));
   EXPECT_EQ(2U, sender_.RtcpSent().nack_packets);
   EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(124));
 }
 
 TEST_F(RtpRtcpImplTest, ReSendsNackListAfterRttMs) {
   sender_.transport_.SimulateNetworkDelay(0, &clock_);
   // Send module sends a NACK.
   const uint16_t kNackLength = 2;
   uint16_t nack_list[kNackLength] = {123, 125};
   EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
+  // Send Frame before sending a compound RTCP that starts with SR.
+  SendFrame(&sender_, kBaseLayerTid);
   EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
   EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
   EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123, 125));
 
   // Same list not re-send, rtt interval has not passed.
   const int kStartupRttMs = 100;
   clock_.AdvanceTimeMilliseconds(kStartupRttMs);
   EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
   EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
 
@@ skipping 37 matching lines @@
   EXPECT_EQ(6U, receiver_.RtcpSent().unique_nack_requests);
   EXPECT_THAT(receiver_.LastNackListSent(), ElementsAre(11, 18, 20, 21));
 
   // Send module receives the request.
   EXPECT_EQ(2U, sender_.RtcpReceived().nack_packets);
   EXPECT_EQ(8U, sender_.RtcpReceived().nack_requests);
   EXPECT_EQ(6U, sender_.RtcpReceived().unique_nack_requests);
   EXPECT_EQ(75, sender_.RtcpReceived().UniqueNackRequestsInPercent());
 }
 }  // namespace webrtc