Add FlexFEC header formatters. (pt. 5)

webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer_unittest.cc

+/*
+ *  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/flexfec_header_reader_writer.h"
+#include "webrtc/modules/rtp_rtcp/source/forward_error_correction.h"
+#include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h"
+
+namespace webrtc {
+
+namespace {
+
+using Packet = ::webrtc::ForwardErrorCorrection::Packet;
+using ReceivedFecPacket = ::webrtc::ForwardErrorCorrection::ReceivedFecPacket;
+
+constexpr uint32_t kMediaSsrc = 1254983;
+constexpr uint16_t kMediaStartSeqNum = 825;
+constexpr size_t kMediaPacketLength = 1234;
+constexpr uint32_t kFlexfecSsrc = 52142;
+
+// Assume single-stream protection.
+constexpr size_t kFlexfecHeaderSizeKBit0Set = 20;
+constexpr size_t kFlexfecHeaderSizeKBit1Set = 24;
+constexpr size_t kFlexfecHeaderSizeKBit2Set = 32;
+constexpr size_t kFlexfecPacketMaskOffset = 18;
+constexpr size_t kFlexfecPacketMaskSizeKBit0Set = 2;
+constexpr size_t kFlexfecPacketMaskSizeKBit1Set = 6;
+constexpr size_t kFlexfecPacketMaskSizeKBit2Set = 14;
+constexpr size_t kFlexfecMaxPacketSize = kFlexfecPacketMaskSizeKBit2Set;
+
+std::unique_ptr<uint8_t[]> GeneratePacketMask(size_t packet_mask_size,
+                                              uint64_t seed) {
+  Random random(seed);
+  std::unique_ptr<uint8_t[]> packet_mask(new uint8_t[kFlexfecMaxPacketSize]);
+  memset(packet_mask.get(), 0, kFlexfecMaxPacketSize);
+  for (size_t i = 0; i < packet_mask_size; ++i) {
+    packet_mask[i] = random.Rand<uint8_t>();
+  }
+  return packet_mask;
+}
+
+void ClearBit(size_t index, uint8_t* packet_mask) {
+  packet_mask[index / 8] &= ~(1 << (7 - index % 8));
+}
+
+void SetBit(size_t index, uint8_t* packet_mask) {
+  packet_mask[index / 8] |= (1 << (7 - index % 8));
+}
+
+rtc::scoped_refptr<Packet> WriteHeader(const uint8_t* packet_mask,
+                                       size_t packet_mask_size) {
+  FlexfecHeaderWriter writer;
+  rtc::scoped_refptr<Packet> written_packet(new Packet());
+  written_packet->length = kMediaPacketLength;
+  for (size_t i = 0; i < written_packet->length; ++i) {
+    written_packet->data[i] = i;  // Actual content doesn't matter.
+  }
+  writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, packet_mask,
+                           packet_mask_size, written_packet.get());
+  return written_packet;
+}
+
+std::unique_ptr<ReceivedFecPacket> ReadHeader(const Packet& written_packet) {
+  FlexfecHeaderReader reader;
+  std::unique_ptr<ReceivedFecPacket> read_packet(new ReceivedFecPacket());
+  read_packet->ssrc = kFlexfecSsrc;
+  read_packet->pkt = rtc::scoped_refptr<Packet>(new Packet());
+  memcpy(read_packet->pkt->data, written_packet.data, written_packet.length);
+  read_packet->pkt->length = written_packet.length;
+  EXPECT_TRUE(reader.ReadFecHeader(read_packet.get()));
+  return read_packet;
+}
+
+void VerifyHeaders(size_t expected_fec_header_size,
+                   const uint8_t* expected_packet_mask,
+                   size_t expected_packet_mask_size,
+                   const Packet& written_packet,
+                   const ReceivedFecPacket& read_packet) {
+  EXPECT_EQ(kFlexfecSsrc, read_packet.ssrc);
+  EXPECT_EQ(expected_fec_header_size, read_packet.fec_header_size);
+  EXPECT_EQ(kMediaSsrc, read_packet.protected_ssrc);
+  EXPECT_EQ(kMediaStartSeqNum, read_packet.seq_num_base);
+  EXPECT_EQ(kFlexfecPacketMaskOffset, read_packet.packet_mask_offset);
+  ASSERT_EQ(expected_packet_mask_size, read_packet.packet_mask_size);
+  EXPECT_EQ(written_packet.length - expected_fec_header_size,
+            read_packet.protection_length);
+  // Verify that the call to ReadFecHeader did normalize the packet masks.
+  EXPECT_EQ(0, memcmp(expected_packet_mask,
+                      &read_packet.pkt->data[read_packet.packet_mask_offset],
+                      read_packet.packet_mask_size));
+  // Verify that the call to ReadFecHeader did not tamper with the payload.
+  EXPECT_EQ(0, memcmp(&written_packet.data[expected_fec_header_size],
+                      &read_packet.pkt->data[expected_fec_header_size],
+                      written_packet.length - expected_fec_header_size));
+}
+
+}  // namespace
+
+TEST(FlexfecHeaderReaderTest, CorrectlyReadsHeaderWithKBit0Set) {

[danilchap, 2016/09/14 13:12:09]

'Correctly' is implicit for tests (at least should be), so can be dropped.

[brandtr, 2016/09/20 11:13:33]

Changed.

+  const uint8_t packet[] = {
+      0x00, 0x00, 0xab, 0xcd,  // F, R bits clear, "random" length recovery

[danilchap, 2016/09/14 13:12:09]

remove 'random', it is misleading

[brandtr, 2016/09/20 11:13:33]

Done.

+      0x01, 0x23, 0x45, 0x67,  // "random" TS recovery

[danilchap, 2016/09/14 13:12:09]

what is TS?

[brandtr, 2016/09/20 11:13:32]

TimeStamp. This follows the nomenclature in the Internet Draft.

+      0x01, 0x00, 0x00, 0x00,  // SSRCCount = 1. Reserved bits are zero.

[danilchap, 2016/09/14 13:12:09]

may be 
constexpr size_t kSsrcCount = 1;
constexpr uint8_t kReserved = 0;
kSsrcCount, kReserved, kReserved, kReserved;

[brandtr, 2016/09/20 11:13:32]

Done.

+      0x11, 0x22, 0x33, 0x44,  // "random" SSRC
+      0xaa, 0xbb, 0x88, 0x81,  // "random" SN base, K-bit 0 set, "random" mask

[danilchap, 2016/09/14 13:12:09]

Having 3 comments describing different bytes doesn't help much unless you
remember flexfec header format by heart.
consider
constexpr uint8_t kKBit = 0x80;
0xaa, 0xbb,  // Sequence Number base.
             kKBit | 0x08, 0x81,   // K-bit0 | packet mask.

[brandtr, 2016/09/20 11:13:33]

Changed, now I align the different packet masks with each other.

+      0x00, 0x00, 0x00, 0x00   // payload

[danilchap, 2016/09/14 13:12:09]

try to start comments with Uppercase and finish with a dot.

[brandtr, 2016/09/20 11:13:33]

Done.

+  };
+  const size_t packet_length = sizeof(packet);
+  ReceivedFecPacket read_packet;
+  read_packet.pkt = rtc::scoped_refptr<Packet>(new Packet());
+  memcpy(read_packet.pkt->data, packet, packet_length);
+  read_packet.pkt->length = packet_length;
+  FlexfecHeaderReader reader;
+  EXPECT_TRUE(reader.ReadFecHeader(&read_packet));

[danilchap, 2016/09/14 13:12:09]

add an empty line above to split preparation and execution.

[brandtr, 2016/09/20 11:13:33]

Done.

+
+  EXPECT_EQ(20U, read_packet.fec_header_size);
+  EXPECT_EQ(
+      static_cast<uint32_t>((0x11 << 24) + (0x22 << 16) + (0x33 << 8) + 0x44),

[danilchap, 2016/09/14 13:12:09]

use 0x11223344
or better define a constant above kSsrc = 0x11223344;

[brandtr, 2016/09/20 11:13:33]

Done.

+      read_packet.protected_ssrc);
+  EXPECT_EQ((0xaa << 8) + 0xbb, read_packet.seq_num_base);
+  const size_t packet_mask_offset = read_packet.packet_mask_offset;
+  EXPECT_EQ(18U, packet_mask_offset);
+  const size_t packet_mask_size = read_packet.packet_mask_size;
+  EXPECT_EQ(2U, packet_mask_size);
+  EXPECT_EQ(packet_length - 20, read_packet.protection_length);

[danilchap, 2016/09/14 13:12:09]

what is 20?

[brandtr, 2016/09/20 11:13:33]

It's the FEC header size. This has been clarified, by reusing existing
variables.

+  // Ensure that the K-bits are removed and the packet mask has been packed.
+  const uint8_t ulpfec_packet_mask[] = {0x11, 0x02};

[danilchap, 2016/09/14 13:12:09]

name it as a constant, not a variable and move to preparation part.
May be add a constants part with comments that manually created kPacket matches
constants.

[brandtr, 2016/09/20 11:13:32]

Done.

+  EXPECT_EQ(
+      0, memcmp(ulpfec_packet_mask, read_packet.pkt->data + packet_mask_offset,
+                packet_mask_size));
+}
+
+TEST(FlexfecHeaderReaderTest, CorrectlyReadsHeaderWithKBit1Set) {
+  const uint8_t packet[] = {
+      0x00, 0x00, 0xab, 0xcd,  // F, R bits clear, "random" length recovery
+      0x01, 0x23, 0x45, 0x67,  // "random" TS recovery
+      0x01, 0x00, 0x00, 0x00,  // SSRCCount = 1. Reserved bits are zero.
+      0x44, 0x33, 0x22, 0x11,  // "random" SSRC
+      0xbb, 0xcc, 0x48, 0x81,  // "random" SN base, K-bit 0 clear, "random" mask
+      0x82, 0x11, 0x00, 0x21,  // K-bit 1 set
+      0x00, 0x00, 0x00, 0x00   // payload
+  };
+  const size_t packet_length = sizeof(packet);
+  ReceivedFecPacket read_packet;
+  read_packet.pkt = rtc::scoped_refptr<Packet>(new Packet());
+  memcpy(read_packet.pkt->data, packet, packet_length);
+  read_packet.pkt->length = packet_length;
+  FlexfecHeaderReader reader;
+  EXPECT_TRUE(reader.ReadFecHeader(&read_packet));
+
+  EXPECT_EQ(24U, read_packet.fec_header_size);
+  EXPECT_EQ(
+      static_cast<uint32_t>((0x44 << 24) + (0x33 << 16) + (0x22 << 8) + 0x11),
+      read_packet.protected_ssrc);
+  EXPECT_EQ((0xbb << 8) + 0xcc, read_packet.seq_num_base);
+  const size_t packet_mask_offset = read_packet.packet_mask_offset;
+  EXPECT_EQ(18U, packet_mask_offset);
+  const size_t packet_mask_size = read_packet.packet_mask_size;
+  EXPECT_EQ(6U, packet_mask_size);
+  EXPECT_EQ(packet_length - 24, read_packet.protection_length);
+  // Ensure that the K-bits are removed and the packet mask has been packed.
+  const uint8_t ulpfec_packet_mask[] = {0x91, 0x02, 0x08, 0x44, 0x00, 0x84};
+  EXPECT_EQ(
+      0, memcmp(ulpfec_packet_mask, read_packet.pkt->data + packet_mask_offset,
+                packet_mask_size));
+}
+
+TEST(FlexfecHeaderReaderTest, CorrectlyReadsHeaderWithKBit2Set) {
+  //
+  const uint8_t packet[] = {
+      0x00, 0x00, 0xab, 0xcd,  // F, R bits clear, "random" length recovery
+      0x01, 0x23, 0x45, 0x67,  // "random" TS recovery
+      0x01, 0x00, 0x00, 0x00,  // SSRCCount = 1. Reserved bits are zero.
+      0x4a, 0x3b, 0x2c, 0x1d,  // "random" SSRC
+      0xbd, 0xdb, 0x48, 0x81,  // "random" SN base, K-bit 0 clear, "random" mask
+      0x02, 0x11, 0x00, 0x21,  // K-bit 1 clear
+      0x81, 0x11, 0x11, 0x11,  // K-bit 2 set
+      0x11, 0x11, 0x11, 0x11,  //
+      0x00, 0x00, 0x00, 0x00   // payload
+  };
+  const size_t packet_length = sizeof(packet);
+  ReceivedFecPacket read_packet;
+  read_packet.pkt = rtc::scoped_refptr<Packet>(new Packet());
+  memcpy(read_packet.pkt->data, packet, packet_length);
+  read_packet.pkt->length = packet_length;
+  FlexfecHeaderReader reader;
+  EXPECT_TRUE(reader.ReadFecHeader(&read_packet));
+
+  EXPECT_EQ(32U, read_packet.fec_header_size);
+  EXPECT_EQ(
+      static_cast<uint32_t>((0x4a << 24) + (0x3b << 16) + (0x2c << 8) + 0x1d),
+      read_packet.protected_ssrc);
+  EXPECT_EQ((0xbd << 8) + 0xdb, read_packet.seq_num_base);
+  const size_t packet_mask_offset = read_packet.packet_mask_offset;
+  EXPECT_EQ(18U, packet_mask_offset);
+  const size_t packet_mask_size = read_packet.packet_mask_size;
+  EXPECT_EQ(14U, packet_mask_size);
+  EXPECT_EQ(packet_length - 32, read_packet.protection_length);
+  // Ensure that the K-bits are removed and the packet mask has been packed.
+  const uint8_t ulpfec_packet_mask[] = {0x91, 0x02, 0x08, 0x44, 0x00,
+                                        0x84, 0x08, 0x88, 0x88, 0x88,
+                                        0x88, 0x88, 0x88, 0x88};
+  EXPECT_EQ(
+      0, memcmp(ulpfec_packet_mask, read_packet.pkt->data + packet_mask_offset,
+                packet_mask_size));
+}
+
+TEST(FlexfecHeaderReaderTest, ReadPacketWithoutStreamSpecificHeaderShouldFail) {
+  FlexfecHeaderReader reader;
+
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+
+  // Simulate short received packet.
+  ReceivedFecPacket read_packet;
+  read_packet.ssrc = kFlexfecSsrc;
+  read_packet.pkt = std::move(written_packet);
+  read_packet.pkt->length = 12;
+  EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
+}
+
+TEST(FlexfecHeaderReaderTest, ReadShortPacketWithKBit0SetShouldFail) {
+  FlexfecHeaderReader reader;
+
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+
+  // Simulate short received packet.
+  ReceivedFecPacket read_packet;
+  read_packet.ssrc = kFlexfecSsrc;
+  read_packet.pkt = std::move(written_packet);
+  read_packet.pkt->length = 18;
+  EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
+}
+
+TEST(FlexfecHeaderReaderTest, ReadShortPacketWithKBit1SetShouldFail) {
+  FlexfecHeaderReader reader;
+
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(15, packet_mask.get());  // This expands the packet mask "once".
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+
+  // Simulate short received packet.
+  ReceivedFecPacket read_packet;
+  read_packet.ssrc = kFlexfecSsrc;
+  read_packet.pkt = std::move(written_packet);
+  read_packet.pkt->length = 20;
+  EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
+}
+
+TEST(FlexfecHeaderReaderTest, ReadShortPacketWithKBit2SetShouldFail) {
+  FlexfecHeaderReader reader;
+
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(47, packet_mask.get());  // This expands the packet mask "twice".
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+
+  // Simulate short received packet.
+  ReceivedFecPacket read_packet;
+  read_packet.ssrc = kFlexfecSsrc;
+  read_packet.pkt = std::move(written_packet);
+  read_packet.pkt->length = 24;
+  EXPECT_FALSE(reader.ReadFecHeader(&read_packet));
+}
+
+TEST(FlexfecHeaderWriterTest, CorrectlyFinalizesHeaderWithKBit0Set) {
+  const uint8_t ulpfec_packet_mask[] = {0x11, 0x02};
+  Packet written_packet;
+  written_packet.length = kMediaPacketLength;
+  for (size_t i = 0; i < written_packet.length; ++i) {
+    written_packet.data[i] = i;
+  }
+  FlexfecHeaderWriter writer;
+  writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, ulpfec_packet_mask,
+                           sizeof(ulpfec_packet_mask), &written_packet);
+
+  const uint8_t* packet = written_packet.data;
+  EXPECT_EQ(0x00, packet[0] & 0xc0);  // F and R bits clear.
+  EXPECT_EQ(0x01, packet[8]);         // SSRCCount = 1
+  EXPECT_EQ(kMediaSsrc,
+            static_cast<uint32_t>((packet[12] << 24) + (packet[13] << 16) +

[danilchap, 2016/09/14 13:12:09]

may be 
EXPECT_EQ(kMediaSsrc, ByteReader<uint32_t>::ReadBigEndian(packet + 12));

[brandtr, 2016/09/20 11:13:33]

Done.

+                                  (packet[14] << 8) + packet[15]));
+  EXPECT_EQ(kMediaStartSeqNum,
+            static_cast<uint16_t>((packet[16] << 8) + packet[17]));
+  const uint8_t flexfec_packet_mask[] = {0x88, 0x81};
+  EXPECT_EQ(
+      0, memcmp(flexfec_packet_mask, packet + 18, sizeof(flexfec_packet_mask)));

[danilchap, 2016/09/14 13:12:09]

might be better to split into 2 expectations:
EXPECT_EQ(kFlexfecPacketMask[0], packet[18]);
EXPECT_EQ(kFlexfecPacketMask[1], packet[19]);
this way if it failes, you can also see the values of expected and actual bytes,
but with memcmp all you would see is that they are different.
(but avoid using for loop - with it will be hard to see which byte is different)
Or, consider using gmock matchers to compare arrays:
EXPECT_THAT(::testing::make_tuple(packet + 18, 2), ElementsAre(0x88, 0x81)); //
Or ElementsAreArray(kFlexfexPacketMask);

[brandtr, 2016/09/20 11:13:33]

Done.

Thanks for writing out the gmock code for me! I find that that library has a
steep learning curve for the syntax...

+}
+
+TEST(FlexfecHeaderWriterTest, CorrectlyFinalizesHeaderWithKBit1Set) {
+  const uint8_t ulpfec_packet_mask[] = {0x91, 0x02, 0x08, 0x44, 0x00, 0x84};
+  Packet written_packet;
+  written_packet.length = kMediaPacketLength;
+  for (size_t i = 0; i < written_packet.length; ++i) {
+    written_packet.data[i] = i;
+  }
+  FlexfecHeaderWriter writer;
+  writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, ulpfec_packet_mask,
+                           sizeof(ulpfec_packet_mask), &written_packet);
+
+  const uint8_t* packet = written_packet.data;
+  EXPECT_EQ(0x00, packet[0] & 0xc0);  // F and R bits clear.

[danilchap, 2016/09/14 13:12:09]

may be test seperatly:
constexpr uint8_t kFbit = 1 << 7;
constexpr uint8_t kRbit = 1 << 6;
EXPECT_FALSE(packet[0] & kFbit);
EXPECT_FALSE(packet[0] & kRbit);

[brandtr, 2016/09/20 11:13:32]

Done.

+  EXPECT_EQ(0x01, packet[8]);         // SSRCCount = 1
+  EXPECT_EQ(kMediaSsrc,
+            static_cast<uint32_t>((packet[12] << 24) + (packet[13] << 16) +
+                                  (packet[14] << 8) + packet[15]));
+  EXPECT_EQ(kMediaStartSeqNum,
+            static_cast<uint16_t>((packet[16] << 8) + packet[17]));
+  const uint8_t flexfec_packet_mask[] = {0x48, 0x81, 0x82, 0x11, 0x00, 0x21};
+  EXPECT_EQ(
+      0, memcmp(flexfec_packet_mask, packet + 18, sizeof(flexfec_packet_mask)));
+}
+
+TEST(FlexfecHeaderWriterTest, CorrectlyFinalizesHeaderWithKBit2Set) {
+  const uint8_t ulpfec_packet_mask[] = {0x22, 0x22, 0x44, 0x44, 0x44, 0x41};
+  Packet written_packet;
+  written_packet.length = kMediaPacketLength;
+  for (size_t i = 0; i < written_packet.length; ++i) {
+    written_packet.data[i] = i;
+  }
+  FlexfecHeaderWriter writer;
+  writer.FinalizeFecHeader(kMediaSsrc, kMediaStartSeqNum, ulpfec_packet_mask,
+                           sizeof(ulpfec_packet_mask), &written_packet);
+
+  const uint8_t* packet = written_packet.data;
+  EXPECT_EQ(0x00, packet[0] & 0xc0);  // F and R bits clear.
+  EXPECT_EQ(0x01, packet[8]);         // SSRCCount = 1
+  EXPECT_EQ(kMediaSsrc,
+            static_cast<uint32_t>((packet[12] << 24) + (packet[13] << 16) +
+                                  (packet[14] << 8) + packet[15]));
+  EXPECT_EQ(kMediaStartSeqNum,
+            static_cast<uint16_t>((packet[16] << 8) + packet[17]));
+  const uint8_t flexfec_packet_mask[] = {
+      0x11, 0x11,                                     // K-bit 0 clear.
+      0x11, 0x11, 0x11, 0x10,                         // K-bit 1 clear.
+      0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // K-bit 2 set.
+  };
+  EXPECT_EQ(
+      0, memcmp(flexfec_packet_mask, packet + 18, sizeof(flexfec_packet_mask)));
+}
+
+TEST(FlexfecHeaderWriterTest, ContractsShortUlpfecPacketMaskWithBit15Clear) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(15, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSizeKBit0Set, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSizeKBit0Set,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderWriterTest, ExpandsShortUlpfecPacketMaskWithBit15Set) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(15, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSizeKBit1Set, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSizeKBit1Set,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderWriterTest,
+     ContractsLongUlpfecPacketMaskWithBits46And47Clear) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(46, packet_mask.get());
+  ClearBit(47, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSizeKBit1Set, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSizeKBit1Set,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderWriterTest, ExpandsLongUlpfecPacketMaskWithBits46And47Clear) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(46, packet_mask.get());
+  ClearBit(47, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSizeKBit2Set, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSizeKBit2Set,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderWriterTest,
+     ExpandsLongUlpfecPacketMaskWithBit46ClearBit47Set) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(46, packet_mask.get());
+  SetBit(47, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSizeKBit2Set, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSizeKBit2Set,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderWriterTest, ExpandsLongUlpfecPacketMaskWithBits46And47Set) {
+  FlexfecHeaderWriter writer;
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(46, packet_mask.get());
+  SetBit(47, packet_mask.get());
+  size_t min_packet_mask_size =
+      writer.MinPacketMaskSize(packet_mask.get(), packet_mask_size);
+  EXPECT_EQ(kFlexfecPacketMaskSizeKBit2Set, min_packet_mask_size);
+  EXPECT_EQ(kFlexfecHeaderSizeKBit2Set,
+            writer.FecHeaderSize(min_packet_mask_size));
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadSmallUlpfecPacketHeaderWithMaskBit15Clear) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(15, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSizeKBit0Set, packet_mask.get(),
+                kFlexfecPacketMaskSizeKBit0Set, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadSmallUlpfecPacketHeaderWithMaskBit15Set) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitClear;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(15, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSizeKBit1Set, packet_mask.get(),
+                kFlexfecPacketMaskSizeKBit1Set, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadLargeUlpfecPacketHeaderWithMaskBits46And47Clear) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(46, packet_mask.get());
+  ClearBit(47, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSizeKBit1Set, packet_mask.get(),
+                kFlexfecPacketMaskSizeKBit1Set, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadLargeUlpfecPacketHeaderWithMaskBit46SetBit47Clear) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(46, packet_mask.get());
+  ClearBit(47, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSizeKBit2Set, packet_mask.get(),
+                kFlexfecPacketMaskSizeKBit2Set, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadLargeUlpfecPacketHeaderMaskWithBit46ClearBit47Set) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  ClearBit(46, packet_mask.get());
+  SetBit(47, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSizeKBit2Set, packet_mask.get(),
+                kFlexfecPacketMaskSizeKBit2Set, *written_packet, *read_packet);
+}
+
+TEST(FlexfecHeaderReaderWriterTest,
+     WriteAndReadLargeUlpfecPacketHeaderWithMaskBits46And47Set) {
+  const size_t packet_mask_size = kUlpfecPacketMaskSizeLBitSet;
+  auto packet_mask = GeneratePacketMask(packet_mask_size, 0xabcd);
+  SetBit(46, packet_mask.get());
+  SetBit(47, packet_mask.get());
+  auto written_packet = WriteHeader(packet_mask.get(), packet_mask_size);
+  auto read_packet = ReadHeader(*written_packet);
+  VerifyHeaders(kFlexfecHeaderSizeKBit2Set, packet_mask.get(),
+                kFlexfecPacketMaskSizeKBit2Set, *written_packet, *read_packet);
+}
+
+}  // namespace webrtc