First-order-FEC recoverability calculation

webrtc/voice_engine/transport_feedback_packet_loss_tracker_unittest.cc

 /*
  *  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.
  */
 
@@ skipping 38 matching lines @@
     }
   }
   StrictMock<MockTransportFeedback> mock_feedback;
   EXPECT_CALL(mock_feedback, GetBaseSequence())
       .WillOnce(Return(base_sequence_num));
   EXPECT_CALL(mock_feedback, GetStatusVector()).WillOnce(Return(statuses));
   tracker->OnReceivedTransportFeedback(mock_feedback);
   tracker->Validate();
 }
 
+// Checks that validty is as expected. If valid, checks also that
+// value is as expected.
+void ValidatePacketReceptionStatistics(
+    const TransportFeedbackPacketLossTracker& tracker,
+    rtc::Optional<float> expected_plr,
+    rtc::Optional<float> expected_rplr) {
+  // Comparing the rtc::Optional<float> directly would have given concise code,
+  // but less readable error messages.
+  rtc::Optional<float> plr = tracker.GetPacketLossRate();
+  EXPECT_EQ(bool(expected_plr), bool(plr));
+  if (expected_plr && plr) {
+    EXPECT_EQ(*expected_plr, *plr);
+  }
+
+  rtc::Optional<float> rplr = tracker.GetRecoverablePacketLossRate();
+  EXPECT_EQ(bool(expected_rplr), bool(rplr));
+  if (expected_rplr && rplr) {
+    EXPECT_EQ(*expected_rplr, *rplr);
+  }
+}
+
+// Convenience function for when both are valid, and explicitly stating
+// the rtc::Optional<float> constructor is just cumbersome.
+void ValidatePacketReceptionStatistics(
+    const TransportFeedbackPacketLossTracker& tracker,
+    float expected_plr,
+    float expected_rplr) {
+  ValidatePacketReceptionStatistics(tracker,
+                                    rtc::Optional<float>(expected_plr),
+                                    rtc::Optional<float>(expected_rplr));
+}
+
 }  // namespace
 
 // Sanity check on an empty window.
 TEST(TransportFeedbackPacketLossTrackerTest, EmptyWindow) {
   std::unique_ptr<TransportFeedback> feedback;
-  float plr = 0.0f;   // Packet-loss-rate
-  float cplr = 0.0f;  // Consecutive-packet-loss-rate
-
-  TransportFeedbackPacketLossTracker tracker(5, 10);
-
-  // PLR and CPLR reported as unknown before reception of first feedback.
-  EXPECT_FALSE(tracker.GetPacketLossRates(&plr, &cplr));
+  TransportFeedbackPacketLossTracker tracker(5, 10, 5);
+
+  // PLR and RPLR reported as unknown before reception of first feedback.
+  ValidatePacketReceptionStatistics(tracker,
+                                    rtc::Optional<float>(),
+                                    rtc::Optional<float>());
 }
 
 // Sanity check on partially filled window.
-TEST(TransportFeedbackPacketLossTrackerTest, PartiallyFilledWindow) {
-  for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 10);
-
-    // PLR and CPLR reported as unknown before minimum window size reached.
+TEST(TransportFeedbackPacketLossTrackerTest, PlrPartiallyFilledWindow) {
+  for (uint16_t base : kBases) {
+    TransportFeedbackPacketLossTracker tracker(5, 10, 4);
+
+    // PLR unknown before minimum window size reached.
+    // RPLR unknown before minimum pairs reached.
     // Expected window contents: [] -> [1001].
     AddTransportFeedbackAndValidate(&tracker, base, {true, false, false, true});
-    EXPECT_FALSE(tracker.GetPacketLossRates(&plr, &cplr));
-  }
-}
-
-// Sanity check on minimum filled window.
-TEST(TransportFeedbackPacketLossTrackerTest, MinimumFilledWindow) {
-  for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 10);
-
-    // PLR and CPLR correctly calculated after minimum window size reached.
-    // Expected window contents: [] -> [10011].
-    AddTransportFeedbackAndValidate(&tracker, base,
-                                    {true, false, false, true, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 2.0f / 5.0f);
-    EXPECT_EQ(cplr, 1.0f / 5.0f);
-  }
-}
-
-// Additional reports update PLR and CPLR.
+    ValidatePacketReceptionStatistics(tracker,
+                                      rtc::Optional<float>(),
+                                      rtc::Optional<float>());
+  }
+}
+
+// Sanity check on minimum filled window - PLR known, RPLR unknown.
+TEST(TransportFeedbackPacketLossTrackerTest, PlrMinimumFilledWindow) {
+  for (uint16_t base : kBases) {
+    TransportFeedbackPacketLossTracker tracker(5, 10, 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].
+    AddTransportFeedbackAndValidate(&tracker, base,
+                                    {true, false, false, true, true});
+    ValidatePacketReceptionStatistics(tracker,
+                                      rtc::Optional<float>(2.0f / 5.0f),
+                                      rtc::Optional<float>());
+  }
+}
+
+// Sanity check on minimum filled window - PLR unknown, RPLR known.
+TEST(TransportFeedbackPacketLossTrackerTest, RplrMinimumFilledWindow) {
+  for (uint16_t base : kBases) {
+    TransportFeedbackPacketLossTracker tracker(6, 10, 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].
+    AddTransportFeedbackAndValidate(&tracker, base,
+                                    {true, false, false, true, true});
+    ValidatePacketReceptionStatistics(tracker,
+                                      rtc::Optional<float>(),
+                                      rtc::Optional<float>(1.0f / 4.0f));
+  }
+}
+
+// Additional reports update PLR and RPLR.
 TEST(TransportFeedbackPacketLossTrackerTest, ExtendWindow) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
