Home | History | Annotate | Download | only in rtcp_packet 
      1 /*
      2  *  Copyright (c) 2015 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 "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
     12 
     13 #include "testing/gtest/include/gtest/gtest.h"
     14 
     15 using webrtc::rtcp::RawPacket;
     16 using webrtc::rtcp::ReceiverReport;
     17 using webrtc::rtcp::ReportBlock;
     18 using webrtc::RTCPUtility::RtcpCommonHeader;
     19 using webrtc::RTCPUtility::RtcpParseCommonHeader;
     20 
     21 namespace webrtc {
     22 namespace {
     23 const uint32_t kSenderSsrc = 0x12345678;
     24 const uint32_t kRemoteSsrc = 0x23456789;
     25 const uint8_t kFractionLost = 55;
     26 const uint32_t kCumulativeLost = 0x111213;
     27 const uint32_t kExtHighestSeqNum = 0x22232425;
     28 const uint32_t kJitter = 0x33343536;
     29 const uint32_t kLastSr = 0x44454647;
     30 const uint32_t kDelayLastSr = 0x55565758;
     31 // Manually created ReceiverReport with one ReportBlock matching constants
     32 // above.
     33 // Having this block allows to test Create and Parse separately.
     34 const uint8_t kPacket[] = {0x81, 201,  0x00, 0x07, 0x12, 0x34, 0x56, 0x78,
     35                            0x23, 0x45, 0x67, 0x89, 55,   0x11, 0x12, 0x13,
     36                            0x22, 0x23, 0x24, 0x25, 0x33, 0x34, 0x35, 0x36,
     37                            0x44, 0x45, 0x46, 0x47, 0x55, 0x56, 0x57, 0x58};
     38 const size_t kPacketLength = sizeof(kPacket);
     39 
     40 class RtcpPacketReceiverReportTest : public ::testing::Test {
     41  protected:
     42   void BuildPacket() { packet = rr.Build(); }
     43   void ParsePacket() {
     44     RtcpCommonHeader header;
     45     EXPECT_TRUE(
     46         RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header));
     47     EXPECT_EQ(header.BlockSize(), packet->Length());
     48     EXPECT_TRUE(parsed_.Parse(
     49         header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes));
     50   }
     51 
     52   ReceiverReport rr;
     53   rtc::scoped_ptr<RawPacket> packet;
     54   const ReceiverReport& parsed() { return parsed_; }
     55 
     56  private:
     57   ReceiverReport parsed_;
     58 };
     59 
     60 TEST_F(RtcpPacketReceiverReportTest, Parse) {
     61   RtcpCommonHeader header;
     62   RtcpParseCommonHeader(kPacket, kPacketLength, &header);
     63   EXPECT_TRUE(rr.Parse(header, kPacket + RtcpCommonHeader::kHeaderSizeBytes));
     64   const ReceiverReport& parsed = rr;
     65 
     66   EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
     67   EXPECT_EQ(1u, parsed.report_blocks().size());
     68   const ReportBlock& rb = parsed.report_blocks().front();
     69   EXPECT_EQ(kRemoteSsrc, rb.source_ssrc());
     70   EXPECT_EQ(kFractionLost, rb.fraction_lost());
     71   EXPECT_EQ(kCumulativeLost, rb.cumulative_lost());
     72   EXPECT_EQ(kExtHighestSeqNum, rb.extended_high_seq_num());
     73   EXPECT_EQ(kJitter, rb.jitter());
     74   EXPECT_EQ(kLastSr, rb.last_sr());
     75   EXPECT_EQ(kDelayLastSr, rb.delay_since_last_sr());
     76 }
     77 
     78 TEST_F(RtcpPacketReceiverReportTest, ParseFailsOnIncorrectSize) {
     79   RtcpCommonHeader header;
     80   RtcpParseCommonHeader(kPacket, kPacketLength, &header);
     81   header.count_or_format++;  // Damage the packet.
     82   EXPECT_FALSE(rr.Parse(header, kPacket + RtcpCommonHeader::kHeaderSizeBytes));
     83 }
     84 
     85 TEST_F(RtcpPacketReceiverReportTest, Create) {
     86   rr.From(kSenderSsrc);
     87   ReportBlock rb;
     88   rb.To(kRemoteSsrc);
     89   rb.WithFractionLost(kFractionLost);
     90   rb.WithCumulativeLost(kCumulativeLost);
     91   rb.WithExtHighestSeqNum(kExtHighestSeqNum);
     92   rb.WithJitter(kJitter);
     93   rb.WithLastSr(kLastSr);
     94   rb.WithDelayLastSr(kDelayLastSr);
     95   rr.WithReportBlock(rb);
     96 
     97   BuildPacket();
     98 
     99   ASSERT_EQ(kPacketLength, packet->Length());
    100   EXPECT_EQ(0, memcmp(kPacket, packet->Buffer(), kPacketLength));
    101 }
    102 
    103 TEST_F(RtcpPacketReceiverReportTest, WithoutReportBlocks) {
    104   rr.From(kSenderSsrc);
    105 
    106   BuildPacket();
    107   ParsePacket();
    108 
    109   EXPECT_EQ(kSenderSsrc, parsed().sender_ssrc());
    110   EXPECT_EQ(0u, parsed().report_blocks().size());
    111 }
    112 
    113 TEST_F(RtcpPacketReceiverReportTest, WithTwoReportBlocks) {
    114   ReportBlock rb1;
    115   rb1.To(kRemoteSsrc);
    116   ReportBlock rb2;
    117   rb2.To(kRemoteSsrc + 1);
    118 
    119   rr.From(kSenderSsrc);
    120   EXPECT_TRUE(rr.WithReportBlock(rb1));
    121   EXPECT_TRUE(rr.WithReportBlock(rb2));
    122 
    123   BuildPacket();
    124   ParsePacket();
    125 
    126   EXPECT_EQ(kSenderSsrc, parsed().sender_ssrc());
    127   EXPECT_EQ(2u, parsed().report_blocks().size());
    128   EXPECT_EQ(kRemoteSsrc, parsed().report_blocks()[0].source_ssrc());
    129   EXPECT_EQ(kRemoteSsrc + 1, parsed().report_blocks()[1].source_ssrc());
    130 }
    131 
    132 TEST_F(RtcpPacketReceiverReportTest, WithTooManyReportBlocks) {
    133   rr.From(kSenderSsrc);
    134   const size_t kMaxReportBlocks = (1 << 5) - 1;
    135   ReportBlock rb;
    136   for (size_t i = 0; i < kMaxReportBlocks; ++i) {
    137     rb.To(kRemoteSsrc + i);
    138     EXPECT_TRUE(rr.WithReportBlock(rb));
    139   }
    140   rb.To(kRemoteSsrc + kMaxReportBlocks);
    141   EXPECT_FALSE(rr.WithReportBlock(rb));
    142 }
    143 
    144 }  // namespace
    145 }  // namespace webrtc
    146