| /* |
| * 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/modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
| #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
| #include "webrtc/rtc_base/checks.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> { |
| public: |
| TransportFeedbackPacketLossTrackerTest() = default; |
| virtual ~TransportFeedbackPacketLossTrackerTest() = default; |
| |
| protected: |
| void SendPackets(TransportFeedbackPacketLossTracker* tracker, |
| const std::vector<uint16_t>& sequence_numbers, |
| int64_t send_time_interval_ms, |
| bool validate_all = true) { |
| RTC_CHECK_GE(send_time_interval_ms, 0); |
| for (uint16_t sequence_number : sequence_numbers) { |
| tracker->OnPacketAdded(sequence_number, time_ms_); |
| if (validate_all) { |
| tracker->Validate(); |
| } |
| time_ms_ += send_time_interval_ms; |
| } |
| |
| // We've either validated after each packet, or, for making sure the UT |
| // doesn't run too long, we might validate only at the end of the range. |
| if (!validate_all) { |
| tracker->Validate(); |
| } |
| } |
| |
| void SendPackets(TransportFeedbackPacketLossTracker* tracker, |
| uint16_t first_seq_num, |
| size_t num_of_packets, |
| int64_t send_time_interval_ms, |
| bool validate_all = true) { |
| RTC_CHECK_GE(send_time_interval_ms, 0); |
| std::vector<uint16_t> sequence_numbers(num_of_packets); |
| std::iota(sequence_numbers.begin(), sequence_numbers.end(), first_seq_num); |
| SendPackets(tracker, sequence_numbers, send_time_interval_ms, validate_all); |
| } |
| |
| void AdvanceClock(int64_t time_delta_ms) { |
| RTC_CHECK_GT(time_delta_ms, 0); |
| time_ms_ += time_delta_ms; |
| } |
| |
| void AddTransportFeedbackAndValidate( |
| TransportFeedbackPacketLossTracker* tracker, |
| uint16_t base_sequence_num, |
| const std::vector<bool>& reception_status_vec) { |
| // Any positive integer signals reception. kNotReceived signals loss. |
| // Other values are just illegal. |
| constexpr int64_t kArrivalTimeMs = 1234; |
| |
| std::vector<PacketFeedback> packet_feedback_vector; |
| uint16_t seq_num = base_sequence_num; |
| for (bool received : reception_status_vec) { |
| packet_feedback_vector.emplace_back(PacketFeedback( |
| received ? kArrivalTimeMs : PacketFeedback::kNotReceived, seq_num)); |
| ++seq_num; |
| } |
| |
| tracker->OnPacketFeedbackVector(packet_feedback_vector); |
| tracker->Validate(); |
| } |
| |
| // Checks that validty is as expected. If valid, checks also that |
| // value is as expected. |
| void ValidatePacketLossStatistics( |
| const TransportFeedbackPacketLossTracker& tracker, |
| rtc::Optional<float> expected_plr, |
| rtc::Optional<float> expected_rplr) { |
| // TODO(eladalon): Comparing the rtc::Optional<float> directly would have |
| // given concise code, but less readable error messages. If we modify |
| // the way rtc::Optional is printed, we can get rid of this. |
| rtc::Optional<float> plr = tracker.GetPacketLossRate(); |
| EXPECT_EQ(static_cast<bool>(expected_plr), static_cast<bool>(plr)); |
| if (expected_plr && plr) { |
| EXPECT_EQ(*expected_plr, *plr); |
| } |
| |
| rtc::Optional<float> rplr = tracker.GetRecoverablePacketLossRate(); |
| EXPECT_EQ(static_cast<bool>(expected_rplr), static_cast<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 ValidatePacketLossStatistics( |
| const TransportFeedbackPacketLossTracker& tracker, |
| float expected_plr, |
| float expected_rplr) { |
| ValidatePacketLossStatistics(tracker, rtc::Optional<float>(expected_plr), |
| rtc::Optional<float>(expected_rplr)); |
| } |
| |
| uint16_t base_{GetParam()}; |
| |
| 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(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(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, 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(kDefaultMaxWindowSizeMs, 5, 4); |
| |
| // PLR unknown before minimum window size reached. |
| // RPLR unknown before minimum pairs reached. |
| // Expected window contents: [] -> [1001]. |
| 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(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, 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(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, 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(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(kDefaultMaxWindowSizeMs, 5, 5); |
| |
| 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(kDefaultMaxWindowSizeMs, 5, 4); |
| |
| int64_t frames[] = {20, 60, 120, 20, 60}; |
| for (size_t i = 0; i < sizeof(frames) / sizeof(frames[0]); 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(4 * kDefaultSendIntervalMs, 5, 1); |
| |
| SendPackets(&tracker, base_, 6, kDefaultSendIntervalMs, true); |
| |
| // 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(kDefaultMaxWindowSizeMs, 5, 4); |
| |
| // Expected window contents: [] -> [11111]. |
| 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(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, 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(kDefaultMaxWindowSizeMs, 5, 4); |
| |
| 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(kDefaultMaxWindowSizeMs, 5, 1); |
| |
| 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(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 * kDefaultSendIntervalMs, 5, |
| 1); |
| |
| 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); |
| } |
| |
| // Moving a window, if it excludes some old acked messages, can leave |
| // in-window unacked messages intact, and ready to be used later. |
| TEST_P(TransportFeedbackPacketLossTrackerTest, MovedWindowRetainsRelevantInfo) { |
| constexpr int64_t max_window_size_ms = 100; |
| TransportFeedbackPacketLossTracker tracker(max_window_size_ms, 5, 1); |
| |
| // Note: All messages in this test are sent 1ms apart from each other. |
| // Therefore, the delta in sequence numbers equals the timestamps delta. |
| SendPackets(&tracker, base_, 4 * max_window_size_ms, 1); |
| |
| // Expected window contents: [] -> [10101]. |
| AddTransportFeedbackAndValidate(&tracker, base_, |
| {true, false, true, false, true}); |
| ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 2.0f / 4.0f); |
| |
| // Expected window contents: [10101] -> [100011]. |
| const int64_t moved_oldest_acked = base_ + 2 * max_window_size_ms; |
| const std::vector<bool> feedback = {true, false, false, false, true, true}; |
| AddTransportFeedbackAndValidate(&tracker, moved_oldest_acked, feedback); |
| ValidatePacketLossStatistics(tracker, 3.0f / 6.0f, 1.0f / 5.0f); |
| |
| // Having acked |feedback.size()| starting with |moved_oldest_acked|, the |
| // newest of the acked ones is now: |
| const int64_t moved_newest_acked = moved_oldest_acked + feedback.size() - 1; |
| |
| // Messages that *are* more than the span-limit away from the newest |
| // acked message *are* too old. Acking them would have no effect. |
| AddTransportFeedbackAndValidate( |
| &tracker, moved_newest_acked - max_window_size_ms - 1, {true}); |
| ValidatePacketLossStatistics(tracker, 3.0f / 6.0f, 1.0f / 5.0f); |
| |
| // 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(150 * kDefaultSendIntervalMs, 5, |
| 1); |
| |
| 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(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)}, |
| 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)}, |
| 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); |
| |
| SendPackets(&tracker, base_, 0x2000, 1, false); |
| |
| // Expected window contents: [] -> [10011]. |
| AddTransportFeedbackAndValidate(&tracker, base_, |
| {true, false, false, true, true}); |
| ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f); |
| |
| // Sending more unacked packets, up to 0x7fff from the base, does not |
| // move the window or discard any information. |
| SendPackets(&tracker, static_cast<uint16_t>(base_ + 0x8000 - 0x2000), 0x2000, |
| 1, false); |
| ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f); |
| |
| // Sending more unacked packets, up to 0x7fff from the base, does not |
| // move the window or discard any information. |
| // Expected window contents: [10011] -> [0011]. |
| SendPackets(&tracker, static_cast<uint16_t>(base_ + 0x8000), 1, 1); |
| ValidatePacketLossStatistics(tracker, 2.0f / 4.0f, 1.0f / 3.0f); |
| } |
| |
| // The window holds acked packets up until the difference in timestamps between |
| // the oldest and newest reaches the configured maximum. Once this maximum |
| // is exceeded, old packets are shifted out of window until the maximum is |
| // once again observed. |
| TEST_P(TransportFeedbackPacketLossTrackerTest, TimeDifferenceMaximumObserved) { |
| constexpr int64_t max_window_size_ms = 500; |
| TransportFeedbackPacketLossTracker tracker(max_window_size_ms, 3, 1); |
| |
| // Note: All messages in this test are sent 1ms apart from each other. |
| // Therefore, the delta in sequence numbers equals the timestamps delta. |
| |
| // Baseline - window has acked messages. |
| // Expected window contents: [] -> [01101]. |
| const std::vector<bool> feedback = {false, true, true, false, true}; |
| SendPackets(&tracker, base_, feedback.size(), 1); |
| AddTransportFeedbackAndValidate(&tracker, base_, feedback); |
| ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 2.0f / 4.0f); |
| |
| // Test - window base not moved. |
| // Expected window contents: [01101] -> [011011]. |
| AdvanceClock(max_window_size_ms - feedback.size()); |
| SendPackets(&tracker, static_cast<uint16_t>(base_ + feedback.size()), 1, 1); |
| AddTransportFeedbackAndValidate( |
| &tracker, static_cast<uint16_t>(base_ + feedback.size()), {true}); |
| ValidatePacketLossStatistics(tracker, 2.0f / 6.0f, 2.0f / 5.0f); |
| |
| // Another packet, sent 1ms later, would already be too late. The window will |
| // be moved, but only after the ACK is received. |
| 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(50 * kDefaultSendIntervalMs, 2, 1); |
| |
| // Baseline - window has acked messages. |
| // Expected window contents: [] -> [01101]. |
| 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)}, |
| 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(50 * kDefaultSendIntervalMs, 2, 1); |
| |
| // Baseline - window has acked messages. |
| // Expected window contents: [] -> [01101]. |
| 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)}, |
| 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), ""); |
| } |
| |
| TEST(TransportFeedbackPacketLossTrackerTest, InvalidConfigPlrMinAcked) { |
| EXPECT_DEATH(TransportFeedbackPacketLossTracker tracker(5000, 0, 10), ""); |
| } |
| |
| TEST(TransportFeedbackPacketLossTrackerTest, InvalidConfigRplrMinPairs) { |
| EXPECT_DEATH(TransportFeedbackPacketLossTracker tracker(5000, 20, 0), ""); |
| } |
| |
| TEST(TransportFeedbackPacketLossTrackerTest, TimeCantFlowBackwards) { |
| TransportFeedbackPacketLossTracker tracker(5000, 2, 1); |
| tracker.OnPacketAdded(100, 0); |
| tracker.OnPacketAdded(101, 2); |
| EXPECT_DEATH(tracker.OnPacketAdded(102, 1), ""); |
| } |
| #endif |
| |
| // 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 |