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/bye.h" 12 13 #include "testing/gmock/include/gmock/gmock.h" 14 #include "testing/gtest/include/gtest/gtest.h" 15 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" 16 17 using ::testing::ElementsAre; 18 19 using webrtc::rtcp::Bye; 20 using webrtc::rtcp::RawPacket; 21 using webrtc::RTCPUtility::RtcpCommonHeader; 22 using webrtc::RTCPUtility::RtcpParseCommonHeader; 23 24 namespace webrtc { 25 namespace { 26 27 const uint32_t kSenderSsrc = 0x12345678; 28 const uint32_t kCsrc1 = 0x22232425; 29 const uint32_t kCsrc2 = 0x33343536; 30 31 class RtcpPacketByeTest : public ::testing::Test { 32 protected: 33 void BuildPacket() { packet = bye.Build(); } 34 void ParsePacket() { 35 RtcpCommonHeader header; 36 EXPECT_TRUE( 37 RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header)); 38 // Check that there is exactly one RTCP packet in the buffer. 39 EXPECT_EQ(header.BlockSize(), packet->Length()); 40 EXPECT_TRUE(parsed_bye.Parse( 41 header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes)); 42 } 43 44 Bye bye; 45 rtc::scoped_ptr<RawPacket> packet; 46 Bye parsed_bye; 47 }; 48 49 TEST_F(RtcpPacketByeTest, Bye) { 50 bye.From(kSenderSsrc); 51 52 BuildPacket(); 53 ParsePacket(); 54 55 EXPECT_EQ(kSenderSsrc, parsed_bye.sender_ssrc()); 56 EXPECT_TRUE(parsed_bye.csrcs().empty()); 57 EXPECT_TRUE(parsed_bye.reason().empty()); 58 } 59 60 TEST_F(RtcpPacketByeTest, WithCsrcs) { 61 bye.From(kSenderSsrc); 62 EXPECT_TRUE(bye.WithCsrc(kCsrc1)); 63 EXPECT_TRUE(bye.WithCsrc(kCsrc2)); 64 EXPECT_TRUE(bye.reason().empty()); 65 66 BuildPacket(); 67 EXPECT_EQ(16u, packet->Length()); // Header: 4, 3xSRCs: 12, Reason: 0. 68 69 ParsePacket(); 70 71 EXPECT_EQ(kSenderSsrc, parsed_bye.sender_ssrc()); 72 EXPECT_THAT(parsed_bye.csrcs(), ElementsAre(kCsrc1, kCsrc2)); 73 EXPECT_TRUE(parsed_bye.reason().empty()); 74 } 75 76 TEST_F(RtcpPacketByeTest, WithCsrcsAndReason) { 77 const std::string kReason = "Some Reason"; 78 79 bye.From(kSenderSsrc); 80 EXPECT_TRUE(bye.WithCsrc(kCsrc1)); 81 EXPECT_TRUE(bye.WithCsrc(kCsrc2)); 82 bye.WithReason(kReason); 83 84 BuildPacket(); 85 EXPECT_EQ(28u, packet->Length()); // Header: 4, 3xSRCs: 12, Reason: 12. 86 87 ParsePacket(); 88 89 EXPECT_EQ(kSenderSsrc, parsed_bye.sender_ssrc()); 90 EXPECT_THAT(parsed_bye.csrcs(), ElementsAre(kCsrc1, kCsrc2)); 91 EXPECT_EQ(kReason, parsed_bye.reason()); 92 } 93 94 TEST_F(RtcpPacketByeTest, WithTooManyCsrcs) { 95 bye.From(kSenderSsrc); 96 const int kMaxCsrcs = (1 << 5) - 2; // 5 bit len, first item is sender SSRC. 97 for (int i = 0; i < kMaxCsrcs; ++i) { 98 EXPECT_TRUE(bye.WithCsrc(i)); 99 } 100 EXPECT_FALSE(bye.WithCsrc(kMaxCsrcs)); 101 } 102 103 TEST_F(RtcpPacketByeTest, WithAReason) { 104 const std::string kReason = "Some Random Reason"; 105 106 bye.From(kSenderSsrc); 107 bye.WithReason(kReason); 108 109 BuildPacket(); 110 ParsePacket(); 111 112 EXPECT_EQ(kSenderSsrc, parsed_bye.sender_ssrc()); 113 EXPECT_TRUE(parsed_bye.csrcs().empty()); 114 EXPECT_EQ(kReason, parsed_bye.reason()); 115 } 116 117 TEST_F(RtcpPacketByeTest, WithReasons) { 118 // Test that packet creation/parsing behave with reasons of different length 119 // both when it require padding and when it does not. 120 for (size_t reminder = 0; reminder < 4; ++reminder) { 121 const std::string kReason(4 + reminder, 'a' + reminder); 122 bye.From(kSenderSsrc); 123 bye.WithReason(kReason); 124 125 BuildPacket(); 126 ParsePacket(); 127 128 EXPECT_EQ(kReason, parsed_bye.reason()); 129 } 130 } 131 132 TEST_F(RtcpPacketByeTest, ParseEmptyPacket) { 133 RtcpCommonHeader header; 134 header.packet_type = Bye::kPacketType; 135 header.count_or_format = 0; 136 header.payload_size_bytes = 0; 137 uint8_t empty_payload[1]; 138 139 EXPECT_TRUE(parsed_bye.Parse(header, empty_payload + 1)); 140 EXPECT_EQ(0u, parsed_bye.sender_ssrc()); 141 EXPECT_TRUE(parsed_bye.csrcs().empty()); 142 EXPECT_TRUE(parsed_bye.reason().empty()); 143 } 144 145 TEST_F(RtcpPacketByeTest, ParseFailOnInvalidSrcCount) { 146 bye.From(kSenderSsrc); 147 148 BuildPacket(); 149 150 RtcpCommonHeader header; 151 RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header); 152 header.count_or_format = 2; // Lie there are 2 ssrcs, not one. 153 154 EXPECT_FALSE(parsed_bye.Parse( 155 header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes)); 156 } 157 158 TEST_F(RtcpPacketByeTest, ParseFailOnInvalidReasonLength) { 159 bye.From(kSenderSsrc); 160 bye.WithReason("18 characters long"); 161 162 BuildPacket(); 163 164 RtcpCommonHeader header; 165 RtcpParseCommonHeader(packet->Buffer(), packet->Length(), &header); 166 header.payload_size_bytes -= 4; // Payload is usually 32bit aligned. 167 168 EXPECT_FALSE(parsed_bye.Parse( 169 header, packet->Buffer() + RtcpCommonHeader::kHeaderSizeBytes)); 170 } 171 172 } // namespace 173 } // namespace webrtc 174