-
-    // Expected window contents: [] -> [10011].
-    AddTransportFeedbackAndValidate(&tracker, base,
-                                    {true, false, false, true, true});
+    TransportFeedbackPacketLossTracker tracker(5, 20, 5);
+
+    // Expected window contents: [] -> [10011].
+    AddTransportFeedbackAndValidate(&tracker, base,
+                                    {true, false, false, true, true});
+    ValidatePacketReceptionStatistics(tracker,
+                                      rtc::Optional<float>(2.0f / 5.0f),
+                                      rtc::Optional<float>());
 
     // Expected window contents: [10011] -> [10011-10101].
     AddTransportFeedbackAndValidate(&tracker, base + 5,
                                     {true, false, true, false, true});
-
-    // Expected window contents: [10011-10101] -> [10011-10101-10001].
-    AddTransportFeedbackAndValidate(&tracker, base + 10,
+    ValidatePacketReceptionStatistics(tracker, 4.0f / 10.0f, 3.0f / 9.0f);
+
+    // Expected window contents: [10011-10101] -> [10011-10101-GAP-10001].
+    AddTransportFeedbackAndValidate(&tracker, base + 20,
                                     {true, false, false, false, true});
-
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 7.0f / 15.0f);
-    EXPECT_EQ(cplr, 3.0f / 15.0f);
-  }
-}
-
+    ValidatePacketReceptionStatistics(tracker, 7.0f / 15.0f, 4.0f / 13.0f);
+  }
+}
+
+// All packets correctly received.
 TEST(TransportFeedbackPacketLossTrackerTest, AllReceived) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 10);
-
-    // PLR and CPLR correctly calculated after minimum window size reached.
+    TransportFeedbackPacketLossTracker tracker(5, 10, 4);
+
+    // PLR and RPLR correctly calculated after minimum window size reached.
     // Expected window contents: [] -> [11111].
     AddTransportFeedbackAndValidate(&tracker, base,
                                     {true, true, true, true, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 0.0f);
-    EXPECT_EQ(cplr, 0.0f);
-  }
-}
-
+    ValidatePacketReceptionStatistics(tracker, 0.0f, 0.0f);
+  }
+}
+
+// All packets lost.
 TEST(TransportFeedbackPacketLossTrackerTest, AllLost) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 10);
-
-    // PLR and CPLR correctly calculated after minimum window size reached.
+    TransportFeedbackPacketLossTracker tracker(5, 10, 4);
+
+    // PLR and RPLR correctly calculated after minimum window size reached.
     // Expected window contents: [] -> [00000].
     AddTransportFeedbackAndValidate(&tracker, base,
                                     {false, false, false, false, false});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 5.0f / 5.0f);
-    EXPECT_EQ(cplr, 4.0f / 5.0f);
+    ValidatePacketReceptionStatistics(tracker, 5.0f / 5.0f, 0.0f / 4.0f);
   }
 }
 
 // Repeated reports are ignored.
 TEST(TransportFeedbackPacketLossTrackerTest, ReportRepetition) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 10);
-
-    // Expected window contents: [] -> [10011].
-    AddTransportFeedbackAndValidate(&tracker, base,
-                                    {true, false, false, true, true});
+    TransportFeedbackPacketLossTracker tracker(5, 10, 4);
+
+    // Expected window contents: [] -> [10011].
+    AddTransportFeedbackAndValidate(&tracker, base,
+                                    {true, false, false, true, true});
+    ValidatePacketReceptionStatistics(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});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 2.0f / 5.0f);
-    EXPECT_EQ(cplr, 1.0f / 5.0f);
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
   }
 }
 
 // Report overlap.
 TEST(TransportFeedbackPacketLossTrackerTest, ReportOverlap) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 10);
