/*
 *  Copyright (c) 2015 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 "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"

#include <limits>
#include <memory>
#include <utility>

#include "absl/types/optional.h"
#include "api/array_view.h"
#include "api/units/time_delta.h"
#include "api/units/timestamp.h"
#include "modules/rtp_rtcp/source/byte_io.h"
#include "modules/rtp_rtcp/source/rtcp_packet/common_header.h"
#include "test/gmock.h"
#include "test/gtest.h"

namespace webrtc {
namespace {

using rtcp::TransportFeedback;
using ::testing::AllOf;
using ::testing::Each;
using ::testing::ElementsAreArray;
using ::testing::Eq;
using ::testing::InSequence;
using ::testing::MockFunction;
using ::testing::Ne;
using ::testing::Property;
using ::testing::SizeIs;

constexpr int kHeaderSize = 20;
constexpr int kStatusChunkSize = 2;
constexpr int kSmallDeltaSize = 1;
constexpr int kLargeDeltaSize = 2;

constexpr TimeDelta kDeltaLimit = 0xFF * TransportFeedback::kDeltaTick;
constexpr TimeDelta kBaseTimeTick = TransportFeedback::kDeltaTick * (1 << 8);
constexpr TimeDelta kBaseTimeWrapPeriod = kBaseTimeTick * (1 << 24);

MATCHER_P2(Near, value, max_abs_error, "") {
  return value - max_abs_error <= arg && arg <= value + max_abs_error;
}

MATCHER(IsValidFeedback, "") {
  rtcp::CommonHeader rtcp_header;
  TransportFeedback feedback;
  return rtcp_header.Parse(std::data(arg), std::size(arg)) &&
         rtcp_header.type() == TransportFeedback::kPacketType &&
         rtcp_header.fmt() == TransportFeedback::kFeedbackMessageType &&
         feedback.Parse(rtcp_header);
}

TransportFeedback Parse(rtc::ArrayView<const uint8_t> buffer) {
  rtcp::CommonHeader header;
  EXPECT_TRUE(header.Parse(buffer.data(), buffer.size()));
  EXPECT_EQ(header.type(), TransportFeedback::kPacketType);
  EXPECT_EQ(header.fmt(), TransportFeedback::kFeedbackMessageType);
  TransportFeedback feedback;
  EXPECT_TRUE(feedback.Parse(header));
  return feedback;
}

class FeedbackTester {
 public:
  FeedbackTester() : FeedbackTester(true) {}
  explicit FeedbackTester(bool include_timestamps)
      : expected_size_(kAnySize),
        default_delta_(TransportFeedback::kDeltaTick * 4),
        include_timestamps_(include_timestamps) {}

  void WithExpectedSize(size_t expected_size) {
    expected_size_ = expected_size;
  }

  void WithDefaultDelta(TimeDelta delta) { default_delta_ = delta; }

  void WithInput(rtc::ArrayView<const uint16_t> received_seq,
                 rtc::ArrayView<const Timestamp> received_ts = {}) {
    std::vector<Timestamp> temp_timestamps;
    if (received_ts.empty()) {
      temp_timestamps = GenerateReceiveTimestamps(received_seq);
      received_ts = temp_timestamps;
    }
    ASSERT_EQ(received_seq.size(), received_ts.size());

    expected_deltas_.clear();
    feedback_.emplace(include_timestamps_);
    feedback_->SetBase(received_seq[0], received_ts[0]);
    ASSERT_TRUE(feedback_->IsConsistent());
    // First delta is special: it doesn't represent the delta between two times,
    // but a compensation for the reduced precision of the base time.
    EXPECT_TRUE(feedback_->AddReceivedPacket(received_seq[0], received_ts[0]));
    // GetBaseDelta suppose to return balanced diff between base time of the new
    // feedback message (stored internally) and base time of the old feedback
    // message (passed as parameter), but first delta is the difference between
    // 1st timestamp (passed as parameter) and base time (stored internally),
    // thus to get the first delta need to negate whatever GetBaseDelta returns.
    expected_deltas_.push_back(-feedback_->GetBaseDelta(received_ts[0]));

    for (size_t i = 1; i < received_ts.size(); ++i) {
      EXPECT_TRUE(
          feedback_->AddReceivedPacket(received_seq[i], received_ts[i]));
      expected_deltas_.push_back(received_ts[i] - received_ts[i - 1]);
    }
    ASSERT_TRUE(feedback_->IsConsistent());
    expected_seq_.assign(received_seq.begin(), received_seq.end());
  }

  void VerifyPacket() {
    ASSERT_TRUE(feedback_->IsConsistent());
    serialized_ = feedback_->Build();
    VerifyInternal();

    feedback_.emplace(Parse(serialized_));
    ASSERT_TRUE(feedback_->IsConsistent());
    EXPECT_EQ(include_timestamps_, feedback_->IncludeTimestamps());
    VerifyInternal();
  }

  static constexpr size_t kAnySize = static_cast<size_t>(0) - 1;

 private:
  void VerifyInternal() {
    if (expected_size_ != kAnySize) {
      // Round up to whole 32-bit words.
      size_t expected_size_words = (expected_size_ + 3) / 4;
      size_t expected_size_bytes = expected_size_words * 4;
      EXPECT_EQ(expected_size_bytes, serialized_.size());
    }

    std::vector<uint16_t> actual_seq_nos;
    std::vector<TimeDelta> actual_deltas;
    for (const auto& packet : feedback_->GetReceivedPackets()) {
      actual_seq_nos.push_back(packet.sequence_number());
      actual_deltas.push_back(packet.delta());
    }
    EXPECT_THAT(actual_seq_nos, ElementsAreArray(expected_seq_));
    if (include_timestamps_) {
      EXPECT_THAT(actual_deltas, ElementsAreArray(expected_deltas_));
    }
  }

  std::vector<Timestamp> GenerateReceiveTimestamps(
      rtc::ArrayView<const uint16_t> seq_nums) {
    RTC_CHECK(!seq_nums.empty());
    uint16_t last_seq = seq_nums[0];
    Timestamp time = Timestamp::Zero();
    std::vector<Timestamp> result;

    for (uint16_t seq : seq_nums) {
      if (seq < last_seq)
        time += 0x10000 * default_delta_;
      last_seq = seq;

      result.push_back(time + last_seq * default_delta_);
    }
    return result;
  }

  std::vector<uint16_t> expected_seq_;
  std::vector<TimeDelta> expected_deltas_;
  size_t expected_size_;
  TimeDelta default_delta_;
  absl::optional<TransportFeedback> feedback_;
  rtc::Buffer serialized_;
  bool include_timestamps_;
};

// The following tests use FeedbackTester that simulates received packets as
// specified by the parameters `received_seq[]` and `received_ts[]` (optional).
// The following is verified in these tests:
// - Expected size of serialized packet.
// - Expected sequence numbers and receive deltas.
// - Sequence numbers and receive deltas are persistent after serialization
//   followed by parsing.
// - The internal state of a feedback packet is consistent.
TEST(RtcpPacketTest, TransportFeedbackOneBitVector) {
  const uint16_t kReceived[] = {1, 2, 7, 8, 9, 10, 13};
  const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
  const size_t kExpectedSizeBytes =
      kHeaderSize + kStatusChunkSize + (kLength * kSmallDeltaSize);

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackOneBitVectorNoRecvDelta) {
  const uint16_t kReceived[] = {1, 2, 7, 8, 9, 10, 13};
  const size_t kExpectedSizeBytes = kHeaderSize + kStatusChunkSize;

  FeedbackTester test(/*include_timestamps=*/false);
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackFullOneBitVector) {
  const uint16_t kReceived[] = {1, 2, 7, 8, 9, 10, 13, 14};
  const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
  const size_t kExpectedSizeBytes =
      kHeaderSize + kStatusChunkSize + (kLength * kSmallDeltaSize);

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackOneBitVectorWrapReceived) {
  const uint16_t kMax = 0xFFFF;
  const uint16_t kReceived[] = {kMax - 2, kMax - 1, kMax, 0, 1, 2};
  const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
  const size_t kExpectedSizeBytes =
      kHeaderSize + kStatusChunkSize + (kLength * kSmallDeltaSize);

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackOneBitVectorWrapMissing) {
  const uint16_t kMax = 0xFFFF;
  const uint16_t kReceived[] = {kMax - 2, kMax - 1, 1, 2};
  const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
  const size_t kExpectedSizeBytes =
      kHeaderSize + kStatusChunkSize + (kLength * kSmallDeltaSize);

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackTwoBitVector) {
  const uint16_t kReceived[] = {1, 2, 6, 7};
  const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
  const size_t kExpectedSizeBytes =
      kHeaderSize + kStatusChunkSize + (kLength * kLargeDeltaSize);

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithDefaultDelta(kDeltaLimit + TransportFeedback::kDeltaTick);
  test.WithInput(kReceived);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackTwoBitVectorFull) {
  const uint16_t kReceived[] = {1, 2, 6, 7, 8};
  const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
  const size_t kExpectedSizeBytes =
      kHeaderSize + (2 * kStatusChunkSize) + (kLength * kLargeDeltaSize);

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithDefaultDelta(kDeltaLimit + TransportFeedback::kDeltaTick);
  test.WithInput(kReceived);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackWithLargeBaseTimeIsConsistent) {
  TransportFeedback tb;
  constexpr Timestamp kTimestamp =
      Timestamp::Zero() + int64_t{0x7fff'ffff} * TransportFeedback::kDeltaTick;
  tb.SetBase(/*base_sequence=*/0, /*ref_timestamp=*/kTimestamp);
  tb.AddReceivedPacket(/*base_sequence=*/0, /*ref_timestamp=*/kTimestamp);
  EXPECT_TRUE(tb.IsConsistent());
}

TEST(RtcpPacketTest, TransportFeedbackLargeAndNegativeDeltas) {
  const uint16_t kReceived[] = {1, 2, 6, 7, 8};
  const Timestamp kReceiveTimes[] = {
      Timestamp::Millis(2), Timestamp::Millis(1), Timestamp::Millis(4),
      Timestamp::Millis(3),
      Timestamp::Millis(3) + TransportFeedback::kDeltaTick * (1 << 8)};
  const size_t kExpectedSizeBytes =
      kHeaderSize + kStatusChunkSize + (3 * kLargeDeltaSize) + kSmallDeltaSize;

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived, kReceiveTimes);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackMaxRle) {
  // Expected chunks created:
  // * 1-bit vector chunk (1xreceived + 13xdropped)
  // * RLE chunk of max length for dropped symbol
  // * 1-bit vector chunk (1xreceived + 13xdropped)

  const size_t kPacketCount = (1 << 13) - 1 + 14;
  const uint16_t kReceived[] = {0, kPacketCount};
  const Timestamp kReceiveTimes[] = {Timestamp::Millis(1),
                                     Timestamp::Millis(2)};
  const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
  const size_t kExpectedSizeBytes =
      kHeaderSize + (3 * kStatusChunkSize) + (kLength * kSmallDeltaSize);

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived, kReceiveTimes);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackMinRle) {
  // Expected chunks created:
  // * 1-bit vector chunk (1xreceived + 13xdropped)
  // * RLE chunk of length 15 for dropped symbol
  // * 1-bit vector chunk (1xreceived + 13xdropped)

  const uint16_t kReceived[] = {0, (14 * 2) + 1};
  const Timestamp kReceiveTimes[] = {Timestamp::Millis(1),
                                     Timestamp::Millis(2)};
  const size_t kLength = sizeof(kReceived) / sizeof(uint16_t);
  const size_t kExpectedSizeBytes =
      kHeaderSize + (3 * kStatusChunkSize) + (kLength * kSmallDeltaSize);

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived, kReceiveTimes);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackOneToTwoBitVector) {
  const size_t kTwoBitVectorCapacity = 7;
  const uint16_t kReceived[] = {0, kTwoBitVectorCapacity - 1};
  const Timestamp kReceiveTimes[] = {
      Timestamp::Zero(),
      Timestamp::Zero() + kDeltaLimit + TransportFeedback::kDeltaTick};
  const size_t kExpectedSizeBytes =
      kHeaderSize + kStatusChunkSize + kSmallDeltaSize + kLargeDeltaSize;

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived, kReceiveTimes);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackOneToTwoBitVectorSimpleSplit) {
  const size_t kTwoBitVectorCapacity = 7;
  const uint16_t kReceived[] = {0, kTwoBitVectorCapacity};
  const Timestamp kReceiveTimes[] = {
      Timestamp::Zero(),
      Timestamp::Zero() + kDeltaLimit + TransportFeedback::kDeltaTick};
  const size_t kExpectedSizeBytes =
      kHeaderSize + (kStatusChunkSize * 2) + kSmallDeltaSize + kLargeDeltaSize;

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived, kReceiveTimes);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackOneToTwoBitVectorSplit) {
  // With received small delta = S, received large delta = L, use input
  // SSSSSSSSLSSSSSSSSSSSS. This will cause a 1:2 split at the L.
  // After split there will be two symbols in symbol_vec: SL.

  const TimeDelta kLargeDelta = TransportFeedback::kDeltaTick * (1 << 8);
  const size_t kNumPackets = (3 * 7) + 1;
  const size_t kExpectedSizeBytes = kHeaderSize + (kStatusChunkSize * 3) +
                                    (kSmallDeltaSize * (kNumPackets - 1)) +
                                    (kLargeDeltaSize * 1);

  uint16_t kReceived[kNumPackets];
  for (size_t i = 0; i < kNumPackets; ++i)
    kReceived[i] = i;

  std::vector<Timestamp> receive_times;
  receive_times.reserve(kNumPackets);
  receive_times.push_back(Timestamp::Millis(1));
  for (size_t i = 1; i < kNumPackets; ++i) {
    TimeDelta delta = (i == 8) ? kLargeDelta : TimeDelta::Millis(1);
    receive_times.push_back(receive_times.back() + delta);
  }

  FeedbackTester test;
  test.WithExpectedSize(kExpectedSizeBytes);
  test.WithInput(kReceived, receive_times);
  test.VerifyPacket();
}

