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 "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
12
13 #include <utility>
14
15 #include "test/gmock.h"
16 #include "test/gtest.h"
17 #include "test/rtcp_packet_parser.h"
18
19 using ::testing::ElementsAreArray;
20 using ::testing::IsEmpty;
21 using ::testing::make_tuple;
22 using webrtc::rtcp::ReceiverReport;
23 using webrtc::rtcp::ReportBlock;
24
25 namespace webrtc {
26 namespace {
27 const uint32_t kSenderSsrc = 0x12345678;
28 const uint32_t kRemoteSsrc = 0x23456789;
29 const uint8_t kFractionLost = 55;
30 const int32_t kCumulativeLost = 0x111213;
31 const uint32_t kExtHighestSeqNum = 0x22232425;
32 const uint32_t kJitter = 0x33343536;
33 const uint32_t kLastSr = 0x44454647;
34 const uint32_t kDelayLastSr = 0x55565758;
35 // Manually created ReceiverReport with one ReportBlock matching constants
36 // above.
37 // Having this block allows to test Create and Parse separately.
38 const uint8_t kPacket[] = {0x81, 201, 0x00, 0x07, 0x12, 0x34, 0x56, 0x78,
39 0x23, 0x45, 0x67, 0x89, 55, 0x11, 0x12, 0x13,
40 0x22, 0x23, 0x24, 0x25, 0x33, 0x34, 0x35, 0x36,
41 0x44, 0x45, 0x46, 0x47, 0x55, 0x56, 0x57, 0x58};
42 } // namespace
43
TEST(RtcpPacketReceiverReportTest,ParseWithOneReportBlock)44 TEST(RtcpPacketReceiverReportTest, ParseWithOneReportBlock) {
45 ReceiverReport rr;
46 EXPECT_TRUE(test::ParseSinglePacket(kPacket, &rr));
47 const ReceiverReport& parsed = rr;
48
49 EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
50 EXPECT_EQ(1u, parsed.report_blocks().size());
51 const ReportBlock& rb = parsed.report_blocks().front();
52 EXPECT_EQ(kRemoteSsrc, rb.source_ssrc());
53 EXPECT_EQ(kFractionLost, rb.fraction_lost());
54 EXPECT_EQ(kCumulativeLost, rb.cumulative_lost_signed());
55 EXPECT_EQ(kExtHighestSeqNum, rb.extended_high_seq_num());
56 EXPECT_EQ(kJitter, rb.jitter());
57 EXPECT_EQ(kLastSr, rb.last_sr());
58 EXPECT_EQ(kDelayLastSr, rb.delay_since_last_sr());
59 }
60
TEST(RtcpPacketReceiverReportTest,ParseFailsOnIncorrectSize)61 TEST(RtcpPacketReceiverReportTest, ParseFailsOnIncorrectSize) {
62 rtc::Buffer damaged_packet(kPacket);
63 damaged_packet[0]++; // Damage the packet: increase count field.
64 ReceiverReport rr;
65 EXPECT_FALSE(test::ParseSinglePacket(damaged_packet, &rr));
66 }
67
TEST(RtcpPacketReceiverReportTest,CreateWithOneReportBlock)68 TEST(RtcpPacketReceiverReportTest, CreateWithOneReportBlock) {
69 ReceiverReport rr;
70 rr.SetSenderSsrc(kSenderSsrc);
71 ReportBlock rb;
72 rb.SetMediaSsrc(kRemoteSsrc);
73 rb.SetFractionLost(kFractionLost);
74 rb.SetCumulativeLost(kCumulativeLost);
75 rb.SetExtHighestSeqNum(kExtHighestSeqNum);
76 rb.SetJitter(kJitter);
77 rb.SetLastSr(kLastSr);
78 rb.SetDelayLastSr(kDelayLastSr);
79 rr.AddReportBlock(rb);
80
81 rtc::Buffer raw = rr.Build();
82
83 EXPECT_THAT(make_tuple(raw.data(), raw.size()), ElementsAreArray(kPacket));
84 }
85
TEST(RtcpPacketReceiverReportTest,CreateAndParseWithoutReportBlocks)86 TEST(RtcpPacketReceiverReportTest, CreateAndParseWithoutReportBlocks) {
87 ReceiverReport rr;
88 rr.SetSenderSsrc(kSenderSsrc);
89
90 rtc::Buffer raw = rr.Build();
91 ReceiverReport parsed;
92 EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed));
93
94 EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
95 EXPECT_THAT(parsed.report_blocks(), IsEmpty());
96 }
97
TEST(RtcpPacketReceiverReportTest,CreateAndParseWithTwoReportBlocks)98 TEST(RtcpPacketReceiverReportTest, CreateAndParseWithTwoReportBlocks) {
99 ReceiverReport rr;
100 ReportBlock rb1;
101 rb1.SetMediaSsrc(kRemoteSsrc);
102 ReportBlock rb2;
103 rb2.SetMediaSsrc(kRemoteSsrc + 1);
104
105 rr.SetSenderSsrc(kSenderSsrc);
106 EXPECT_TRUE(rr.AddReportBlock(rb1));
107 EXPECT_TRUE(rr.AddReportBlock(rb2));
108
109 rtc::Buffer raw = rr.Build();
110 ReceiverReport parsed;
111 EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed));
112
113 EXPECT_EQ(kSenderSsrc, parsed.sender_ssrc());
114 EXPECT_EQ(2u, parsed.report_blocks().size());
115 EXPECT_EQ(kRemoteSsrc, parsed.report_blocks()[0].source_ssrc());
116 EXPECT_EQ(kRemoteSsrc + 1, parsed.report_blocks()[1].source_ssrc());
117 }
118
TEST(RtcpPacketReceiverReportTest,CreateWithTooManyReportBlocks)119 TEST(RtcpPacketReceiverReportTest, CreateWithTooManyReportBlocks) {
120 ReceiverReport rr;
121 rr.SetSenderSsrc(kSenderSsrc);
122 ReportBlock rb;
123 for (size_t i = 0; i < ReceiverReport::kMaxNumberOfReportBlocks; ++i) {
124 rb.SetMediaSsrc(kRemoteSsrc + i);
125 EXPECT_TRUE(rr.AddReportBlock(rb));
126 }
127 rb.SetMediaSsrc(kRemoteSsrc + ReceiverReport::kMaxNumberOfReportBlocks);
128 EXPECT_FALSE(rr.AddReportBlock(rb));
129 }
130
TEST(RtcpPacketReceiverReportTest,SetReportBlocksOverwritesOldBlocks)131 TEST(RtcpPacketReceiverReportTest, SetReportBlocksOverwritesOldBlocks) {
132 ReceiverReport rr;
133 ReportBlock report_block;
134 // Use jitter field of the report blocks to distinguish them.
135 report_block.SetJitter(1001u);
136 rr.AddReportBlock(report_block);
137 ASSERT_EQ(rr.report_blocks().size(), 1u);
138 ASSERT_EQ(rr.report_blocks()[0].jitter(), 1001u);
139
140 std::vector<ReportBlock> blocks(3u);
141 blocks[0].SetJitter(2001u);
142 blocks[1].SetJitter(3001u);
143 blocks[2].SetJitter(4001u);
144 EXPECT_TRUE(rr.SetReportBlocks(blocks));
145 ASSERT_EQ(rr.report_blocks().size(), 3u);
146 EXPECT_EQ(rr.report_blocks()[0].jitter(), 2001u);
147 EXPECT_EQ(rr.report_blocks()[1].jitter(), 3001u);
148 EXPECT_EQ(rr.report_blocks()[2].jitter(), 4001u);
149 }
150
TEST(RtcpPacketReceiverReportTest,SetReportBlocksMaxLimit)151 TEST(RtcpPacketReceiverReportTest, SetReportBlocksMaxLimit) {
152 ReceiverReport rr;
153 std::vector<ReportBlock> max_blocks(ReceiverReport::kMaxNumberOfReportBlocks);
154 EXPECT_TRUE(rr.SetReportBlocks(std::move(max_blocks)));
155
156 std::vector<ReportBlock> one_too_many_blocks(
157 ReceiverReport::kMaxNumberOfReportBlocks + 1);
158 EXPECT_FALSE(rr.SetReportBlocks(std::move(one_too_many_blocks)));
159 }
160
161 } // namespace webrtc
162