-
-    // Expected window contents: [] -> [10011].
-    AddTransportFeedbackAndValidate(&tracker, base,
-                                    {true, false, false, true, true});
+    TransportFeedbackPacketLossTracker tracker(5, 10, 1);
+
+    // Expected window contents: [] -> [10011].
+    AddTransportFeedbackAndValidate(&tracker, base,
+                                    {true, false, false, true, true});
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
 
     // Expected window contents: [10011] -> [10011-01].
     AddTransportFeedbackAndValidate(&tracker, base + 3,
                                     {true, true, false, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 3.0f / 7.0f);
-    EXPECT_EQ(cplr, 1.0f / 7.0f);
+    ValidatePacketReceptionStatistics(tracker, 3.0f / 7.0f, 2.0f / 6.0f);
   }
 }
 
 // Report conflict.
 TEST(TransportFeedbackPacketLossTrackerTest, ReportConflict) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 10);
+    TransportFeedbackPacketLossTracker tracker(5, 10, 4);
 
     // Expected window contents: [] -> [01001].
     AddTransportFeedbackAndValidate(&tracker, base,
                                     {false, true, false, false, true});
+    ValidatePacketReceptionStatistics(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});
-
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 1.0f / 5.0f);
-    EXPECT_EQ(cplr, 0.0f / 5.0f);
+    ValidatePacketReceptionStatistics(tracker, 1.0f / 5.0f, 1.0f / 4.0f);
   }
 }
 
 // Skipped packets treated as unknown (not lost).
 TEST(TransportFeedbackPacketLossTrackerTest, SkippedPackets) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 10);
-
-    // Expected window contents: [] -> [10011].
-    AddTransportFeedbackAndValidate(&tracker, base,
-                                    {true, false, false, true, true});
-
-    // Expected window contents: [10011] -> [10011-101].
+    TransportFeedbackPacketLossTracker tracker(5, 10, 1);
+
+    // Expected window contents: [] -> [10011].
+    AddTransportFeedbackAndValidate(&tracker, base,
+                                    {true, false, false, true, true});
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
+
+    // Expected window contents: [10011] -> [10011-GAP-101].
     AddTransportFeedbackAndValidate(&tracker, base + 100, {true, false, true});
-
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 3.0f / 8.0f);
-    EXPECT_EQ(cplr, 1.0f / 8.0f);
-  }
-}
-
+    ValidatePacketReceptionStatistics(tracker, 3.0f / 8.0f, 2.0f / 6.0f);
+  }
+}
+
 // The window retain information up to the configured max-window-size, but
 // starts discarding after that.
 TEST(TransportFeedbackPacketLossTrackerTest, MaxWindowSize) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(10, 10);
+    TransportFeedbackPacketLossTracker tracker(10, 10, 1);
 
+    // Up to max-window-size retained.
     // Expected window contents: [] -> [10101-00001].
     AddTransportFeedbackAndValidate(
         &tracker, base,
         {true, false, true, false, true, false, false, false, false, true});
+    ValidatePacketReceptionStatistics(tracker, 6.0f / 10.0f, 3.0f / 9.0f);
 
-    // Up to max-window-size retained.
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 6.0f / 10.0f);
-    EXPECT_EQ(cplr, 3.0f / 10.0f);
-
+    // After max-window-size, older entries discarded to accommodate newer ones.
     // Expected window contents: [10101-00001] -> [00001-10111].
     AddTransportFeedbackAndValidate(&tracker, base + 10,
                                     {true, false, true, true, true});
-
-    // After max-window-size, older entries discarded to accommodate newer ones.
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 5.0f / 10.0f);
-    EXPECT_EQ(cplr, 3.0f / 10.0f);
+    ValidatePacketReceptionStatistics(tracker, 5.0f / 10.0f, 2.0f / 9.0f);
   }
 }
 
 // Inserting into the middle of a full window works correctly.
 TEST(TransportFeedbackPacketLossTrackerTest, InsertIntoMiddle) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(10, 10);
+    TransportFeedbackPacketLossTracker tracker(5, 10, 1);
 
     // Expected window contents: [] -> [10101].
     AddTransportFeedbackAndValidate(&tracker, base,
                                     {true, false, true, false, true});
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 2.0f / 4.0f);
 
-    // Expected window contents: [10101] -> [10101-10001].
+    // Expected window contents: [10101] -> [10101-GAP-10001].
     AddTransportFeedbackAndValidate(&tracker, base + 100,
                                     {true, false, false, false, true});
-
-    // Setup sanity
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 5.0f / 10.0f);
-    EXPECT_EQ(cplr, 2.0f / 10.0f);
+    ValidatePacketReceptionStatistics(tracker, 5.0f / 10.0f, 3.0f / 8.0f);
 
     // Insert into the middle of this full window - it discards the older data.