TEST(RtcpPacketTest, TransportFeedbackAliasing) {
  TransportFeedback feedback;
  feedback.SetBase(0, Timestamp::Zero());

  const int kSamples = 100;
  const TimeDelta kTooSmallDelta = TransportFeedback::kDeltaTick / 3;

  for (int i = 0; i < kSamples; ++i)
    feedback.AddReceivedPacket(i, Timestamp::Zero() + i * kTooSmallDelta);

  feedback.Build();

  TimeDelta accumulated_delta = TimeDelta::Zero();
  int num_samples = 0;
  for (const auto& packet : feedback.GetReceivedPackets()) {
    accumulated_delta += packet.delta();
    TimeDelta expected_time = num_samples * kTooSmallDelta;
    ++num_samples;

    EXPECT_THAT(accumulated_delta,
                Near(expected_time, TransportFeedback::kDeltaTick / 2));
  }
}

TEST(RtcpPacketTest, TransportFeedbackLimits) {
  // Sequence number wrap above 0x8000.
  std::unique_ptr<TransportFeedback> packet(new TransportFeedback());
  packet->SetBase(0, Timestamp::Zero());
  EXPECT_TRUE(packet->AddReceivedPacket(0x0, Timestamp::Zero()));
  EXPECT_TRUE(packet->AddReceivedPacket(0x8000, Timestamp::Millis(1)));

  packet.reset(new TransportFeedback());
  packet->SetBase(0, Timestamp::Zero());
  EXPECT_TRUE(packet->AddReceivedPacket(0x0, Timestamp::Zero()));
  EXPECT_FALSE(packet->AddReceivedPacket(0x8000 + 1, Timestamp::Millis(1)));

  // Packet status count max 0xFFFF.
  packet.reset(new TransportFeedback());
  packet->SetBase(0, Timestamp::Zero());
  EXPECT_TRUE(packet->AddReceivedPacket(0x0, Timestamp::Zero()));
  EXPECT_TRUE(packet->AddReceivedPacket(0x8000, Timestamp::Millis(1)));
  EXPECT_TRUE(packet->AddReceivedPacket(0xFFFE, Timestamp::Millis(2)));
  EXPECT_FALSE(packet->AddReceivedPacket(0xFFFF, Timestamp::Millis(3)));

  // Too large delta.
  packet.reset(new TransportFeedback());
  packet->SetBase(0, Timestamp::Zero());
  TimeDelta kMaxPositiveTimeDelta =
      std::numeric_limits<int16_t>::max() * TransportFeedback::kDeltaTick;
  EXPECT_FALSE(packet->AddReceivedPacket(1, Timestamp::Zero() +
                                                kMaxPositiveTimeDelta +
                                                TransportFeedback::kDeltaTick));
  EXPECT_TRUE(
      packet->AddReceivedPacket(1, Timestamp::Zero() + kMaxPositiveTimeDelta));

  // Too large negative delta.
  packet.reset(new TransportFeedback());
  TimeDelta kMaxNegativeTimeDelta =
      std::numeric_limits<int16_t>::min() * TransportFeedback::kDeltaTick;
  // Use larger base time to avoid kBaseTime + kNegativeDelta to be negative.
  Timestamp kBaseTime = Timestamp::Seconds(1'000'000);
  packet->SetBase(0, kBaseTime);
  EXPECT_FALSE(packet->AddReceivedPacket(
      1, kBaseTime + kMaxNegativeTimeDelta - TransportFeedback::kDeltaTick));
  EXPECT_TRUE(packet->AddReceivedPacket(1, kBaseTime + kMaxNegativeTimeDelta));

  // TODO(sprang): Once we support max length lower than RTCP length limit,
  // add back test for max size in bytes.
}

