Generalize FEC header formatting. (pt. 4)

webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc

Index: webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
diff --git a/webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc b/webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b371eb1ed0ef0f5f2b4e582b3581883406d6847c
--- /dev/null
+++ b/webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer_unittest.cc
@@ -0,0 +1,149 @@
+/*
+ *  Copyright (c) 2016 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 <string.h>
+
+#include <memory>
+#include <utility>
+
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/basictypes.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/base/random.h"
+#include "webrtc/base/scoped_ref_ptr.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/forward_error_correction_internal.h"
+#include "webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h"
+
+namespace webrtc {
+
+namespace {
+constexpr uint32_t kMediaSsrc = 1254983;
+constexpr uint16_t kMediaStartSeqNum = 825;
+constexpr size_t kMediaPacketLength = 1234;
+
+constexpr size_t kUlpfecHeaderSizeLBitClear = 14;
+constexpr size_t kUlpfecHeaderSizeLBitSet = 18;
+constexpr size_t kUlpfecPacketMaskOffset = 12;
+}  // namespace
+
+using Packet = ::webrtc::ForwardErrorCorrection::Packet;
+using PacketList = ::webrtc::ForwardErrorCorrection::PacketList;
+using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket;
+
+class UlpfecHeaderReaderWriterTest : public ::testing::Test {
+ protected:
+  UlpfecHeaderReaderWriterTest() : random_(0xabcdef123456) {}
+
+  // Randomly generate packet mask of specified size.
+  void GeneratePacketMask(size_t packet_mask_size);
+
+  std::unique_ptr<Packet> WriteHeader(size_t packet_mask_size);
+  std::unique_ptr<ReceivedFecPacket> ReadHeader(const Packet& packet_to_write);
+
+  void VerifyHeaders(size_t expected_fec_header_size,
+                     size_t expected_packet_mask_size,
+                     const Packet& packet_to_write,
+                     const ReceivedFecPacket& packet_to_read);
+
+  UlpfecHeaderReader reader_;
+  UlpfecHeaderWriter writer_;
+
+  Random random_;
+  uint8_t packet_mask_[kUlpfecMaxPacketMaskSize];
+};
+
+void UlpfecHeaderReaderWriterTest::GeneratePacketMask(size_t packet_mask_size) {
+  RTC_DCHECK_LE(packet_mask_size, kUlpfecMaxPacketMaskSize);
+  memset(packet_mask_, 0u, sizeof(packet_mask_));
+  for (size_t i = 0; i < packet_mask_size; ++i) {
+    packet_mask_[i] = random_.Rand<uint8_t>();
+  }
+}
+
+std::unique_ptr<Packet> UlpfecHeaderReaderWriterTest::WriteHeader(
+    size_t packet_mask_size) {
+  std::unique_ptr<Packet> packet_to_write(new Packet());
+  packet_to_write->length = kMediaPacketLength;
+  for (size_t i = 0; i < packet_to_write->length; ++i) {
+    packet_to_write->data[i] = random_.Rand<uint8_t>();
+  }
+  constexpr uint16_t kSeqNumBase = kMediaStartSeqNum;
+  writer_.FinalizeFecHeader(kSeqNumBase, packet_mask_, packet_mask_size,
+                            packet_to_write.get());
+  return packet_to_write;
+}
+
+std::unique_ptr<ReceivedFecPacket> UlpfecHeaderReaderWriterTest::ReadHeader(
+    const Packet& packet_to_write) {
+  std::unique_ptr<ReceivedFecPacket> packet_to_read(new ReceivedFecPacket());
+  packet_to_read->ssrc = kMediaSsrc;
+  packet_to_read->protected_ssrc = kMediaSsrc;
+  packet_to_read->pkt = rtc::scoped_refptr<Packet>(new Packet());
+  memcpy(packet_to_read->pkt->data, packet_to_write.data,
+         packet_to_write.length);
+  packet_to_read->pkt->length = packet_to_write.length;
+  EXPECT_TRUE(reader_.ReadFecHeader(packet_to_read.get()));
+  return packet_to_read;
+}
+
+void UlpfecHeaderReaderWriterTest::VerifyHeaders(
+    size_t expected_fec_header_size,
+    size_t expected_packet_mask_size,
+    const Packet& packet_to_write,
+    const ReceivedFecPacket& packet_to_read) {
+  EXPECT_EQ(expected_fec_header_size, packet_to_read.fec_header_size);
+  EXPECT_EQ(packet_to_write.length - expected_fec_header_size,
+            packet_to_read.protection_length);
+  EXPECT_EQ(kMediaStartSeqNum, packet_to_read.seq_num_base);

[danilchap, 2016/09/01 12:58:48]

may be add EXPECT_EQ(kMediaSsrc, packet_to_read.protected_ssrc)

[brandtr, 2016/09/01 13:57:36]

Good idea!

+  EXPECT_EQ(kUlpfecPacketMaskOffset, packet_to_read.packet_mask.offset);
+  ASSERT_EQ(expected_packet_mask_size, packet_to_read.packet_mask.size);
+  EXPECT_EQ(0,
+            memcmp(packet_mask_,
+                   &packet_to_read.pkt->data[packet_to_read.packet_mask.offset],
+                   packet_to_read.packet_mask.size));
+  // Verify that the call to ReadFecHeader did not tamper with the payload.
+  EXPECT_EQ(0, memcmp(&packet_to_write.data[expected_fec_header_size],
+                      &packet_to_read.pkt->data[expected_fec_header_size],
+                      packet_to_write.length - expected_fec_header_size));
+}
+
+TEST_F(UlpfecHeaderReaderWriterTest, CalculateSmallHeaderSize) {
+  GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear);
+  EXPECT_EQ(kUlpfecHeaderSizeLBitClear,
+            writer_.FecHeaderSize(writer_.MinPacketMaskSize(
+                packet_mask_, kUlpfecPacketMaskSizeLBitClear)));
+}
+
+TEST_F(UlpfecHeaderReaderWriterTest, CalculateLargeHeaderSize) {
+  GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet);
+  EXPECT_EQ(kUlpfecHeaderSizeLBitSet,
+            writer_.FecHeaderSize(writer_.MinPacketMaskSize(
+                packet_mask_, kUlpfecPacketMaskSizeLBitSet)));
+}
+
+TEST_F(UlpfecHeaderReaderWriterTest, WriteAndReadSmallHeader) {
+  GeneratePacketMask(kUlpfecPacketMaskSizeLBitClear);
+  auto packet_to_write = WriteHeader(kUlpfecPacketMaskSizeLBitClear);
+  auto packet_to_read = ReadHeader(*packet_to_write);
+  VerifyHeaders(kUlpfecHeaderSizeLBitClear, kUlpfecPacketMaskSizeLBitClear,
+                *packet_to_write, *packet_to_read);
+}
+
+TEST_F(UlpfecHeaderReaderWriterTest, WriteAndReadLargeHeader) {
+  GeneratePacketMask(kUlpfecPacketMaskSizeLBitSet);
+  auto packet_to_write = WriteHeader(kUlpfecPacketMaskSizeLBitSet);
+  auto packet_to_read = ReadHeader(*packet_to_write);
+  VerifyHeaders(kUlpfecHeaderSizeLBitSet, kUlpfecPacketMaskSizeLBitSet,
+                *packet_to_write, *packet_to_read);
+}
+
+}  // namespace webrtc