-    // Expected window contents: [10101-10001] -> [11111-10001].
+    // Expected window contents: [10101-GAP-10001] -> [11111-GAP-10001].
     AddTransportFeedbackAndValidate(&tracker, base + 50,
                                     {true, true, true, true, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 3.0f / 10.0f);
-    EXPECT_EQ(cplr, 2.0f / 10.0f);
+    ValidatePacketReceptionStatistics(tracker, 3.0f / 10.0f, 1.0f / 8.0f);
   }
 }
 
+// Inserting into the middle of a full window works correctly.
+TEST(TransportFeedbackPacketLossTrackerTest, InsertionCompletesTwoPairs) {
+  for (uint16_t base : kBases) {
+    TransportFeedbackPacketLossTracker tracker(5, 15, 1);
+
+    // Expected window contents: [] -> [10111].
+    AddTransportFeedbackAndValidate(&tracker, base,
+                                    {true, false, true, true, true});
+    ValidatePacketReceptionStatistics(tracker, 1.0f / 5.0f, 1.0f / 4.0f);
+
+    // Expected window contents: [10111] -> [10111-GAP-10101].
+    AddTransportFeedbackAndValidate(&tracker, base + 6,
+                                    {true, false, true, false, true});
+    ValidatePacketReceptionStatistics(tracker, 3.0f / 10.0f, 3.0f / 8.0f);
+
+    // Insert in between, closing the gap completely.
+    // Expected window contents: [10111-GAP-10101] -> [10111-01010-1].
+    AddTransportFeedbackAndValidate(&tracker, base + 5, {false});
+    ValidatePacketReceptionStatistics(tracker, 4.0f / 11.0f, 4.0f / 10.0f);
+  }
+}
+
 // Entries in the second quadrant treated like those in the first.
 // The sequence number is used in a looped manner. 0xFFFF is followed by 0x0000.
 // In many tests, we divide the circle of sequence number into 4 quadrants, and
 // verify the behavior of TransportFeedbackPacketLossTracker over them.
 TEST(TransportFeedbackPacketLossTrackerTest, SecondQuadrant) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Expected window contents: [] -> [10011].
     AddTransportFeedbackAndValidate(&tracker, base,
                                     {true, false, false, true, true});
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
 
     // Window *does* get updated with inputs from quadrant #2.
     // Expected window contents: [10011] -> [10011-1].
     AddTransportFeedbackAndValidate(&tracker, base + 0x4321, {true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 2.0f / 6.0f);
-    EXPECT_EQ(cplr, 1.0f / 6.0f);
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 6.0f, 1.0f / 4.0f);
 
     // Correct recognition of quadrant #2: up to, but not including, base +
     // 0x8000
     // Expected window contents: [10011-1] -> [10011-11].
     AddTransportFeedbackAndValidate(&tracker, base + 0x7fff, {true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 2.0f / 7.0f);
-    EXPECT_EQ(cplr, 1.0f / 7.0f);
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 7.0f, 1.0f / 4.0f);
   }
 }
 
 // Insertion into the third quadrant moves the base of the window.
 TEST(TransportFeedbackPacketLossTrackerTest, ThirdQuadrantMovesBase) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Seed the test.
     // Expected window contents: [] -> [10011-01].
     AddTransportFeedbackAndValidate(
         &tracker, base, {true, false, false, true, true, false, true});
+    ValidatePacketReceptionStatistics(tracker, 3.0f / 7.0f, 2.0f / 6.0f);
 
     // Quadrant #3 begins at base + 0x8000. It triggers moving the window so
     // that
     // at least one (oldest) report shifts out of window.
-    // Expected window contents: [10011-01] -> [10110-01].
+    // Expected window contents: [10011-01] -> [101-GAP-1001].
     AddTransportFeedbackAndValidate(&tracker, base + 0x8000,
                                     {true, false, false, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 3.0f / 7.0f);
-    EXPECT_EQ(cplr, 1.0f / 7.0f);
+    ValidatePacketReceptionStatistics(tracker, 3.0f / 7.0f, 2.0f / 5.0f);
 
     // The base can move more than once, because the minimum quadrant-1 packets
     // were dropped out of the window, and some remain.
+    // Expected window contents: [101-GAP-1001] -> [1-GAP-10011-1].
     AddTransportFeedbackAndValidate(&tracker, base + 0x8000 + 4, {true, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 2.0f / 7.0f);
-    EXPECT_EQ(cplr, 1.0f / 7.0f);
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 7.0f, 1.0f / 5.0f);
   }
 }
 
 // After the base has moved due to insertion into the third quadrant, it is
 // still possible to insert into the middle of the window and obtain the correct
