Generalize FEC header formatting. (pt. 4)

webrtc/modules/rtp_rtcp/source/rtp_fec_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 <algorithm>
 #include <list>
 #include <memory>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/random.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/fec_test_helper.h"
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
+#include "webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h"
 
 namespace webrtc {
 
 namespace {
 
 // Transport header size in bytes. Assume UDP/IPv4 as a reasonable minimum.
 constexpr size_t kTransportOverhead = 28;
 
 constexpr uint32_t kMediaSsrc = 83542;
 
 // Deep copies |src| to |dst|, but only keeps every Nth packet.
 void DeepCopyEveryNthPacket(const ForwardErrorCorrection::PacketList& src,
                             int n,
                             ForwardErrorCorrection::PacketList* dst) {
   RTC_DCHECK_GT(n, 0);
   int i = 0;
   for (const auto& packet : src) {
     if (i % n == 0) {
       dst->emplace_back(new ForwardErrorCorrection::Packet(*packet));
     }
     ++i;
   }
 }
 
 }  // namespace
 
 using ::testing::Types;
 
+// Subclass ForwardErrorCorrection to use gTest typed tests.
+class UlpfecForwardErrorCorrection : public ForwardErrorCorrection {
+ public:
+  UlpfecForwardErrorCorrection()
+      : ForwardErrorCorrection(
+            std::unique_ptr<FecHeaderReader>(new UlpfecHeaderReader()),
+            std::unique_ptr<FecHeaderWriter>(new UlpfecHeaderWriter())) {}
+};
+
 template <typename ForwardErrorCorrectionType>
 class RtpFecTest : public ::testing::Test {
  protected:
   RtpFecTest()
       : random_(0xabcdef123456),
         media_packet_generator_(
             kRtpHeaderSize,  // Minimum packet size.
             IP_PACKET_SIZE - kRtpHeaderSize - kTransportOverhead -
                 fec_.MaxPacketOverhead(),  // Maximum packet size.
             kMediaSsrc,
@@ skipping 20 matching lines @@
   ForwardErrorCorrectionType fec_;
 
   Random random_;
   test::fec::MediaPacketGenerator media_packet_generator_;
 
   ForwardErrorCorrection::PacketList media_packets_;
   std::list<ForwardErrorCorrection::Packet*> generated_fec_packets_;
   ForwardErrorCorrection::ReceivedPacketList received_packets_;
   ForwardErrorCorrection::RecoveredPacketList recovered_packets_;
 
-  int media_loss_mask_[ForwardErrorCorrection::kMaxMediaPackets];
-  int fec_loss_mask_[ForwardErrorCorrection::kMaxMediaPackets];
+  int media_loss_mask_[kUlpfecMaxMediaPackets];
+  int fec_loss_mask_[kUlpfecMaxMediaPackets];
 };
 
 // Define gTest typed test to loop over both ULPFEC and FlexFEC.
 // Since the tests now are parameterized, we need to access
 // member variables using |this|, thereby enforcing runtime
 // resolution.
-using FecTypes = Types<ForwardErrorCorrection>;
+using FecTypes = Types<UlpfecForwardErrorCorrection>;
 TYPED_TEST_CASE(RtpFecTest, FecTypes);
 
 TYPED_TEST(RtpFecTest, FecRecoveryNoLoss) {
   constexpr int kNumImportantPackets = 0;
   constexpr bool kUseUnequalProtection = false;
   constexpr int kNumMediaPackets = 4;
   constexpr uint8_t kProtectionFactor = 60;
 
   this->media_packets_ =
       this->media_packet_generator_.ConstructMediaPackets(kNumMediaPackets);
@@ skipping 825 matching lines @@
     }
     packet_idx++;
     // Sequence number of FEC packets are defined as increment by 1 from
     // last media packet in frame.
     if (is_fec)
       fec_seq_num++;
   }
 }
 
 }  // namespace webrtc