TEST(RtcpPacketTest, BaseTimeIsConsistentAcrossMultiplePackets) {
  constexpr Timestamp kMaxBaseTime =
      Timestamp::Zero() + kBaseTimeWrapPeriod - kBaseTimeTick;

  TransportFeedback packet1;
  packet1.SetBase(0, kMaxBaseTime);
  packet1.AddReceivedPacket(0, kMaxBaseTime);
  // Build and parse packet to simulate sending it over the wire.
  TransportFeedback parsed_packet1 = Parse(packet1.Build());

  TransportFeedback packet2;
  packet2.SetBase(1, kMaxBaseTime + kBaseTimeTick);
  packet2.AddReceivedPacket(1, kMaxBaseTime + kBaseTimeTick);
  TransportFeedback parsed_packet2 = Parse(packet2.Build());

  EXPECT_EQ(parsed_packet2.GetBaseDelta(parsed_packet1.BaseTime()),
            kBaseTimeTick);
}

TEST(RtcpPacketTest, SupportsMaximumNumberOfNegativeDeltas) {
  TransportFeedback feedback;
  // Use large base time to avoid hitting zero limit while filling the feedback,
  // but use multiple of kBaseTimeWrapPeriod to hit edge case where base time
  // is recorded as zero in the raw rtcp packet.
  Timestamp time = Timestamp::Zero() + 1'000 * kBaseTimeWrapPeriod;
  feedback.SetBase(0, time);
  static constexpr TimeDelta kMinDelta =
      TransportFeedback::kDeltaTick * std::numeric_limits<int16_t>::min();
  uint16_t num_received_rtp_packets = 0;
  time += kMinDelta;
  while (feedback.AddReceivedPacket(++num_received_rtp_packets, time)) {
    ASSERT_GE(time, Timestamp::Zero() - kMinDelta);
    time += kMinDelta;
  }
  // Subtract one last packet that failed to add.
  --num_received_rtp_packets;
  EXPECT_TRUE(feedback.IsConsistent());

  TransportFeedback parsed = Parse(feedback.Build());
  EXPECT_EQ(parsed.GetReceivedPackets().size(), num_received_rtp_packets);
  EXPECT_THAT(parsed.GetReceivedPackets(),
              AllOf(SizeIs(num_received_rtp_packets),
                    Each(Property(&TransportFeedback::ReceivedPacket::delta,
                                  Eq(kMinDelta)))));
  EXPECT_GE(parsed.BaseTime(),
            Timestamp::Zero() - kMinDelta * num_received_rtp_packets);
}