-// PLR and CPLR. Insertion into the middle before the max window size has been
+// PLR and RPLR. Insertion into the middle before the max window size has been
 // achieved does not cause older packets to be dropped.
 TEST(TransportFeedbackPacketLossTrackerTest, InsertIntoMiddleAfterBaseMove) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Seed the test.
     // Expected window contents: [] -> [10011-01].
     AddTransportFeedbackAndValidate(
         &tracker, base, {true, false, false, true, true, false, true});
+    ValidatePacketReceptionStatistics(tracker, 3.0f / 7.0f, 2.0f / 6.0f);
 
-    // Expected window contents: [10011-01] -> [10110-01].
+    // Expected window contents: [10011-01] -> [101-GAP-1001].
     AddTransportFeedbackAndValidate(&tracker, base + 0x8000,
                                     {true, false, false, true});
+    ValidatePacketReceptionStatistics(tracker, 3.0f / 7.0f, 2.0f / 5.0f);
 
     // Inserting into the middle still works after the base has shifted.
-    // Expected window contents: [10110-01] -> [10110-01011-001].
+    // Expected window contents:
+    // [101-GAP-1001] -> [101-GAP-10010-1-GAP-1001]
     AddTransportFeedbackAndValidate(&tracker, base + 0x5000,
                                     {true, false, false, true, false, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 6.0f / 13.0f);
-    EXPECT_EQ(cplr, 2.0f / 13.0f);
+    ValidatePacketReceptionStatistics(tracker, 6.0f / 13.0f, 4.0f / 10.0f);
 
     // The base can keep moving after inserting into the middle.
-    // Expected window contents: [10110-01011-001] -> [11001-01100-111].
+    // Expected window contents:
+    // [101-GAP-10010-1-GAP-1001] -> [1-GAP-10010-1-GAP-100111].
     AddTransportFeedbackAndValidate(&tracker, base + 0x8000 + 4, {true, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 5.0f / 13.0f);
-    EXPECT_EQ(cplr, 2.0f / 13.0f);
+    ValidatePacketReceptionStatistics(tracker, 5.0f / 13.0f, 3.0f / 10.0f);
   }
 }
 
 // After moving the base of the window, the max window size is still observed.
 TEST(TransportFeedbackPacketLossTrackerTest, ThirdQuadrantObservesMaxWindow) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(10, 15);
+    TransportFeedbackPacketLossTracker tracker(10, 15, 1);
 
     // Expected window contents: [] -> [10011-10101].
     AddTransportFeedbackAndValidate(
         &tracker, base,
         {true, false, false, true, true, true, false, true, false, true});
+    ValidatePacketReceptionStatistics(tracker, 4.0f / 10.0f, 3.0f / 9.0f);
 
-    // Expected window contents: [10011-10101] -> [11101-01101].
+    // Expected window contents: [10011-10101] -> [1110-101-GAP-101].
     AddTransportFeedbackAndValidate(&tracker, base + 0x8000,
                                     {true, false, true});
+    ValidatePacketReceptionStatistics(tracker, 3.0f / 10.0f, 3.0f / 8.0f);
 
     // Push into middle until max window is reached.
-    // Expected window contents: [11101-01101] -> [11101-01100-01101].
+    // Expected window contents:
+    // [1110-101-GAP-101] -> [11101-01-GAP-10001-GAP-101]
     AddTransportFeedbackAndValidate(&tracker, base + 0x4000,
                                     {true, false, false, false, true});
-
-    // Setup sanity
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 6.0f / 15.0f);
-    EXPECT_EQ(cplr, 2.0f / 15.0f);
+    ValidatePacketReceptionStatistics(tracker, 6.0f / 15.0f, 4.0f / 12.0f);
 
     // Pushing new packets into the middle would discard older packets.
-    // Expected window contents: [11101-01100-01101] -> [01011-00011-01101].
+    // Expected window contents:
+    // [11101-01-GAP-10001-GAP-101] -> [0101-GAP-10001-101-GAP-101]
     AddTransportFeedbackAndValidate(&tracker, base + 0x4000 + 5,
                                     {true, false, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 7.0f / 15.0f);
-    EXPECT_EQ(cplr, 2.0f / 15.0f);
+    ValidatePacketReceptionStatistics(tracker, 7.0f / 15.0f, 5.0f / 12.0f);
   }
 }
 
 // A new feedback in quadrant #3 might shift enough old feedbacks out of window,
-// that we'd go back to an unknown PLR and CPLR.
+// that we'd go back to an unknown PLR and RPLR.
 TEST(TransportFeedbackPacketLossTrackerTest, QuadrantThreeMovedBaseMinWindow) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Expected window contents: [] -> [10011-10101].
     AddTransportFeedbackAndValidate(
         &tracker, base,
         {true, false, false, true, true, true, false, true, false, true});
