src/third_party/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc

   1 /*
   2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 #include "webrtc/common_types.h"
  15 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
  16 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
  17
  18 namespace webrtc {
  19 namespace {
  20 const uint32_t kSenderSsrc = 0x12345;
  21 const uint32_t kReceiverSsrc = 0x23456;
  22 const uint32_t kOneWayNetworkDelayMs = 100;
  23
  24 class RtcpRttStatsTestImpl : public RtcpRttStats {
  25  public:
  26   RtcpRttStatsTestImpl() : rtt_ms_(0) {}
  27   virtual ~RtcpRttStatsTestImpl() {}
  28
  29   virtual void OnRttUpdate(uint32_t rtt_ms) {
  30     rtt_ms_ = rtt_ms;
  31   }
  32   virtual uint32_t LastProcessedRtt() const {
  33     return rtt_ms_;
  34   }
  35   uint32_t rtt_ms_;
  36 };
  37
  38 class SendTransport : public Transport,
  39                       public NullRtpData {
  40  public:
  41   SendTransport() : receiver_(NULL), clock_(NULL), delay_ms_(0) {}
  42
  43   void SetRtpRtcpModule(ModuleRtpRtcpImpl* receiver) {
  44     receiver_ = receiver;
  45   }
  46   void SimulateNetworkDelay(uint32_t delay_ms, SimulatedClock* clock) {
  47     clock_ = clock;
  48     delay_ms_ = delay_ms;
  49   }
  50   virtual int SendPacket(int /*ch*/, const void* /*data*/, int /*len*/) {
  51     return -1;
  52   }
  53   virtual int SendRTCPPacket(int /*ch*/, const void *data, int len) {
  54     if (clock_) {
  55       clock_->AdvanceTimeMilliseconds(delay_ms_);
  56     }
  57     EXPECT_TRUE(receiver_ != NULL);
  58     EXPECT_EQ(0, receiver_->IncomingRtcpPacket(
  59         static_cast<const uint8_t*>(data), len));
  60     return len;
  61   }
  62   ModuleRtpRtcpImpl* receiver_;
  63   SimulatedClock* clock_;
  64   uint32_t delay_ms_;
  65 };
  66
  67 class RtpRtcpModule {
  68  public:
  69   RtpRtcpModule(SimulatedClock* clock)
  70       : receive_statistics_(ReceiveStatistics::Create(clock)) {
  71     RtpRtcp::Configuration config;
  72     config.audio = false;
  73     config.clock = clock;
  74     config.outgoing_transport = &transport_;
  75     config.receive_statistics = receive_statistics_.get();
  76     config.rtt_stats = &rtt_stats_;
  77
  78     impl_.reset(new ModuleRtpRtcpImpl(config));
  79     EXPECT_EQ(0, impl_->SetRTCPStatus(kRtcpCompound));
  80
  81     transport_.SimulateNetworkDelay(kOneWayNetworkDelayMs, clock);
  82   }
  83   scoped_ptr<ReceiveStatistics> receive_statistics_;
  84   SendTransport transport_;
  85   RtcpRttStatsTestImpl rtt_stats_;
  86   scoped_ptr<ModuleRtpRtcpImpl> impl_;
  87 };
  88 }  // namespace
  89
  90 class RtpRtcpImplTest : public ::testing::Test {
  91  protected:
  92   RtpRtcpImplTest()
  93       : clock_(1335900000),
  94         sender_(&clock_),
  95         receiver_(&clock_) {
  96     // Send module.
  97     EXPECT_EQ(0, sender_.impl_->SetSendingStatus(true));
  98     EXPECT_EQ(0, sender_.impl_->SetSSRC(kSenderSsrc));
  99     sender_.impl_->SetRemoteSSRC(kReceiverSsrc);
 100     // Receive module.
 101     EXPECT_EQ(0, receiver_.impl_->SetSendingStatus(false));
 102     EXPECT_EQ(0, receiver_.impl_->SetSSRC(kReceiverSsrc));
 103     receiver_.impl_->SetRemoteSSRC(kSenderSsrc);
 104     // Transport settings.
 105     sender_.transport_.SetRtpRtcpModule(receiver_.impl_.get());
 106     receiver_.transport_.SetRtpRtcpModule(sender_.impl_.get());
 107   }
 108   SimulatedClock clock_;
 109   RtpRtcpModule sender_;
 110   RtpRtcpModule receiver_;
 111 };
 112
 113 TEST_F(RtpRtcpImplTest, Rtt) {
 114   RTPHeader header = {};
 115   header.timestamp = 1;
 116   header.sequenceNumber = 123;
 117   header.ssrc = kSenderSsrc;
 118   header.headerLength = 12;
 119   receiver_.receive_statistics_->IncomingPacket(header, 100, false);
 120
 121   // Sender module should send a SR.
 122   EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
 123
 124   // Receiver module should send a RR with a response to the last received SR.
 125   clock_.AdvanceTimeMilliseconds(1000);
 126   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
 127
 128   // Verify RTT.
 129   uint16_t rtt;
 130   uint16_t avg_rtt;
 131   uint16_t min_rtt;
 132   uint16_t max_rtt;
 133   EXPECT_EQ(0,
 134       sender_.impl_->RTT(kReceiverSsrc, &rtt, &avg_rtt, &min_rtt, &max_rtt));
 135   EXPECT_EQ(2 * kOneWayNetworkDelayMs, rtt);
 136   EXPECT_EQ(2 * kOneWayNetworkDelayMs, avg_rtt);
 137   EXPECT_EQ(2 * kOneWayNetworkDelayMs, min_rtt);
 138   EXPECT_EQ(2 * kOneWayNetworkDelayMs, max_rtt);
 139
 140   // No RTT from other ssrc.
 141   EXPECT_EQ(-1,
 142       sender_.impl_->RTT(kReceiverSsrc+1, &rtt, &avg_rtt, &min_rtt, &max_rtt));
 143
 144   // Verify RTT from rtt_stats config.
 145   EXPECT_EQ(0U, sender_.rtt_stats_.LastProcessedRtt());
 146   EXPECT_EQ(0U, sender_.impl_->rtt_ms());
 147   sender_.impl_->Process();
 148   EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.rtt_stats_.LastProcessedRtt());
 149   EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.impl_->rtt_ms());
 150 }
 151
 152 TEST_F(RtpRtcpImplTest, SetRtcpXrRrtrStatus) {
 153   EXPECT_FALSE(receiver_.impl_->RtcpXrRrtrStatus());
 154   receiver_.impl_->SetRtcpXrRrtrStatus(true);
 155   EXPECT_TRUE(receiver_.impl_->RtcpXrRrtrStatus());
 156 }
 157
 158 TEST_F(RtpRtcpImplTest, RttForReceiverOnly) {
 159   receiver_.impl_->SetRtcpXrRrtrStatus(true);
 160
 161   // Receiver module should send a Receiver time reference report (RTRR).
 162   EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
 163
 164   // Sender module should send a response to the last received RTRR (DLRR).
 165   clock_.AdvanceTimeMilliseconds(1000);
 166   EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
 167
 168   // Verify RTT.
 169   EXPECT_EQ(0U, receiver_.rtt_stats_.LastProcessedRtt());
 170   EXPECT_EQ(0U, receiver_.impl_->rtt_ms());
 171   receiver_.impl_->Process();
 172   EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.rtt_stats_.LastProcessedRtt());
 173   EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.impl_->rtt_ms());
 174 }
 175 }  // namespace webrtc