OLD | NEW |
(Empty) | |
| 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().Pass(); } |
| 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 |
OLD | NEW |