-    EXPECT_TRUE(
-        tracker.GetPacketLossRates(&plr, &cplr));  // Min window reached.
+    ValidatePacketReceptionStatistics(tracker, 4.0f / 10.0f, 3.0f / 9.0f);
 
     // A new feedback in quadrant #3 might shift enough old feedbacks out of
-    // window, that we'd go back to an unknown PLR and CPLR. This *doesn't*
+    // window, that we'd go back to an unknown PLR and RPLR. This *doesn't*
     // necessarily mean all of the old ones were discarded, though.
-    // Expected window contents: [10011-10101] -> [0111].
+    // Expected window contents: [10011-10101] -> [01-GAP-11].
     AddTransportFeedbackAndValidate(&tracker, base + 0x8006, {true, true});
-    EXPECT_FALSE(tracker.GetPacketLossRates(&plr, &cplr));
+    ValidatePacketReceptionStatistics(tracker,
+                                      rtc::Optional<float>(),  // Still invalid.
+                                      rtc::Optional<float>(1.0f / 2.0f));
 
     // Inserting in the middle shows that though some of the elements were
     // ejected, some were retained.
-    // Expected window contents: [] -> [01101-11].
+    // Expected window contents: [01-GAP-11] -> [01-GAP-1010-GAP-11].
     AddTransportFeedbackAndValidate(&tracker, base + 0x4000,
-                                    {true, false, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 2.0f / 7.0f);
-    EXPECT_EQ(cplr, 0.0f / 7.0f);
+                                    {true, false, true, false});
+    ValidatePacketReceptionStatistics(tracker, 3.0f / 8.0f, 2.0f / 5.0f);
   }
 }
 
 // Quadrant four reports ignored for up to kMaxConsecutiveOldReports times.
 TEST(TransportFeedbackPacketLossTrackerTest, QuadrantFourInitiallyIgnored) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Expected window contents: [] -> [10011].
     AddTransportFeedbackAndValidate(&tracker, base,
                                     {true, false, false, true, true});
 
     // Feedbacks in quadrant #4 are discarded (up to kMaxConsecutiveOldReports
     // consecutive reports).
     // Expected window contents: [10011] -> [10011].
     for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) {
       AddTransportFeedbackAndValidate(&tracker, base + 0xc000, {true, true});
-      EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-      EXPECT_EQ(plr, 2.0f / 5.0f);
-      EXPECT_EQ(cplr, 1.0f / 5.0f);
+      ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
     }
   }
 }
 
 // Receiving a packet from quadrant #1 resets the counter for quadrant #4.
 TEST(TransportFeedbackPacketLossTrackerTest, QuadrantFourCounterResetByQ1) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Expected window contents: [] -> [10011].
     AddTransportFeedbackAndValidate(&tracker, base,
                                     {true, false, false, true, true});
 
     // Feedbacks in quadrant #4 are discarded (up to kMaxConsecutiveOldReports
     // consecutive reports).
     // Expected window contents: [10011] -> [10011].
     for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) {
       AddTransportFeedbackAndValidate(&tracker, base + 0xc000, {true, true});
-      EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-      EXPECT_EQ(plr, 2.0f / 5.0f);
-      EXPECT_EQ(cplr, 1.0f / 5.0f);
+      ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
     }
 
     // If we receive a feedback in quadrant #1, the above counter is reset.
     // Expected window contents: [10011] -> [10011-1].
-    AddTransportFeedbackAndValidate(&tracker, base + 0x000f, {true});
+    AddTransportFeedbackAndValidate(&tracker, base + 5, {true});
     for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) {
       // Note: though the feedback message reports three packets, it only gets
       // counted once.
       AddTransportFeedbackAndValidate(&tracker, base + 0xc000,
                                       {true, false, true});
-      EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-      EXPECT_EQ(plr, 2.0f / 6.0f);
-      EXPECT_EQ(cplr, 1.0f / 6.0f);
+      ValidatePacketReceptionStatistics(tracker, 2.0f / 6.0f, 1.0f / 5.0f);
+    }
+
+    // The same is true for reports which create a gap - they still reset.
+    // Expected window contents: [10011] -> [10011-1-GAP-01].
+    AddTransportFeedbackAndValidate(&tracker, base + 0x00ff, {false, true});
+    for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) {
+      // Note: though the feedback message reports three packets, it only gets
+      // counted once.
+      AddTransportFeedbackAndValidate(&tracker, base + 0xc000,
+                                      {true, false, true});
+      ValidatePacketReceptionStatistics(tracker, 3.0f / 8.0f, 2.0f / 6.0f);
     }
   }
 }
 
