Append second nack list in same compound rtcp packet

webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <memory>
 
+#include "webrtc/base/arraysize.h"
 #include "webrtc/base/array_view.h"
 #include "webrtc/base/random.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
@@ skipping 1177 matching lines @@
 
   // Stress no transport feedback is expected.
   EXPECT_CALL(transport_feedback_observer_, OnTransportFeedback(_)).Times(0);
   // But remb should be processed and cause a callback
   EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps));
   InjectRtcpPacket(built_packet);
 }
 
 TEST_F(RtcpReceiverTest, Nack) {
   const uint16_t kNackList1[] = {1, 2, 3, 5};
-  const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1);
-  const uint16_t kNackList2[] = {5, 7, 30, 40};
-  const size_t kNackListLength2 = std::end(kNackList2) - std::begin(kNackList2);
+  const uint16_t kNackList23[] = {5, 7, 30, 40, 41, 58, 59, 61, 63};
+  const size_t kNackListLength2 = 4;
+  const size_t kNackListLength3 = arraysize(kNackList23) - kNackListLength2;
   std::set<uint16_t> nack_set;
   nack_set.insert(std::begin(kNackList1), std::end(kNackList1));
-  nack_set.insert(std::begin(kNackList2), std::end(kNackList2));
+  nack_set.insert(std::begin(kNackList23), std::end(kNackList23));
 
-  rtcp::Nack nack;
-  nack.SetSenderSsrc(kSenderSsrc);
-  nack.SetMediaSsrc(kReceiverMainSsrc);
-  nack.SetPacketIds(kNackList1, kNackListLength1);
+  rtcp::Nack nack1;
+  nack1.SetSenderSsrc(kSenderSsrc);
+  nack1.SetMediaSsrc(kReceiverMainSsrc);
+  nack1.SetPacketIds(kNackList1, arraysize(kNackList1));
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList1)));
-  EXPECT_CALL(
-      packet_type_counter_observer_,
-      RtcpPacketTypesCounterUpdated(
-          kReceiverMainSsrc,
-          AllOf(Field(&RtcpPacketTypeCounter::nack_requests, kNackListLength1),
-                Field(&RtcpPacketTypeCounter::unique_nack_requests,
-                      kNackListLength1))));
-  InjectRtcpPacket(nack);
+  EXPECT_CALL(packet_type_counter_observer_,
+              RtcpPacketTypesCounterUpdated(
+                  kReceiverMainSsrc,
+                  AllOf(Field(&RtcpPacketTypeCounter::nack_requests,
+                              arraysize(kNackList1)),
+                        Field(&RtcpPacketTypeCounter::unique_nack_requests,
+                              arraysize(kNackList1)))));
+  InjectRtcpPacket(nack1);
 
   rtcp::Nack nack2;
   nack2.SetSenderSsrc(kSenderSsrc);
   nack2.SetMediaSsrc(kReceiverMainSsrc);
-  nack2.SetPacketIds(kNackList2, kNackListLength2);
-  EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList2)));
+  nack2.SetPacketIds(kNackList23, kNackListLength2);
+
+  rtcp::Nack nack3;
+  nack3.SetSenderSsrc(kSenderSsrc);
+  nack3.SetMediaSsrc(kReceiverMainSsrc);
+  nack3.SetPacketIds(kNackList23 + kNackListLength2, kNackListLength3);
+
+  rtcp::CompoundPacket two_nacks;
+  two_nacks.Append(&nack2);
+  two_nacks.Append(&nack3);
+
+  EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList23)));
   EXPECT_CALL(packet_type_counter_observer_,
               RtcpPacketTypesCounterUpdated(
                   kReceiverMainSsrc,
                   AllOf(Field(&RtcpPacketTypeCounter::nack_requests,
-                              kNackListLength1 + kNackListLength2),
+                              arraysize(kNackList1) + arraysize(kNackList23)),
                         Field(&RtcpPacketTypeCounter::unique_nack_requests,
                               nack_set.size()))));
-  InjectRtcpPacket(nack2);
+  InjectRtcpPacket(two_nacks);
 }
 
 TEST_F(RtcpReceiverTest, NackNotForUsIgnored) {
   const uint16_t kNackList1[] = {1, 2, 3, 5};
   const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1);
 
   rtcp::Nack nack;
   nack.SetSenderSsrc(kSenderSsrc);
   nack.SetMediaSsrc(kNotToUsSsrc);
   nack.SetPacketIds(kNackList1, kNackListLength1);
 
   EXPECT_CALL(packet_type_counter_observer_,
               RtcpPacketTypesCounterUpdated(
                   _, Field(&RtcpPacketTypeCounter::nack_requests, 0)));
   InjectRtcpPacket(nack);
 }
 
 TEST_F(RtcpReceiverTest, ForceSenderReport) {
   rtcp::RapidResyncRequest rr;
   rr.SetSenderSsrc(kSenderSsrc);
   rr.SetMediaSsrc(kReceiverMainSsrc);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport());
   InjectRtcpPacket(rr);
 }
 
 }  // namespace webrtc