TEST(RtcpPacketTest, TransportFeedbackPadding) {
  const size_t kExpectedSizeBytes =
      kHeaderSize + kStatusChunkSize + kSmallDeltaSize;
  const size_t kExpectedSizeWords = (kExpectedSizeBytes + 3) / 4;
  const size_t kExpectedPaddingSizeBytes =
      4 * kExpectedSizeWords - kExpectedSizeBytes;

  TransportFeedback feedback;
  feedback.SetBase(0, Timestamp::Zero());
  EXPECT_TRUE(feedback.AddReceivedPacket(0, Timestamp::Zero()));

  rtc::Buffer packet = feedback.Build();
  EXPECT_EQ(kExpectedSizeWords * 4, packet.size());
  ASSERT_GT(kExpectedSizeWords * 4, kExpectedSizeBytes);
  for (size_t i = kExpectedSizeBytes; i < (kExpectedSizeWords * 4 - 1); ++i)
    EXPECT_EQ(0u, packet[i]);

  EXPECT_EQ(kExpectedPaddingSizeBytes, packet[kExpectedSizeWords * 4 - 1]);

  // Modify packet by adding 4 bytes of padding at the end. Not currently used
  // when we're sending, but need to be able to handle it when receiving.

  const int kPaddingBytes = 4;
  const size_t kExpectedSizeWithPadding =
      (kExpectedSizeWords * 4) + kPaddingBytes;
  uint8_t mod_buffer[kExpectedSizeWithPadding];
  memcpy(mod_buffer, packet.data(), kExpectedSizeWords * 4);
  memset(&mod_buffer[kExpectedSizeWords * 4], 0, kPaddingBytes - 1);
  mod_buffer[kExpectedSizeWithPadding - 1] =
      kPaddingBytes + kExpectedPaddingSizeBytes;
  const uint8_t padding_flag = 1 << 5;
  mod_buffer[0] |= padding_flag;
  ByteWriter<uint16_t>::WriteBigEndian(
      &mod_buffer[2], ByteReader<uint16_t>::ReadBigEndian(&mod_buffer[2]) +
                          ((kPaddingBytes + 3) / 4));

  EXPECT_THAT(mod_buffer, IsValidFeedback());
}