+// TODO(eladalon): Suppose the feedback that resets the Q4-counter is actually
+// a repeated message that ends up not adding any new information?
+
 // Receiving a packet from quadrant #2 resets the counter for quadrant #4.
 TEST(TransportFeedbackPacketLossTrackerTest, QuadrantFourCounterResetByQ2) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Expected window contents: [] -> [10011].
     AddTransportFeedbackAndValidate(&tracker, base,
                                     {true, false, false, true, true});
 
     // Feedbacks in quadrant #4 are discarded (up to kMaxConsecutiveOldReports
     // consecutive reports).
     // Expected window contents: [10011] -> [10011].
     for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) {
       AddTransportFeedbackAndValidate(&tracker, base + 0xc000, {true, true});
-      EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-      EXPECT_EQ(plr, 2.0f / 5.0f);
-      EXPECT_EQ(cplr, 1.0f / 5.0f);
+      ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
     }
 
-    // If we receive a feedback in quadrant #1, the above counter is reset.
-    // Expected window contents: [10011] -> [10011-1].
-    AddTransportFeedbackAndValidate(&tracker, base + 0x400f, {true});
+    // If we receive a feedback in quadrant #2, the above counter is reset.
+    // Expected window contents: [10011] -> [10011-GAP-11].
+    AddTransportFeedbackAndValidate(&tracker, base + 0x400f, {true, true});
     for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) {
       // Note: though the feedback message reports three packets, it only gets
       // counted once.
       AddTransportFeedbackAndValidate(&tracker, base + 0xc000,
                                       {true, false, true});
-      EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-      EXPECT_EQ(plr, 2.0f / 6.0f);
-      EXPECT_EQ(cplr, 1.0f / 6.0f);
+      ValidatePacketReceptionStatistics(tracker, 2.0f / 7.0f, 1.0f / 5.0f);
     }
   }
 }
 
 // Receiving a packet from quadrant #3 resets the counter for quadrant #4.
 TEST(TransportFeedbackPacketLossTrackerTest, QuadrantFourCounterResetByQ3) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Expected window contents: [] -> [10011-10001].
     AddTransportFeedbackAndValidate(
         &tracker, base,
         {true, false, false, true, true, true, false, false, false, true});
 
     // Feedbacks in quadrant #4 are discarded (up to kMaxConsecutiveOldReports
     // consecutive reports).
     // Expected window contents: [10011-10001] -> [10011-10001].
     for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) {
       AddTransportFeedbackAndValidate(&tracker, base + 0xc000, {true, true});
-      EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-      EXPECT_EQ(plr, 5.0f / 10.0f);
-      EXPECT_EQ(cplr, 3.0f / 10.0f);
+      ValidatePacketReceptionStatistics(tracker, 5.0f / 10.0f, 2.0f / 9.0f);
     }
 
     // If we receive a feedback in quadrant #1, the above counter is reset.
-    // Expected window contents: [10011-10001] -> [11100-01111].
+    // Expected window contents: [10011-10001] -> [11100-01-GAP-111].
     AddTransportFeedbackAndValidate(&tracker, base + 0x8000,
                                     {true, true, true});
     for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) {
       // Note: though the feedback message reports three packets, it only gets
       // counted once.
       AddTransportFeedbackAndValidate(&tracker, base + 0xc000 + 10,
                                       {true, false, true});
-      EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-      EXPECT_EQ(plr, 3.0f / 10.0f);
-      EXPECT_EQ(cplr, 2.0f / 10.0f);
+      ValidatePacketReceptionStatistics(tracker, 3.0f / 10.0f, 1.0f / 8.0f);
     }
   }
 }
 
 // Quadrant four reports ignored for up to kMaxConsecutiveOldReports times.
 // After that, the window is reset.
 TEST(TransportFeedbackPacketLossTrackerTest, QuadrantFourReset) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Expected window contents: [] -> [10011-10001].
     AddTransportFeedbackAndValidate(
         &tracker, base,
         {true, false, false, true, true, true, false, false, false, true});
 
+    // Sanity
+    ValidatePacketReceptionStatistics(tracker, 5.0f / 10.0f, 2.0f / 9.0f);
+
     // The first kMaxConsecutiveOldReports quadrant #4 reports are ignored.
     // It doesn't matter that they consist of multiple packets - each report
     // is only counted once.
     for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) {
       // Expected window contents: [10011-10001] -> [10011-10001].
       AddTransportFeedbackAndValidate(&tracker, base + 0xc000,
                                       {true, true, false, true});
-      EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-      EXPECT_EQ(plr, 5.0f / 10.0f);
-      EXPECT_EQ(cplr, 3.0f / 10.0f);
+      ValidatePacketReceptionStatistics(tracker, 5.0f / 10.0f, 2.0f / 9.0f);
     }
 
     // One additional feedback in quadrant #4 brings us over
     // kMaxConsecutiveOldReports consecutive "old" reports, resetting the
     // window.
