src/media/cast/rtcp/rtcp_sender_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "media/cast/cast_defines.h"
   7 #include "media/cast/pacing/paced_sender.h"
   8 #include "media/cast/rtcp/rtcp_sender.h"
   9 #include "media/cast/rtcp/test_rtcp_packet_builder.h"
  10 #include "testing/gmock/include/gmock/gmock.h"
  11
  12 namespace media {
  13 namespace cast {
  14
  15 static const uint32 kSendingSsrc = 0x12345678;
  16 static const uint32 kMediaSsrc = 0x87654321;
  17 static const std::string kCName("test@10.1.1.1");
  18
  19 class TestRtcpTransport : public PacedPacketSender {
  20  public:
  21   TestRtcpTransport()
  22       : expected_packet_length_(0),
  23         packet_count_(0) {
  24   }
  25
  26   virtual bool SendRtcpPacket(const Packet& packet) OVERRIDE {
  27     EXPECT_EQ(expected_packet_length_, packet.size());
  28     EXPECT_EQ(0, memcmp(expected_packet_, &(packet[0]), packet.size()));
  29     packet_count_++;
  30     return true;
  31   }
  32
  33   virtual bool SendPackets(const PacketList& packets) OVERRIDE {
  34     return false;
  35   }
  36
  37   virtual bool ResendPackets(const PacketList& packets) OVERRIDE {
  38     return false;
  39   }
  40
  41   void SetExpectedRtcpPacket(const uint8* rtcp_buffer, size_t length) {
  42     expected_packet_length_ = length;
  43     memcpy(expected_packet_, rtcp_buffer, length);
  44   }
  45
  46   int packet_count() { return packet_count_; }
  47
  48  private:
  49   uint8 expected_packet_[kIpPacketSize];
  50   size_t expected_packet_length_;
  51   int packet_count_;
  52 };
  53
  54 class RtcpSenderTest : public ::testing::Test {
  55  protected:
  56   RtcpSenderTest()
  57       : rtcp_sender_(new RtcpSender(&test_transport_,
  58                                     kSendingSsrc,
  59                                     kCName)) {
  60   }
  61
  62   TestRtcpTransport test_transport_;
  63   scoped_ptr<RtcpSender> rtcp_sender_;
  64 };
  65
  66 TEST_F(RtcpSenderTest, RtcpSenderReport) {
  67   RtcpSenderInfo sender_info;
  68   sender_info.ntp_seconds = kNtpHigh;
  69   sender_info.ntp_fraction = kNtpLow;
  70   sender_info.rtp_timestamp = kRtpTimestamp;
  71   sender_info.send_packet_count = kSendPacketCount;
  72   sender_info.send_octet_count = kSendOctetCount;
  73
  74   // Sender report + c_name.
  75   TestRtcpPacketBuilder p;
  76   p.AddSr(kSendingSsrc, 0);
  77   p.AddSdesCname(kSendingSsrc, kCName);
  78   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
  79
  80   rtcp_sender_->SendRtcp(RtcpSender::kRtcpSr,
  81                          &sender_info,
  82                          NULL,
  83                          0,
  84                          NULL,
  85                          NULL,
  86                          NULL);
  87
  88   EXPECT_EQ(1, test_transport_.packet_count());
  89 }
  90
  91 TEST_F(RtcpSenderTest, RtcpReceiverReport) {
  92   // Empty receiver report + c_name.
  93   TestRtcpPacketBuilder p1;
  94   p1.AddRr(kSendingSsrc, 0);
  95   p1.AddSdesCname(kSendingSsrc, kCName);
  96   test_transport_.SetExpectedRtcpPacket(p1.Packet(), p1.Length());
  97
  98   rtcp_sender_->SendRtcp(RtcpSender::kRtcpRr,
  99                          NULL,
 100                          NULL,
 101                          0,
 102                          NULL,
 103                          NULL,
 104                          NULL);
 105
 106   EXPECT_EQ(1, test_transport_.packet_count());
 107
 108   // Receiver report with report block + c_name.
 109   TestRtcpPacketBuilder p2;
 110   p2.AddRr(kSendingSsrc, 1);
 111   p2.AddRb(kMediaSsrc);
 112   p2.AddSdesCname(kSendingSsrc, kCName);
 113   test_transport_.SetExpectedRtcpPacket(p2.Packet(), p2.Length());
 114
 115   RtcpReportBlock report_block;
 116   // Initialize remote_ssrc to a "clearly illegal" value.
 117   report_block.remote_ssrc = 0xDEAD;
 118   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 119   report_block.fraction_lost = kLoss >> 24;
 120   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 121   report_block.extended_high_sequence_number =
 122       kExtendedMax;
 123   report_block.jitter = kJitter;
 124   report_block.last_sr = kLastSr;
 125   report_block.delay_since_last_sr = kDelayLastSr;
 126
 127   rtcp_sender_->SendRtcp(RtcpSender::kRtcpRr,
 128                          NULL,
 129                          &report_block,
 130                          0,
 131                          NULL,
 132                          NULL,
 133                          NULL);
 134
 135   EXPECT_EQ(2, test_transport_.packet_count());
 136 }
 137
 138 TEST_F(RtcpSenderTest, RtcpSenderReportWithDlrr) {
 139   RtcpSenderInfo sender_info;
 140   sender_info.ntp_seconds = kNtpHigh;
 141   sender_info.ntp_fraction = kNtpLow;
 142   sender_info.rtp_timestamp = kRtpTimestamp;
 143   sender_info.send_packet_count = kSendPacketCount;
 144   sender_info.send_octet_count = kSendOctetCount;
 145
 146   // Sender report + c_name + dlrr.
 147   TestRtcpPacketBuilder p1;
 148   p1.AddSr(kSendingSsrc, 0);
 149   p1.AddSdesCname(kSendingSsrc, kCName);
 150   p1.AddXrHeader(kSendingSsrc);
 151   p1.AddXrDlrrBlock(kSendingSsrc);
 152   test_transport_.SetExpectedRtcpPacket(p1.Packet(), p1.Length());
 153
 154   RtcpDlrrReportBlock dlrr_rb;
 155   dlrr_rb.last_rr = kLastRr;
 156   dlrr_rb.delay_since_last_rr = kDelayLastRr;
 157
 158   rtcp_sender_->SendRtcp(RtcpSender::kRtcpSr | RtcpSender::kRtcpDlrr,
 159                          &sender_info,
 160                          NULL,
 161                          0,
 162                          &dlrr_rb,
 163                          NULL,
 164                          NULL);
 165
 166   EXPECT_EQ(1, test_transport_.packet_count());
 167 }
 168
 169 TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) {
 170   // Receiver report with report block + c_name.
 171   TestRtcpPacketBuilder p;
 172   p.AddRr(kSendingSsrc, 1);
 173   p.AddRb(kMediaSsrc);
 174   p.AddSdesCname(kSendingSsrc, kCName);
 175   p.AddXrHeader(kSendingSsrc);
 176   p.AddXrRrtrBlock();
 177   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 178
 179   RtcpReportBlock report_block;
 180   // Initialize remote_ssrc to a "clearly illegal" value.
 181   report_block.remote_ssrc = 0xDEAD;
 182   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 183   report_block.fraction_lost = kLoss >> 24;
 184   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 185   report_block.extended_high_sequence_number =
 186       kExtendedMax;
 187   report_block.jitter = kJitter;
 188   report_block.last_sr = kLastSr;
 189   report_block.delay_since_last_sr = kDelayLastSr;
 190
 191   RtcpReceiverReferenceTimeReport rrtr;
 192   rrtr.ntp_seconds = kNtpHigh;
 193   rrtr.ntp_fraction = kNtpLow;
 194
 195   rtcp_sender_->SendRtcp(RtcpSender::kRtcpRr | RtcpSender::kRtcpRrtr,
 196                          NULL,
 197                          &report_block,
 198                          0,
 199                          NULL,
 200                          &rrtr,
 201                          NULL);
 202
 203   EXPECT_EQ(1, test_transport_.packet_count());
 204 }
 205
 206 TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) {
 207   // Receiver report with report block + c_name.
 208   TestRtcpPacketBuilder p;
 209   p.AddRr(kSendingSsrc, 1);
 210   p.AddRb(kMediaSsrc);
 211   p.AddSdesCname(kSendingSsrc, kCName);
 212   p.AddCast(kSendingSsrc, kMediaSsrc);
 213   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 214
 215   RtcpReportBlock report_block;
 216   // Initialize remote_ssrc to a "clearly illegal" value.
 217   report_block.remote_ssrc = 0xDEAD;
 218   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 219   report_block.fraction_lost = kLoss >> 24;
 220   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 221   report_block.extended_high_sequence_number = kExtendedMax;
 222   report_block.jitter = kJitter;
 223   report_block.last_sr = kLastSr;
 224   report_block.delay_since_last_sr = kDelayLastSr;
 225
 226   RtcpCastMessage cast_message(kMediaSsrc);
 227   cast_message.ack_frame_id_ = kAckFrameId;
 228   PacketIdSet missing_packets;
 229   cast_message.missing_frames_and_packets_[
 230       kLostFrameId] = missing_packets;
 231
 232   missing_packets.insert(kLostPacketId1);
 233   missing_packets.insert(kLostPacketId2);
 234   missing_packets.insert(kLostPacketId3);
 235   cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] =
 236       missing_packets;
 237
 238   rtcp_sender_->SendRtcp(RtcpSender::kRtcpRr | RtcpSender::kRtcpCast,
 239                          NULL,
 240                          &report_block,
 241                          0,
 242                          NULL,
 243                          NULL,
 244                          &cast_message);
 245
 246   EXPECT_EQ(1, test_transport_.packet_count());
 247 }
 248
 249 TEST_F(RtcpSenderTest, RtcpReceiverReportWithIntraFrameRequest) {
 250   // Receiver report with report block + c_name.
 251   TestRtcpPacketBuilder p;
 252   p.AddRr(kSendingSsrc, 1);
 253   p.AddRb(kMediaSsrc);
 254   p.AddSdesCname(kSendingSsrc, kCName);
 255   p.AddPli(kSendingSsrc, kMediaSsrc);
 256   test_transport_.SetExpectedRtcpPacket(p.Packet(), p.Length());
 257
 258   RtcpReportBlock report_block;
 259   // Initialize remote_ssrc to a "clearly illegal" value.
 260   report_block.remote_ssrc = 0xDEAD;
 261   report_block.media_ssrc = kMediaSsrc;  // SSRC of the RTP packet sender.
 262   report_block.fraction_lost = kLoss >> 24;
 263   report_block.cumulative_lost = kLoss;  // 24 bits valid.
 264   report_block.extended_high_sequence_number =
 265       kExtendedMax;
 266   report_block.jitter = kJitter;
 267   report_block.last_sr = kLastSr;
 268   report_block.delay_since_last_sr = kDelayLastSr;
 269
 270   rtcp_sender_->SendRtcp(RtcpSender::kRtcpRr | RtcpSender::kRtcpPli,
 271                          NULL,
 272                          &report_block,
 273                          kMediaSsrc,
 274                          NULL,
 275                          NULL,
 276                          NULL);
 277
 278   EXPECT_EQ(1, test_transport_.packet_count());
 279 }
 280
 281 }  // namespace cast
 282 }  // namespace media