TEST(RtcpPacketTest, TransportFeedbackPaddingBackwardsCompatibility) {
  const size_t kExpectedSizeBytes =
      kHeaderSize + kStatusChunkSize + kSmallDeltaSize;
  const size_t kExpectedSizeWords = (kExpectedSizeBytes + 3) / 4;
  const size_t kExpectedPaddingSizeBytes =
      4 * kExpectedSizeWords - kExpectedSizeBytes;

  TransportFeedback feedback;
  feedback.SetBase(0, Timestamp::Zero());
  EXPECT_TRUE(feedback.AddReceivedPacket(0, Timestamp::Zero()));

  rtc::Buffer packet = feedback.Build();
  EXPECT_EQ(kExpectedSizeWords * 4, packet.size());
  ASSERT_GT(kExpectedSizeWords * 4, kExpectedSizeBytes);
  for (size_t i = kExpectedSizeBytes; i < (kExpectedSizeWords * 4 - 1); ++i)
    EXPECT_EQ(0u, packet[i]);

  EXPECT_GT(kExpectedPaddingSizeBytes, 0u);
  EXPECT_EQ(kExpectedPaddingSizeBytes, packet[kExpectedSizeWords * 4 - 1]);

  // Modify packet by removing padding bit and writing zero at the last padding
  // byte to verify that we can parse packets from old clients, where zero
  // padding of up to three bytes was used without the padding bit being set.
  uint8_t mod_buffer[kExpectedSizeWords * 4];
  memcpy(mod_buffer, packet.data(), kExpectedSizeWords * 4);
  mod_buffer[kExpectedSizeWords * 4 - 1] = 0;
  const uint8_t padding_flag = 1 << 5;
  mod_buffer[0] &= ~padding_flag;  // Unset padding flag.

  EXPECT_THAT(mod_buffer, IsValidFeedback());
}