+    // The new window is not completely empty - it's been seeded with the
+    // packets reported in the feedback that has triggered the reset.
     // Note: The report doesn't have to be the same as the previous ones.
     // Expected window contents: [10011-10001] -> [10011].
     AddTransportFeedbackAndValidate(&tracker, base + 0xc000,
                                     {true, false, false, true, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-
-    // The new window is not completely empty - it's been seeded with the
-    // packets reported in the feedback that has triggered the reset.
-    EXPECT_EQ(plr, 2.0f / 5.0f);
-    EXPECT_EQ(cplr, 1.0f / 5.0f);
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
   }
 }
 
 // Feedbacks spanning multiple quadrant are treated correctly (Q1-Q2).
 TEST(TransportFeedbackPacketLossTrackerTest, MultiQuadrantQ1Q2) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Expected window contents: [] -> [10011].
     AddTransportFeedbackAndValidate(&tracker, base,
                                     {true, false, false, true, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
 
     // A feedback with entries in both quadrant #1 and #2 gets both counted:
-    // Expected window contents: [10011] -> [10011-11].
-    AddTransportFeedbackAndValidate(&tracker, base + 0x3fff, {true, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 2.0f / 7.0f);
-    EXPECT_EQ(cplr, 1.0f / 7.0f);
+    // Expected window contents: [10011] -> [10011-GAP-1001].
+    AddTransportFeedbackAndValidate(&tracker, base + 0x3ffe,
+                                    {true, false, false, true});
+    ValidatePacketReceptionStatistics(tracker, 4.0f / 9.0f, 2.0f / 7.0f);
   }
 }
 
 // Feedbacks spanning multiple quadrant are treated correctly (Q2-Q3).
 TEST(TransportFeedbackPacketLossTrackerTest, MultiQuadrantQ2Q3) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Expected window contents: [] -> [10011-00001].
     AddTransportFeedbackAndValidate(
         &tracker, base,
         {true, false, false, true, true, false, false, false, false, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 6.0f / 10.0f);
-    EXPECT_EQ(cplr, 4.0f / 10.0f);
+    ValidatePacketReceptionStatistics(tracker, 6.0f / 10.0f, 2.0f / 9.0f);
 
     // A feedback with entries in both quadrant #2 and #3 gets both counted,
     // but only those from #3 trigger throwing out old entries from quadrant #1:
-    // Expected window contents: [10011-00001] -> [01100-00110-01].
+    // Expected window contents: [10011-00001] -> [01100-001-GAP-1001].
     AddTransportFeedbackAndValidate(&tracker, base + 0x7ffe,
                                     {true, false, false, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 7.0f / 12.0f);
-    EXPECT_EQ(cplr, 4.0f / 12.0f);
+    ValidatePacketReceptionStatistics(tracker, 7.0f / 12.0f, 3.0f / 10.0f);
   }
 }
 
-// Feedbacks spanning multiple quadrant are treated correctly (Q2-Q3).
+// Feedbacks spanning multiple quadrant are treated correctly (Q3-Q4).
 TEST(TransportFeedbackPacketLossTrackerTest, MultiQuadrantQ3Q4) {
   for (uint16_t base : kBases) {
-    float plr = 0.0f;   // Packet-loss-rate
-    float cplr = 0.0f;  // Consecutive-packet-loss-rate
-
-    TransportFeedbackPacketLossTracker tracker(5, 20);
+    TransportFeedbackPacketLossTracker tracker(5, 20, 1);
 
     // Expected window contents: [] -> [10011-00001].
     AddTransportFeedbackAndValidate(
         &tracker, base,
         {true, false, false, true, true, false, false, false, false, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 6.0f / 10.0f);
-    EXPECT_EQ(cplr, 4.0f / 10.0f);
+    ValidatePacketReceptionStatistics(tracker, 6.0f / 10.0f, 2.0f / 9.0f);
 
     // A feedback with entries in both quadrant #3 and #4 would have the entries
     // from quadrant #3 shift enough quadrant #1 entries out of window, that
     // by the time the #4 packets are examined, the moving baseline has made
     // them into quadrant #3 packets.
     // Expected window contents: [10011-00001] -> [10011].
     AddTransportFeedbackAndValidate(&tracker, base + 0xbfff,
                                     {true, false, false, true, true});
-    EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr));
-    EXPECT_EQ(plr, 2.0f / 5.0f);
-    EXPECT_EQ(cplr, 1.0f / 5.0f);
+    ValidatePacketReceptionStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f);
   }
 }
 
 }  // namespace webrtc