rtp_rtcp_impl_unittest.cc revision ff761fba8274d93bd73e76c8b8a1f2d0776dd840 
1/*
2 *  Copyright (c) 2013 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 "testing/gmock/include/gmock/gmock.h"
12#include "testing/gtest/include/gtest/gtest.h"
13
14#include "webrtc/common_types.h"
15#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
16#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
17#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
18#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
19#include "webrtc/system_wrappers/include/scoped_vector.h"
20#include "webrtc/test/rtcp_packet_parser.h"
21
22using ::testing::_;
23using ::testing::ElementsAre;
24using ::testing::NiceMock;
25using ::testing::Return;
26using ::testing::SaveArg;
27
28namespace webrtc {
29namespace {
30const uint32_t kSenderSsrc = 0x12345;
31const uint32_t kReceiverSsrc = 0x23456;
32const int64_t kOneWayNetworkDelayMs = 100;
33const uint8_t kBaseLayerTid = 0;
34const uint8_t kHigherLayerTid = 1;
35const uint16_t kSequenceNumber = 100;
36
37class RtcpRttStatsTestImpl : public RtcpRttStats {
38 public:
39  RtcpRttStatsTestImpl() : rtt_ms_(0) {}
40  virtual ~RtcpRttStatsTestImpl() {}
41
42  void OnRttUpdate(int64_t rtt_ms) override { rtt_ms_ = rtt_ms; }
43  int64_t LastProcessedRtt() const override { return rtt_ms_; }
44  int64_t rtt_ms_;
45};
46
47class SendTransport : public Transport,
48                      public NullRtpData {
49 public:
50  SendTransport()
51      : receiver_(NULL),
52        clock_(NULL),
53        delay_ms_(0),
54        rtp_packets_sent_(0) {
55  }
56
57  void SetRtpRtcpModule(ModuleRtpRtcpImpl* receiver) {
58    receiver_ = receiver;
59  }
60  void SimulateNetworkDelay(int64_t delay_ms, SimulatedClock* clock) {
61    clock_ = clock;
62    delay_ms_ = delay_ms;
63  }
64  bool SendRtp(const uint8_t* data,
65               size_t len,
66               const PacketOptions& options) override {
67    RTPHeader header;
68    rtc::scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create());
69    EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data), len, &header));
70    ++rtp_packets_sent_;
71    last_rtp_header_ = header;
72    return true;
73  }
74  bool SendRtcp(const uint8_t* data, size_t len) override {
75    test::RtcpPacketParser parser;
76    parser.Parse(static_cast<const uint8_t*>(data), len);
77    last_nack_list_ = parser.nack_item()->last_nack_list();
78
79    if (clock_) {
80      clock_->AdvanceTimeMilliseconds(delay_ms_);
81    }
82    EXPECT_TRUE(receiver_ != NULL);
83    EXPECT_EQ(0, receiver_->IncomingRtcpPacket(
84        static_cast<const uint8_t*>(data), len));
85    return true;
86  }
87  ModuleRtpRtcpImpl* receiver_;
88  SimulatedClock* clock_;
89  int64_t delay_ms_;
90  int rtp_packets_sent_;
91  RTPHeader last_rtp_header_;
92  std::vector<uint16_t> last_nack_list_;
93};
94
95class RtpRtcpModule : public RtcpPacketTypeCounterObserver {
96 public:
97  RtpRtcpModule(SimulatedClock* clock)
98      : receive_statistics_(ReceiveStatistics::Create(clock)) {
99    RtpRtcp::Configuration config;
100    config.audio = false;
101    config.clock = clock;
102    config.outgoing_transport = &transport_;
103    config.receive_statistics = receive_statistics_.get();
104    config.rtcp_packet_type_counter_observer = this;
105    config.rtt_stats = &rtt_stats_;
106
107    impl_.reset(new ModuleRtpRtcpImpl(config));
108    impl_->SetRTCPStatus(RtcpMode::kCompound);
109
110    transport_.SimulateNetworkDelay(kOneWayNetworkDelayMs, clock);
111  }
112
113  RtcpPacketTypeCounter packets_sent_;
114  RtcpPacketTypeCounter packets_received_;
115  rtc::scoped_ptr<ReceiveStatistics> receive_statistics_;
116  SendTransport transport_;
117  RtcpRttStatsTestImpl rtt_stats_;
118  rtc::scoped_ptr<ModuleRtpRtcpImpl> impl_;
119  uint32_t remote_ssrc_;
120
121  void SetRemoteSsrc(uint32_t ssrc) {
122    remote_ssrc_ = ssrc;
123    impl_->SetRemoteSSRC(ssrc);
124  }
125
126  void RtcpPacketTypesCounterUpdated(
127      uint32_t ssrc,
128      const RtcpPacketTypeCounter& packet_counter) override {
129    counter_map_[ssrc] = packet_counter;
130  }
131
132  RtcpPacketTypeCounter RtcpSent() {
133    // RTCP counters for remote SSRC.
134    return counter_map_[remote_ssrc_];
135  }
136
137  RtcpPacketTypeCounter RtcpReceived() {
138    // Received RTCP stats for (own) local SSRC.
139    return counter_map_[impl_->SSRC()];
140  }
141  int RtpSent() {
142    return transport_.rtp_packets_sent_;
143  }
144  uint16_t LastRtpSequenceNumber() {
145    return transport_.last_rtp_header_.sequenceNumber;
146  }
147  std::vector<uint16_t> LastNackListSent() {
148    return transport_.last_nack_list_;
149  }
150
151 private:
152  std::map<uint32_t, RtcpPacketTypeCounter> counter_map_;
153};
154}  // namespace
155
156class RtpRtcpImplTest : public ::testing::Test {
157 protected:
158  RtpRtcpImplTest()
159      : clock_(133590000000000),
160        sender_(&clock_),
161        receiver_(&clock_) {
162    // Send module.
163    EXPECT_EQ(0, sender_.impl_->SetSendingStatus(true));
164    sender_.impl_->SetSendingMediaStatus(true);
165    sender_.impl_->SetSSRC(kSenderSsrc);
166    sender_.SetRemoteSsrc(kReceiverSsrc);
167    sender_.impl_->SetSequenceNumber(kSequenceNumber);
168    sender_.impl_->SetStorePacketsStatus(true, 100);
169
170    memset(&codec_, 0, sizeof(VideoCodec));
171    codec_.plType = 100;
172    strncpy(codec_.plName, "VP8", 3);
173    codec_.width = 320;
174    codec_.height = 180;
175    EXPECT_EQ(0, sender_.impl_->RegisterSendPayload(codec_));
176
177    // Receive module.
178    EXPECT_EQ(0, receiver_.impl_->SetSendingStatus(false));
179    receiver_.impl_->SetSendingMediaStatus(false);
180    receiver_.impl_->SetSSRC(kReceiverSsrc);
181    receiver_.SetRemoteSsrc(kSenderSsrc);
182    // Transport settings.
183    sender_.transport_.SetRtpRtcpModule(receiver_.impl_.get());
184    receiver_.transport_.SetRtpRtcpModule(sender_.impl_.get());
185  }
186  SimulatedClock clock_;
187  RtpRtcpModule sender_;
188  RtpRtcpModule receiver_;
189  VideoCodec codec_;
190
191  void SendFrame(const RtpRtcpModule* module, uint8_t tid) {
192    RTPVideoHeaderVP8 vp8_header = {};
193    vp8_header.temporalIdx = tid;
194    RTPVideoHeader rtp_video_header = {codec_.width,
195                                       codec_.height,
196                                       kVideoRotation_0,
197                                       true,
198                                       0,
199                                       kRtpVideoVp8,
200                                       {vp8_header}};
201
202    const uint8_t payload[100] = {0};
203    EXPECT_EQ(0, module->impl_->SendOutgoingData(kVideoFrameKey,
204                                                 codec_.plType,
205                                                 0,
206                                                 0,
207                                                 payload,
208                                                 sizeof(payload),
209                                                 NULL,
210                                                 &rtp_video_header));
211  }
212
213  void IncomingRtcpNack(const RtpRtcpModule* module, uint16_t sequence_number) {
214    bool sender = module->impl_->SSRC() == kSenderSsrc;
215    rtcp::Nack nack;
216    uint16_t list[1];
217    list[0] = sequence_number;
218    const uint16_t kListLength = sizeof(list) / sizeof(list[0]);
219    nack.From(sender ? kReceiverSsrc : kSenderSsrc);
220    nack.To(sender ? kSenderSsrc : kReceiverSsrc);
221    nack.WithList(list, kListLength);
222    rtc::scoped_ptr<rtcp::RawPacket> packet(nack.Build());
223    EXPECT_EQ(0, module->impl_->IncomingRtcpPacket(packet->Buffer(),
224                                                   packet->Length()));
225  }
226};
227
228TEST_F(RtpRtcpImplTest, SetSelectiveRetransmissions_BaseLayer) {
229  sender_.impl_->SetSelectiveRetransmissions(kRetransmitBaseLayer);
230  EXPECT_EQ(kRetransmitBaseLayer, sender_.impl_->SelectiveRetransmissions());
231
232  // Send frames.
233  EXPECT_EQ(0, sender_.RtpSent());
234  SendFrame(&sender_, kBaseLayerTid);    // kSequenceNumber
235  SendFrame(&sender_, kHigherLayerTid);  // kSequenceNumber + 1
236  SendFrame(&sender_, kNoTemporalIdx);   // kSequenceNumber + 2
237  EXPECT_EQ(3, sender_.RtpSent());
238  EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
239
240  // Min required delay until retransmit = 5 + RTT ms (RTT = 0).
241  clock_.AdvanceTimeMilliseconds(5);
242
243  // Frame with kBaseLayerTid re-sent.
244  IncomingRtcpNack(&sender_, kSequenceNumber);
245  EXPECT_EQ(4, sender_.RtpSent());
246  EXPECT_EQ(kSequenceNumber, sender_.LastRtpSequenceNumber());
247  // Frame with kHigherLayerTid not re-sent.
248  IncomingRtcpNack(&sender_, kSequenceNumber + 1);
249  EXPECT_EQ(4, sender_.RtpSent());
250  // Frame with kNoTemporalIdx re-sent.
251  IncomingRtcpNack(&sender_, kSequenceNumber + 2);
252  EXPECT_EQ(5, sender_.RtpSent());
253  EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
254}
255
256TEST_F(RtpRtcpImplTest, SetSelectiveRetransmissions_HigherLayers) {
257  const uint8_t kSetting = kRetransmitBaseLayer + kRetransmitHigherLayers;
258  sender_.impl_->SetSelectiveRetransmissions(kSetting);
259  EXPECT_EQ(kSetting, sender_.impl_->SelectiveRetransmissions());
260
261  // Send frames.
262  EXPECT_EQ(0, sender_.RtpSent());
263  SendFrame(&sender_, kBaseLayerTid);    // kSequenceNumber
264  SendFrame(&sender_, kHigherLayerTid);  // kSequenceNumber + 1
265  SendFrame(&sender_, kNoTemporalIdx);   // kSequenceNumber + 2
266  EXPECT_EQ(3, sender_.RtpSent());
267  EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
268
269  // Min required delay until retransmit = 5 + RTT ms (RTT = 0).
270  clock_.AdvanceTimeMilliseconds(5);
271
272  // Frame with kBaseLayerTid re-sent.
273  IncomingRtcpNack(&sender_, kSequenceNumber);
274  EXPECT_EQ(4, sender_.RtpSent());
275  EXPECT_EQ(kSequenceNumber, sender_.LastRtpSequenceNumber());
276  // Frame with kHigherLayerTid re-sent.
277  IncomingRtcpNack(&sender_, kSequenceNumber + 1);
278  EXPECT_EQ(5, sender_.RtpSent());
279  EXPECT_EQ(kSequenceNumber + 1, sender_.LastRtpSequenceNumber());
280  // Frame with kNoTemporalIdx re-sent.
281  IncomingRtcpNack(&sender_, kSequenceNumber + 2);
282  EXPECT_EQ(6, sender_.RtpSent());
283  EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
284}
285
286TEST_F(RtpRtcpImplTest, Rtt) {
287  RTPHeader header;
288  header.timestamp = 1;
289  header.sequenceNumber = 123;
290  header.ssrc = kSenderSsrc;
291  header.headerLength = 12;
292  receiver_.receive_statistics_->IncomingPacket(header, 100, false);
293
294  // Sender module should send a SR.
295  EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
296
297  // Receiver module should send a RR with a response to the last received SR.
298  clock_.AdvanceTimeMilliseconds(1000);
299  EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
300
301  // Verify RTT.
302  int64_t rtt;
303  int64_t avg_rtt;
304  int64_t min_rtt;
305  int64_t max_rtt;
306  EXPECT_EQ(0,
307      sender_.impl_->RTT(kReceiverSsrc, &rtt, &avg_rtt, &min_rtt, &max_rtt));
308  EXPECT_EQ(2 * kOneWayNetworkDelayMs, rtt);
309  EXPECT_EQ(2 * kOneWayNetworkDelayMs, avg_rtt);
310  EXPECT_EQ(2 * kOneWayNetworkDelayMs, min_rtt);
311  EXPECT_EQ(2 * kOneWayNetworkDelayMs, max_rtt);
312
313  // No RTT from other ssrc.
314  EXPECT_EQ(-1,
315      sender_.impl_->RTT(kReceiverSsrc+1, &rtt, &avg_rtt, &min_rtt, &max_rtt));
316
317  // Verify RTT from rtt_stats config.
318  EXPECT_EQ(0, sender_.rtt_stats_.LastProcessedRtt());
319  EXPECT_EQ(0, sender_.impl_->rtt_ms());
320  sender_.impl_->Process();
321  EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.rtt_stats_.LastProcessedRtt());
322  EXPECT_EQ(2 * kOneWayNetworkDelayMs, sender_.impl_->rtt_ms());
323}
324
325TEST_F(RtpRtcpImplTest, SetRtcpXrRrtrStatus) {
326  EXPECT_FALSE(receiver_.impl_->RtcpXrRrtrStatus());
327  receiver_.impl_->SetRtcpXrRrtrStatus(true);
328  EXPECT_TRUE(receiver_.impl_->RtcpXrRrtrStatus());
329}
330
331TEST_F(RtpRtcpImplTest, RttForReceiverOnly) {
332  receiver_.impl_->SetRtcpXrRrtrStatus(true);
333
334  // Receiver module should send a Receiver time reference report (RTRR).
335  EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));
336
337  // Sender module should send a response to the last received RTRR (DLRR).
338  clock_.AdvanceTimeMilliseconds(1000);
339  EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
340
341  // Verify RTT.
342  EXPECT_EQ(0, receiver_.rtt_stats_.LastProcessedRtt());
343  EXPECT_EQ(0, receiver_.impl_->rtt_ms());
344  receiver_.impl_->Process();
345  EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.rtt_stats_.LastProcessedRtt());
346  EXPECT_EQ(2 * kOneWayNetworkDelayMs, receiver_.impl_->rtt_ms());
347}
348
349TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_Nack) {
350  EXPECT_EQ(-1, receiver_.RtcpSent().first_packet_time_ms);
351  EXPECT_EQ(-1, sender_.RtcpReceived().first_packet_time_ms);
352  EXPECT_EQ(0U, sender_.RtcpReceived().nack_packets);
353  EXPECT_EQ(0U, receiver_.RtcpSent().nack_packets);
354
355  // Receive module sends a NACK.
356  const uint16_t kNackLength = 1;
357  uint16_t nack_list[kNackLength] = {123};
358  EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list, kNackLength));
359  EXPECT_EQ(1U, receiver_.RtcpSent().nack_packets);
360  EXPECT_GT(receiver_.RtcpSent().first_packet_time_ms, -1);
361
362  // Send module receives the NACK.
363  EXPECT_EQ(1U, sender_.RtcpReceived().nack_packets);
364  EXPECT_GT(sender_.RtcpReceived().first_packet_time_ms, -1);
365}
366
367TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_FirAndPli) {
368  EXPECT_EQ(0U, sender_.RtcpReceived().fir_packets);
369  EXPECT_EQ(0U, receiver_.RtcpSent().fir_packets);
370  // Receive module sends a FIR.
371  EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir));
372  EXPECT_EQ(1U, receiver_.RtcpSent().fir_packets);
373  // Send module receives the FIR.
374  EXPECT_EQ(1U, sender_.RtcpReceived().fir_packets);
375
376  // Receive module sends a FIR and PLI.
377  std::set<RTCPPacketType> packet_types;
378  packet_types.insert(kRtcpFir);
379  packet_types.insert(kRtcpPli);
380  EXPECT_EQ(0, receiver_.impl_->SendCompoundRTCP(packet_types));
381  EXPECT_EQ(2U, receiver_.RtcpSent().fir_packets);
382  EXPECT_EQ(1U, receiver_.RtcpSent().pli_packets);
383  // Send module receives the FIR and PLI.
384  EXPECT_EQ(2U, sender_.RtcpReceived().fir_packets);
385  EXPECT_EQ(1U, sender_.RtcpReceived().pli_packets);
386}
387
388TEST_F(RtpRtcpImplTest, AddStreamDataCounters) {
389  StreamDataCounters rtp;
390  const int64_t kStartTimeMs = 1;
391  rtp.first_packet_time_ms = kStartTimeMs;
392  rtp.transmitted.packets = 1;
393  rtp.transmitted.payload_bytes = 1;
394  rtp.transmitted.header_bytes = 2;
395  rtp.transmitted.padding_bytes = 3;
396  EXPECT_EQ(rtp.transmitted.TotalBytes(), rtp.transmitted.payload_bytes +
397                                          rtp.transmitted.header_bytes +
398                                          rtp.transmitted.padding_bytes);
399
400  StreamDataCounters rtp2;
401  rtp2.first_packet_time_ms = -1;
402  rtp2.transmitted.packets = 10;
403  rtp2.transmitted.payload_bytes = 10;
404  rtp2.retransmitted.header_bytes = 4;
405  rtp2.retransmitted.payload_bytes = 5;
406  rtp2.retransmitted.padding_bytes = 6;
407  rtp2.retransmitted.packets = 7;
408  rtp2.fec.packets = 8;
409
410  StreamDataCounters sum = rtp;
411  sum.Add(rtp2);
412  EXPECT_EQ(kStartTimeMs, sum.first_packet_time_ms);
413  EXPECT_EQ(11U, sum.transmitted.packets);
414  EXPECT_EQ(11U, sum.transmitted.payload_bytes);
415  EXPECT_EQ(2U, sum.transmitted.header_bytes);
416  EXPECT_EQ(3U, sum.transmitted.padding_bytes);
417  EXPECT_EQ(4U, sum.retransmitted.header_bytes);
418  EXPECT_EQ(5U, sum.retransmitted.payload_bytes);
419  EXPECT_EQ(6U, sum.retransmitted.padding_bytes);
420  EXPECT_EQ(7U, sum.retransmitted.packets);
421  EXPECT_EQ(8U, sum.fec.packets);
422  EXPECT_EQ(sum.transmitted.TotalBytes(),
423            rtp.transmitted.TotalBytes() + rtp2.transmitted.TotalBytes());
424
425  StreamDataCounters rtp3;
426  rtp3.first_packet_time_ms = kStartTimeMs + 10;
427  sum.Add(rtp3);
428  EXPECT_EQ(kStartTimeMs, sum.first_packet_time_ms);  // Holds oldest time.
429}
430
431TEST_F(RtpRtcpImplTest, SendsInitialNackList) {
432  // Send module sends a NACK.
433  const uint16_t kNackLength = 1;
434  uint16_t nack_list[kNackLength] = {123};
435  EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
436  EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
437  EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
438  EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
439}
440
441TEST_F(RtpRtcpImplTest, SendsExtendedNackList) {
442  // Send module sends a NACK.
443  const uint16_t kNackLength = 1;
444  uint16_t nack_list[kNackLength] = {123};
445  EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
446  EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
447  EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
448  EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
449
450  // Same list not re-send.
451  EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
452  EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
453  EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
454
455  // Only extended list sent.
456  const uint16_t kNackExtLength = 2;
457  uint16_t nack_list_ext[kNackExtLength] = {123, 124};
458  EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list_ext, kNackExtLength));
459  EXPECT_EQ(2U, sender_.RtcpSent().nack_packets);
460  EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(124));
461}
462
463TEST_F(RtpRtcpImplTest, ReSendsNackListAfterRttMs) {
464  sender_.transport_.SimulateNetworkDelay(0, &clock_);
465  // Send module sends a NACK.
466  const uint16_t kNackLength = 2;
467  uint16_t nack_list[kNackLength] = {123, 125};
468  EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
469  EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
470  EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
471  EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123, 125));
472
473  // Same list not re-send, rtt interval has not passed.
474  const int kStartupRttMs = 100;
475  clock_.AdvanceTimeMilliseconds(kStartupRttMs);
476  EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
477  EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
478
479  // Rtt interval passed, full list sent.
480  clock_.AdvanceTimeMilliseconds(1);
481  EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
482  EXPECT_EQ(2U, sender_.RtcpSent().nack_packets);
483  EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123, 125));
484}
485
486TEST_F(RtpRtcpImplTest, UniqueNackRequests) {
487  receiver_.transport_.SimulateNetworkDelay(0, &clock_);
488  EXPECT_EQ(0U, receiver_.RtcpSent().nack_packets);
489  EXPECT_EQ(0U, receiver_.RtcpSent().nack_requests);
490  EXPECT_EQ(0U, receiver_.RtcpSent().unique_nack_requests);
491  EXPECT_EQ(0, receiver_.RtcpSent().UniqueNackRequestsInPercent());
492
493  // Receive module sends NACK request.
494  const uint16_t kNackLength = 4;
495  uint16_t nack_list[kNackLength] = {10, 11, 13, 18};
496  EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list, kNackLength));
497  EXPECT_EQ(1U, receiver_.RtcpSent().nack_packets);
498  EXPECT_EQ(4U, receiver_.RtcpSent().nack_requests);
499  EXPECT_EQ(4U, receiver_.RtcpSent().unique_nack_requests);
500  EXPECT_THAT(receiver_.LastNackListSent(), ElementsAre(10, 11, 13, 18));
501
502  // Send module receives the request.
503  EXPECT_EQ(1U, sender_.RtcpReceived().nack_packets);
504  EXPECT_EQ(4U, sender_.RtcpReceived().nack_requests);
505  EXPECT_EQ(4U, sender_.RtcpReceived().unique_nack_requests);
506  EXPECT_EQ(100, sender_.RtcpReceived().UniqueNackRequestsInPercent());
507
508  // Receive module sends new request with duplicated packets.
509  const int kStartupRttMs = 100;
510  clock_.AdvanceTimeMilliseconds(kStartupRttMs + 1);
511  const uint16_t kNackLength2 = 4;
512  uint16_t nack_list2[kNackLength2] = {11, 18, 20, 21};
513  EXPECT_EQ(0, receiver_.impl_->SendNACK(nack_list2, kNackLength2));
514  EXPECT_EQ(2U, receiver_.RtcpSent().nack_packets);
515  EXPECT_EQ(8U, receiver_.RtcpSent().nack_requests);
516  EXPECT_EQ(6U, receiver_.RtcpSent().unique_nack_requests);
517  EXPECT_THAT(receiver_.LastNackListSent(), ElementsAre(11, 18, 20, 21));
518
519  // Send module receives the request.
520  EXPECT_EQ(2U, sender_.RtcpReceived().nack_packets);
521  EXPECT_EQ(8U, sender_.RtcpReceived().nack_requests);
522  EXPECT_EQ(6U, sender_.RtcpReceived().unique_nack_requests);
523  EXPECT_EQ(75, sender_.RtcpReceived().UniqueNackRequestsInPercent());
524}
525
526}  // namespace webrtc
527