TEST(RtcpPacketTest, TransportFeedbackCorrectlySplitsVectorChunks) {
  const int kOneBitVectorCapacity = 14;
  const TimeDelta kLargeTimeDelta = TransportFeedback::kDeltaTick * (1 << 8);

  // Test that a number of small deltas followed by a large delta results in a
  // correct split into multiple chunks, as needed.

  for (int deltas = 0; deltas <= kOneBitVectorCapacity + 1; ++deltas) {
    TransportFeedback feedback;
    feedback.SetBase(0, Timestamp::Zero());
    for (int i = 0; i < deltas; ++i)
      feedback.AddReceivedPacket(i, Timestamp::Millis(i));
    feedback.AddReceivedPacket(deltas,
                               Timestamp::Millis(deltas) + kLargeTimeDelta);

    EXPECT_THAT(feedback.Build(), IsValidFeedback());
  }
}

TEST(RtcpPacketTest, TransportFeedbackMoveConstructor) {
  const int kSamples = 100;
  const uint16_t kBaseSeqNo = 7531;
  const Timestamp kBaseTimestamp = Timestamp::Micros(123'456'789);
  const uint8_t kFeedbackSeqNo = 90;

  TransportFeedback feedback;
  feedback.SetBase(kBaseSeqNo, kBaseTimestamp);
  feedback.SetFeedbackSequenceNumber(kFeedbackSeqNo);
  for (int i = 0; i < kSamples; ++i) {
    feedback.AddReceivedPacket(
        kBaseSeqNo + i, kBaseTimestamp + i * TransportFeedback::kDeltaTick);
  }
  EXPECT_TRUE(feedback.IsConsistent());

  TransportFeedback feedback_copy(feedback);
  EXPECT_TRUE(feedback_copy.IsConsistent());
  EXPECT_TRUE(feedback.IsConsistent());
  EXPECT_EQ(feedback_copy.Build(), feedback.Build());

  TransportFeedback moved(std::move(feedback));
  EXPECT_TRUE(moved.IsConsistent());
  EXPECT_TRUE(feedback.IsConsistent());
  EXPECT_EQ(moved.Build(), feedback_copy.Build());
}

