TransportFeedbackPacketLossTrackerTest cosmetic modification

webrtc/voice_engine/transport_feedback_packet_loss_tracker_unittest.cc

 /*
  *  Copyright (c) 2017 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 <limits>
 #include <memory>
 #include <numeric>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 #include "webrtc/voice_engine/transport_feedback_packet_loss_tracker.h"
 
 namespace webrtc {
 
 namespace {
 
+constexpr int64_t kDefaultSendIntervalMs = 10;
+constexpr int64_t kDefaultMaxWindowSizeMs = 500 * kDefaultSendIntervalMs;
+
 class TransportFeedbackPacketLossTrackerTest
     : public ::testing::TestWithParam<uint16_t> {
   using TransportFeedback = webrtc::rtcp::TransportFeedback;
 
  public:
   TransportFeedbackPacketLossTrackerTest() = default;
   virtual ~TransportFeedbackPacketLossTrackerTest() = default;
 
  protected:
   void SendPackets(TransportFeedbackPacketLossTracker* tracker,
@@ skipping 98 matching lines @@
  private:
   int64_t time_ms_{0};
 
   RTC_DISALLOW_COPY_AND_ASSIGN(TransportFeedbackPacketLossTrackerTest);
 };
 
 }  // namespace
 
 // Sanity check on an empty window.
 TEST_P(TransportFeedbackPacketLossTrackerTest, EmptyWindow) {
-  TransportFeedbackPacketLossTracker tracker(5000, 5, 5);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 5);
 
   // PLR and RPLR reported as unknown before reception of first feedback.
   ValidatePacketLossStatistics(tracker,
                                rtc::Optional<float>(),
                                rtc::Optional<float>());
 }
 
 // A feedback received for an empty window has no effect.
 TEST_P(TransportFeedbackPacketLossTrackerTest, EmptyWindowFeedback) {
-  TransportFeedbackPacketLossTracker tracker(5000, 3, 2);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 3, 2);
 
   // Feedback doesn't correspond to any packets - ignored.
   AddTransportFeedbackAndValidate(&tracker, base_, {true, false, true});
   ValidatePacketLossStatistics(tracker,
                                rtc::Optional<float>(),
                                rtc::Optional<float>());
 
   // After the packets are transmitted, acking them would have an effect.
-  SendPackets(&tracker, base_, 3, 10);
+  SendPackets(&tracker, base_, 3, kDefaultSendIntervalMs);
   AddTransportFeedbackAndValidate(&tracker, base_, {true, false, true});
   ValidatePacketLossStatistics(tracker, 1.0f / 3.0f, 0.5f);
 }
 
 // Sanity check on partially filled window.
 TEST_P(TransportFeedbackPacketLossTrackerTest, PartiallyFilledWindow) {
-  TransportFeedbackPacketLossTracker tracker(5000, 5, 4);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4);
 
   // PLR unknown before minimum window size reached.
   // RPLR unknown before minimum pairs reached.
   // Expected window contents: [] -> [1001].
-  SendPackets(&tracker, base_, 3, 10);
+  SendPackets(&tracker, base_, 3, kDefaultSendIntervalMs);
   AddTransportFeedbackAndValidate(&tracker, base_, {true, false, false, true});
   ValidatePacketLossStatistics(tracker,
                                rtc::Optional<float>(),
                                rtc::Optional<float>());
 }
 
 // Sanity check on minimum filled window - PLR known, RPLR unknown.
 TEST_P(TransportFeedbackPacketLossTrackerTest, PlrMinimumFilledWindow) {
-  TransportFeedbackPacketLossTracker tracker(5000, 5, 5);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 5);
 
   // PLR correctly calculated after minimum window size reached.
   // RPLR not necessarily known at that time (not if min-pairs not reached).
   // Expected window contents: [] -> [10011].
-  SendPackets(&tracker, base_, 5, 10);
+  SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs);
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {true, false, false, true, true});
   ValidatePacketLossStatistics(tracker,
                                rtc::Optional<float>(2.0f / 5.0f),
                                rtc::Optional<float>());
 }
 
 // Sanity check on minimum filled window - PLR unknown, RPLR known.
 TEST_P(TransportFeedbackPacketLossTrackerTest, RplrMinimumFilledWindow) {
-  TransportFeedbackPacketLossTracker tracker(5000, 6, 4);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 6, 4);
 
   // RPLR correctly calculated after minimum pairs reached.
   // PLR not necessarily known at that time (not if min window not reached).
   // Expected window contents: [] -> [10011].
-  SendPackets(&tracker, base_, 5, 10);
+  SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs);
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {true, false, false, true, true});
   ValidatePacketLossStatistics(tracker,
                                rtc::Optional<float>(),
                                rtc::Optional<float>(1.0f / 4.0f));
 }
 
 // If packets are sent close enough together that the clock reading for both
 // is the same, that's handled properly.
 TEST_P(TransportFeedbackPacketLossTrackerTest, SameSentTime) {
-  TransportFeedbackPacketLossTracker tracker(5000, 3, 2);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 3, 2);
 
   // Expected window contents: [] -> [101].
   SendPackets(&tracker, base_, 3, 0);  // Note: time interval = 0ms.
   AddTransportFeedbackAndValidate(&tracker, base_, {true, false, true});
 
   ValidatePacketLossStatistics(tracker, 1.0f / 3.0f, 0.5f);
 }
 
 // Additional reports update PLR and RPLR.
 TEST_P(TransportFeedbackPacketLossTrackerTest, ExtendWindow) {
-  TransportFeedbackPacketLossTracker tracker(5000, 5, 5);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 5);
 
-  SendPackets(&tracker, base_, 25, 10);
+  SendPackets(&tracker, base_, 25, kDefaultSendIntervalMs);
 
   // Expected window contents: [] -> [10011].
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {true, false, false, true, true});
   ValidatePacketLossStatistics(tracker,
                                rtc::Optional<float>(2.0f / 5.0f),
                                rtc::Optional<float>());
 
   // Expected window contents: [10011] -> [1001110101].
   AddTransportFeedbackAndValidate(&tracker, base_ + 5,
                                   {true, false, true, false, true});
   ValidatePacketLossStatistics(tracker, 4.0f / 10.0f, 3.0f / 9.0f);
 
   // Expected window contents: [1001110101] -> [1001110101-GAP-10001].
   AddTransportFeedbackAndValidate(&tracker, base_ + 20,
                                   {true, false, false, false, true});
   ValidatePacketLossStatistics(tracker, 7.0f / 15.0f, 4.0f / 13.0f);
 }
 
 // Correct calculation with different packet lengths.
 TEST_P(TransportFeedbackPacketLossTrackerTest, DifferentSentIntervals) {
-  TransportFeedbackPacketLossTracker tracker(5000, 5, 4);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4);
 
-  int64_t now_ms = 0;
   int64_t frames[] = {20, 60, 120, 20, 60};
   for (size_t i = 0; i < sizeof(frames) / sizeof(frames[0]); i++) {
-    tracker.OnPacketAdded(static_cast<uint16_t>(base_ + i), now_ms);
-    now_ms += frames[i];
+    SendPackets(&tracker, {static_cast<uint16_t>(base_ + i)}, frames[i]);
   }
 
   // Expected window contents: [] -> [10011].
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {true, false, false, true, true});
   ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
 }
 
 // The window retains information up to sent times that exceed the the max
 // window size. The oldest packets get shifted out of window to make room
 // for the newer ones.
 TEST_P(TransportFeedbackPacketLossTrackerTest, MaxWindowSize) {
-  TransportFeedbackPacketLossTracker tracker(40, 5, 1);
+  TransportFeedbackPacketLossTracker tracker(4 * kDefaultSendIntervalMs, 5, 1);
 
-  SendPackets(&tracker, base_, 6, 10, true);
+  SendPackets(&tracker, base_, 6, kDefaultSendIntervalMs, true);
 
-  // Up to the maximum time-span retained (first + 4 * 10ms).
+  // Up to the maximum time-span retained (first + 4 * kDefaultSendIntervalMs).
   // Expected window contents: [] -> [01001].
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {false, true, false, false, true});
   ValidatePacketLossStatistics(tracker, 3.0f / 5.0f, 2.0f / 4.0f);
 
   // After the maximum time-span, older entries are discarded to accommodate
   // newer ones.
   // Expected window contents: [01001] -> [10011].
   AddTransportFeedbackAndValidate(&tracker, base_ + 5, {true});
   ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
 }
 
 // All packets received.
 TEST_P(TransportFeedbackPacketLossTrackerTest, AllReceived) {
-  TransportFeedbackPacketLossTracker tracker(5000, 5, 4);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4);
 
   // Expected window contents: [] -> [11111].
-  SendPackets(&tracker, base_, 5, 10);
+  SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs);
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {true, true, true, true, true});
   ValidatePacketLossStatistics(tracker, 0.0f, 0.0f);
 }
 
 // All packets lost.
 TEST_P(TransportFeedbackPacketLossTrackerTest, AllLost) {
-  TransportFeedbackPacketLossTracker tracker(5000, 5, 4);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4);
 
   // Note: The last packet in the feedback does not belong to the stream.
   // It's only there because we're not allowed to end a feedback with a loss.
   // Expected window contents: [] -> [00000].
-  SendPackets(&tracker, base_, 5, 10);
+  SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs);
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {false, false, false, false, false, true});
   ValidatePacketLossStatistics(tracker, 1.0f, 0.0f);
 }
 
 // Repeated reports are ignored.
 TEST_P(TransportFeedbackPacketLossTrackerTest, ReportRepetition) {
-  TransportFeedbackPacketLossTracker tracker(5000, 5, 4);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4);
 
-  SendPackets(&tracker, base_, 5, 10);
+  SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs);
 
   // Expected window contents: [] -> [10011].
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {true, false, false, true, true});
   ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
 
   // Repeat entire previous feedback
   // Expected window contents: [10011] -> [10011].
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {true, false, false, true, true});
   ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
 }
 
 // Report overlap.
 TEST_P(TransportFeedbackPacketLossTrackerTest, ReportOverlap) {
-  TransportFeedbackPacketLossTracker tracker(5000, 5, 1);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 1);
 
-  SendPackets(&tracker, base_, 15, 10);
+  SendPackets(&tracker, base_, 15, kDefaultSendIntervalMs);
 
   // Expected window contents: [] -> [10011].
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {true, false, false, true, true});
   ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
 
   // Expected window contents: [10011] -> [1001101].
   AddTransportFeedbackAndValidate(&tracker, base_ + 3,
                                   {true, true, false, true});
   ValidatePacketLossStatistics(tracker, 3.0f / 7.0f, 2.0f / 6.0f);
 }
 
 // Report conflict.
 TEST_P(TransportFeedbackPacketLossTrackerTest, ReportConflict) {
-  TransportFeedbackPacketLossTracker tracker(5000, 5, 4);
+  TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4);
 
   SendPackets(&tracker, base_, 15, 10);
 
   // Expected window contents: [] -> [01001].
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {false, true, false, false, true});
   ValidatePacketLossStatistics(tracker, 3.0f / 5.0f, 2.0f / 4.0f);
 
   // Expected window contents: [01001] -> [11101].
   // While false->true will be applied, true -> false will be ignored.
   AddTransportFeedbackAndValidate(&tracker, base_, {true, false, true});
   ValidatePacketLossStatistics(tracker, 1.0f / 5.0f, 1.0f / 4.0f);
 }
 
 // Skipped packets treated as unknown (not lost).
 TEST_P(TransportFeedbackPacketLossTrackerTest, SkippedPackets) {
-  TransportFeedbackPacketLossTracker tracker(200 * 10, 5, 1);
+  TransportFeedbackPacketLossTracker tracker(200 * kDefaultSendIntervalMs, 5,
+                                             1);
 
-  SendPackets(&tracker, base_, 200, 10);
+  SendPackets(&tracker, base_, 200, kDefaultSendIntervalMs);
 
   // Expected window contents: [] -> [10011].
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {true, false, false, true, true});
   ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
 
   // Expected window contents: [10011] -> [10011-GAP-101].
   AddTransportFeedbackAndValidate(&tracker, base_ + 100, {true, false, true});
   ValidatePacketLossStatistics(tracker, 3.0f / 8.0f, 2.0f / 6.0f);
 }
@@ skipping 32 matching lines @@
   // Messages that are *not* more than the span-limit away from the newest
   // acked message are *not* too old. Acking them would have an effect.
   AddTransportFeedbackAndValidate(
       &tracker, moved_newest_acked - max_window_size_ms, {true});
   ValidatePacketLossStatistics(tracker, 3.0f / 7.0f, 1.0f / 5.0f);
 }
 
 // Inserting feedback into the middle of a window works correctly - can
 // complete two pairs.
 TEST_P(TransportFeedbackPacketLossTrackerTest, InsertionCompletesTwoPairs) {
-  TransportFeedbackPacketLossTracker tracker(1500, 5, 1);
+  TransportFeedbackPacketLossTracker tracker(150 * kDefaultSendIntervalMs, 5,
+                                             1);
 
-  SendPackets(&tracker, base_, 15, 10);
+  SendPackets(&tracker, base_, 15, kDefaultSendIntervalMs);
 
   // Expected window contents: [] -> [10111].
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {true, false, true, true, true});
   ValidatePacketLossStatistics(tracker, 1.0f / 5.0f, 1.0f / 4.0f);
 
   // Expected window contents: [10111] -> [10111-GAP-10101].
   AddTransportFeedbackAndValidate(&tracker, base_ + 7,
                                   {true, false, true, false, true});
   ValidatePacketLossStatistics(tracker, 3.0f / 10.0f, 3.0f / 8.0f);
 
   // Insert in between, closing the gap completely.
   // Expected window contents: [10111-GAP-10101] -> [101110110101].
   AddTransportFeedbackAndValidate(&tracker, base_ + 5, {false, true});
   ValidatePacketLossStatistics(tracker, 4.0f / 12.0f, 4.0f / 11.0f);
 }
 
 // Sequence number gaps are not gaps in reception. However, gaps in reception
 // are still possible, if a packet which WAS sent on the stream is not acked.
 TEST_P(TransportFeedbackPacketLossTrackerTest, SanityGapsInSequenceNumbers) {
-  TransportFeedbackPacketLossTracker tracker(500, 5, 1);
+  TransportFeedbackPacketLossTracker tracker(50 * kDefaultSendIntervalMs, 5, 1);
 
   SendPackets(&tracker,
               {static_cast<uint16_t>(base_),
                static_cast<uint16_t>(base_ + 2),
                static_cast<uint16_t>(base_ + 4),
                static_cast<uint16_t>(base_ + 6),
                static_cast<uint16_t>(base_ + 8)},
-              10);
+              kDefaultSendIntervalMs);
 
   // Gaps in sequence numbers not considered as gaps in window, because  only
   // those sequence numbers which were associated with the stream count.
   // Expected window contents: [] -> [11011].
   AddTransportFeedbackAndValidate(
       // Note: Left packets belong to this stream, right ones ignored.
       &tracker, base_, {true, false,
                         true, false,
                         false, false,
                         true, false,
                         true, true});
   ValidatePacketLossStatistics(tracker, 1.0f / 5.0f, 1.0f / 4.0f);
 
   // Create gap by sending [base + 10] but not acking it.
   // Note: Acks for [base + 11] and [base + 13] ignored (other stream).
   // Expected window contents: [11011] -> [11011-GAP-01].
   SendPackets(&tracker,
               {static_cast<uint16_t>(base_ + 10),
                static_cast<uint16_t>(base_ + 12),
                static_cast<uint16_t>(base_ + 14)},
-              10);
+              kDefaultSendIntervalMs);
   AddTransportFeedbackAndValidate(&tracker, base_ + 11,
                                   {false, false, false, true, true});
   ValidatePacketLossStatistics(tracker, 2.0f / 7.0f, 2.0f / 5.0f);
 }
 
 // The window cannot span more than 0x8000 in sequence numbers, regardless
 // of time stamps and ack/unacked status.
 TEST_P(TransportFeedbackPacketLossTrackerTest, MaxUnackedPackets) {
   TransportFeedbackPacketLossTracker tracker(0x10000, 4, 1);
 
@@ skipping 48 matching lines @@
   const uint16_t new_packet_seq_num =
       static_cast<uint16_t>(base_ + feedback.size() + 1);
   SendPackets(&tracker, {new_packet_seq_num}, 1);
   ValidatePacketLossStatistics(tracker, 2.0f / 6.0f, 2.0f / 5.0f);
   // Expected window contents: [011011] -> [110111].
   AddTransportFeedbackAndValidate(&tracker, new_packet_seq_num, {true});
   ValidatePacketLossStatistics(tracker, 1.0f / 6.0f, 1.0f / 5.0f);
 }
 
 TEST_P(TransportFeedbackPacketLossTrackerTest, RepeatedSeqNumResetsWindow) {
-  TransportFeedbackPacketLossTracker tracker(500, 2, 1);
+  TransportFeedbackPacketLossTracker tracker(50 * kDefaultSendIntervalMs, 2, 1);
 
   // Baseline - window has acked messages.
   // Expected window contents: [] -> [01101].
-  SendPackets(&tracker, base_, 5, 10);
+  SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs);
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {false, true, true, false, true});
   ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 2.0f / 4.0f);
 
   // A reset occurs.
-  SendPackets(&tracker, static_cast<uint16_t>(base_ + 2), 1, 10);
+  SendPackets(&tracker, {static_cast<uint16_t>(base_ + 2)},
+              kDefaultSendIntervalMs);
   ValidatePacketLossStatistics(tracker,
                                rtc::Optional<float>(),
                                rtc::Optional<float>());
 }
 
 // The window is reset by the sending of a packet which is 0x8000 or more
 // away from the newest packet acked/unacked packet.
 TEST_P(TransportFeedbackPacketLossTrackerTest,
        SendAfterLongSuspensionResetsWindow) {
-  TransportFeedbackPacketLossTracker tracker(500, 2, 1);
+  TransportFeedbackPacketLossTracker tracker(50 * kDefaultSendIntervalMs, 2, 1);
 
   // Baseline - window has acked messages.
   // Expected window contents: [] -> [01101].
-  SendPackets(&tracker, base_, 5, 10);
+  SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs);
   AddTransportFeedbackAndValidate(&tracker, base_,
                                   {false, true, true, false, true});
   ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 2.0f / 4.0f);
 
   // A reset occurs.
-  SendPackets(&tracker, static_cast<uint16_t>(base_ + 5 + 0x8000), 1, 10);
+  SendPackets(&tracker, {static_cast<uint16_t>(base_ + 5 + 0x8000)},
+              kDefaultSendIntervalMs);
   ValidatePacketLossStatistics(tracker,
                                rtc::Optional<float>(),
                                rtc::Optional<float>());
 }
 
 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
 TEST(TransportFeedbackPacketLossTrackerTest, InvalidConfigMaxWindowSize) {
   EXPECT_DEATH(TransportFeedbackPacketLossTracker tracker(0, 20, 10), "");
 }
 
@@ skipping 15 matching lines @@
 
 // All tests are run multiple times with various baseline sequence number,
 // to weed out potential bugs with wrap-around handling.
 constexpr uint16_t kBases[] = {0x0000, 0x3456, 0xc032, 0xfffe};
 
 INSTANTIATE_TEST_CASE_P(_,
                         TransportFeedbackPacketLossTrackerTest,
                         testing::ValuesIn(kBases));
 
 }  // namespace webrtc