TEST(TransportFeedbackTest, ReportsMissingPackets) {
  const uint16_t kBaseSeqNo = 1000;
  const Timestamp kBaseTimestamp = Timestamp::Millis(10);
  const uint8_t kFeedbackSeqNo = 90;
  TransportFeedback feedback_builder(/*include_timestamps*/ true);
  feedback_builder.SetBase(kBaseSeqNo, kBaseTimestamp);
  feedback_builder.SetFeedbackSequenceNumber(kFeedbackSeqNo);
  feedback_builder.AddReceivedPacket(kBaseSeqNo + 0, kBaseTimestamp);
  // Packet losses indicated by jump in sequence number.
  feedback_builder.AddReceivedPacket(kBaseSeqNo + 3,
                                     kBaseTimestamp + TimeDelta::Millis(2));

  MockFunction<void(uint16_t, TimeDelta)> handler;
  InSequence s;
  EXPECT_CALL(handler, Call(kBaseSeqNo + 0, Ne(TimeDelta::PlusInfinity())));
  EXPECT_CALL(handler, Call(kBaseSeqNo + 1, TimeDelta::PlusInfinity()));
  EXPECT_CALL(handler, Call(kBaseSeqNo + 2, TimeDelta::PlusInfinity()));
  EXPECT_CALL(handler, Call(kBaseSeqNo + 3, Ne(TimeDelta::PlusInfinity())));
  Parse(feedback_builder.Build()).ForAllPackets(handler.AsStdFunction());
}

TEST(TransportFeedbackTest, ReportsMissingPacketsWithoutTimestamps) {
  const uint16_t kBaseSeqNo = 1000;
  const uint8_t kFeedbackSeqNo = 90;
  TransportFeedback feedback_builder(/*include_timestamps*/ false);
  feedback_builder.SetBase(kBaseSeqNo, Timestamp::Millis(10));
  feedback_builder.SetFeedbackSequenceNumber(kFeedbackSeqNo);
  feedback_builder.AddReceivedPacket(kBaseSeqNo + 0, Timestamp::Zero());
  // Packet losses indicated by jump in sequence number.
  feedback_builder.AddReceivedPacket(kBaseSeqNo + 3, Timestamp::Zero());

  MockFunction<void(uint16_t, TimeDelta)> handler;
  InSequence s;
  EXPECT_CALL(handler, Call(kBaseSeqNo + 0, Ne(TimeDelta::PlusInfinity())));
  EXPECT_CALL(handler, Call(kBaseSeqNo + 1, TimeDelta::PlusInfinity()));
  EXPECT_CALL(handler, Call(kBaseSeqNo + 2, TimeDelta::PlusInfinity()));
  EXPECT_CALL(handler, Call(kBaseSeqNo + 3, Ne(TimeDelta::PlusInfinity())));
  Parse(feedback_builder.Build()).ForAllPackets(handler.AsStdFunction());
}
}  // namespace
}  // namespace webrtc