minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
| 11 | #include <limits> |
| 12 | #include <memory> |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 13 | #include <numeric> |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 14 | #include <vector> |
| 15 | |
Fredrik Solenberg | a8b7c7f | 2018-01-17 11:18:31 +0100 | [diff] [blame] | 16 | #include "audio/transport_feedback_packet_loss_tracker.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 17 | #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
| 18 | #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
| 19 | #include "rtc_base/checks.h" |
| 20 | #include "test/gmock.h" |
| 21 | #include "test/gtest.h" |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 22 | |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 23 | namespace webrtc { |
| 24 | |
| 25 | namespace { |
| 26 | |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 27 | constexpr int64_t kDefaultSendIntervalMs = 10; |
| 28 | constexpr int64_t kDefaultMaxWindowSizeMs = 500 * kDefaultSendIntervalMs; |
| 29 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 30 | class TransportFeedbackPacketLossTrackerTest |
| 31 | : public ::testing::TestWithParam<uint16_t> { |
| 32 | public: |
| 33 | TransportFeedbackPacketLossTrackerTest() = default; |
| 34 | virtual ~TransportFeedbackPacketLossTrackerTest() = default; |
| 35 | |
| 36 | protected: |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 37 | void SendPackets(TransportFeedbackPacketLossTracker* tracker, |
| 38 | const std::vector<uint16_t>& sequence_numbers, |
| 39 | int64_t send_time_interval_ms, |
| 40 | bool validate_all = true) { |
| 41 | RTC_CHECK_GE(send_time_interval_ms, 0); |
| 42 | for (uint16_t sequence_number : sequence_numbers) { |
| 43 | tracker->OnPacketAdded(sequence_number, time_ms_); |
| 44 | if (validate_all) { |
| 45 | tracker->Validate(); |
| 46 | } |
| 47 | time_ms_ += send_time_interval_ms; |
| 48 | } |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 49 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 50 | // We've either validated after each packet, or, for making sure the UT |
| 51 | // doesn't run too long, we might validate only at the end of the range. |
| 52 | if (!validate_all) { |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 53 | tracker->Validate(); |
| 54 | } |
| 55 | } |
| 56 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 57 | void SendPackets(TransportFeedbackPacketLossTracker* tracker, |
| 58 | uint16_t first_seq_num, |
| 59 | size_t num_of_packets, |
| 60 | int64_t send_time_interval_ms, |
| 61 | bool validate_all = true) { |
| 62 | RTC_CHECK_GE(send_time_interval_ms, 0); |
| 63 | std::vector<uint16_t> sequence_numbers(num_of_packets); |
| 64 | std::iota(sequence_numbers.begin(), sequence_numbers.end(), first_seq_num); |
| 65 | SendPackets(tracker, sequence_numbers, send_time_interval_ms, validate_all); |
| 66 | } |
| 67 | |
| 68 | void AdvanceClock(int64_t time_delta_ms) { |
| 69 | RTC_CHECK_GT(time_delta_ms, 0); |
| 70 | time_ms_ += time_delta_ms; |
| 71 | } |
| 72 | |
| 73 | void AddTransportFeedbackAndValidate( |
| 74 | TransportFeedbackPacketLossTracker* tracker, |
| 75 | uint16_t base_sequence_num, |
| 76 | const std::vector<bool>& reception_status_vec) { |
elad.alon | 92e448d | 2017-03-21 07:31:35 -0700 | [diff] [blame] | 77 | // Any positive integer signals reception. kNotReceived signals loss. |
| 78 | // Other values are just illegal. |
| 79 | constexpr int64_t kArrivalTimeMs = 1234; |
| 80 | |
| 81 | std::vector<PacketFeedback> packet_feedback_vector; |
| 82 | uint16_t seq_num = base_sequence_num; |
| 83 | for (bool received : reception_status_vec) { |
| 84 | packet_feedback_vector.emplace_back(PacketFeedback( |
| 85 | received ? kArrivalTimeMs : PacketFeedback::kNotReceived, seq_num)); |
| 86 | ++seq_num; |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 87 | } |
| 88 | |
elad.alon | d12a8e1 | 2017-03-23 11:04:48 -0700 | [diff] [blame] | 89 | tracker->OnPacketFeedbackVector(packet_feedback_vector); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 90 | tracker->Validate(); |
| 91 | } |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 92 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 93 | // Checks that validty is as expected. If valid, checks also that |
| 94 | // value is as expected. |
| 95 | void ValidatePacketLossStatistics( |
| 96 | const TransportFeedbackPacketLossTracker& tracker, |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 97 | absl::optional<float> expected_plr, |
| 98 | absl::optional<float> expected_rplr) { |
| 99 | // TODO(eladalon): Comparing the absl::optional<float> directly would have |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 100 | // given concise code, but less readable error messages. If we modify |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 101 | // the way absl::optional is printed, we can get rid of this. |
| 102 | absl::optional<float> plr = tracker.GetPacketLossRate(); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 103 | EXPECT_EQ(static_cast<bool>(expected_plr), static_cast<bool>(plr)); |
| 104 | if (expected_plr && plr) { |
| 105 | EXPECT_EQ(*expected_plr, *plr); |
| 106 | } |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 107 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 108 | absl::optional<float> rplr = tracker.GetRecoverablePacketLossRate(); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 109 | EXPECT_EQ(static_cast<bool>(expected_rplr), static_cast<bool>(rplr)); |
| 110 | if (expected_rplr && rplr) { |
| 111 | EXPECT_EQ(*expected_rplr, *rplr); |
| 112 | } |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 113 | } |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 114 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 115 | uint16_t base_{GetParam()}; |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 116 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 117 | private: |
| 118 | int64_t time_ms_{0}; |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 119 | }; |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 120 | |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 121 | } // namespace |
| 122 | |
| 123 | // Sanity check on an empty window. |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 124 | TEST_P(TransportFeedbackPacketLossTrackerTest, EmptyWindow) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 125 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 5); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 126 | |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 127 | // PLR and RPLR reported as unknown before reception of first feedback. |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 128 | ValidatePacketLossStatistics(tracker, absl::nullopt, absl::nullopt); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 129 | } |
| 130 | |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 131 | // A feedback received for an empty window has no effect. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 132 | TEST_P(TransportFeedbackPacketLossTrackerTest, EmptyWindowFeedback) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 133 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 3, 2); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 134 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 135 | // Feedback doesn't correspond to any packets - ignored. |
| 136 | AddTransportFeedbackAndValidate(&tracker, base_, {true, false, true}); |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 137 | ValidatePacketLossStatistics(tracker, absl::nullopt, absl::nullopt); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 138 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 139 | // After the packets are transmitted, acking them would have an effect. |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 140 | SendPackets(&tracker, base_, 3, kDefaultSendIntervalMs); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 141 | AddTransportFeedbackAndValidate(&tracker, base_, {true, false, true}); |
| 142 | ValidatePacketLossStatistics(tracker, 1.0f / 3.0f, 0.5f); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 143 | } |
| 144 | |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 145 | // Sanity check on partially filled window. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 146 | TEST_P(TransportFeedbackPacketLossTrackerTest, PartiallyFilledWindow) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 147 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 148 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 149 | // PLR unknown before minimum window size reached. |
| 150 | // RPLR unknown before minimum pairs reached. |
| 151 | // Expected window contents: [] -> [1001]. |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 152 | SendPackets(&tracker, base_, 3, kDefaultSendIntervalMs); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 153 | AddTransportFeedbackAndValidate(&tracker, base_, {true, false, false, true}); |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 154 | ValidatePacketLossStatistics(tracker, absl::nullopt, absl::nullopt); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 155 | } |
| 156 | |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 157 | // Sanity check on minimum filled window - PLR known, RPLR unknown. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 158 | TEST_P(TransportFeedbackPacketLossTrackerTest, PlrMinimumFilledWindow) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 159 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 5); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 160 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 161 | // PLR correctly calculated after minimum window size reached. |
| 162 | // RPLR not necessarily known at that time (not if min-pairs not reached). |
| 163 | // Expected window contents: [] -> [10011]. |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 164 | SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 165 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 166 | {true, false, false, true, true}); |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 167 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, absl::nullopt); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 168 | } |
| 169 | |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 170 | // Sanity check on minimum filled window - PLR unknown, RPLR known. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 171 | TEST_P(TransportFeedbackPacketLossTrackerTest, RplrMinimumFilledWindow) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 172 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 6, 4); |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 173 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 174 | // RPLR correctly calculated after minimum pairs reached. |
| 175 | // PLR not necessarily known at that time (not if min window not reached). |
| 176 | // Expected window contents: [] -> [10011]. |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 177 | SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 178 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 179 | {true, false, false, true, true}); |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 180 | ValidatePacketLossStatistics(tracker, absl::nullopt, 1.0f / 4.0f); |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 181 | } |
| 182 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 183 | // If packets are sent close enough together that the clock reading for both |
| 184 | // is the same, that's handled properly. |
| 185 | TEST_P(TransportFeedbackPacketLossTrackerTest, SameSentTime) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 186 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 3, 2); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 187 | |
| 188 | // Expected window contents: [] -> [101]. |
| 189 | SendPackets(&tracker, base_, 3, 0); // Note: time interval = 0ms. |
| 190 | AddTransportFeedbackAndValidate(&tracker, base_, {true, false, true}); |
| 191 | |
| 192 | ValidatePacketLossStatistics(tracker, 1.0f / 3.0f, 0.5f); |
| 193 | } |
| 194 | |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 195 | // Additional reports update PLR and RPLR. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 196 | TEST_P(TransportFeedbackPacketLossTrackerTest, ExtendWindow) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 197 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 5); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 198 | |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 199 | SendPackets(&tracker, base_, 25, kDefaultSendIntervalMs); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 200 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 201 | // Expected window contents: [] -> [10011]. |
| 202 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 203 | {true, false, false, true, true}); |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 204 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, absl::nullopt); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 205 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 206 | // Expected window contents: [10011] -> [1001110101]. |
| 207 | AddTransportFeedbackAndValidate(&tracker, base_ + 5, |
| 208 | {true, false, true, false, true}); |
| 209 | ValidatePacketLossStatistics(tracker, 4.0f / 10.0f, 3.0f / 9.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 210 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 211 | // Expected window contents: [1001110101] -> [1001110101-GAP-10001]. |
| 212 | AddTransportFeedbackAndValidate(&tracker, base_ + 20, |
| 213 | {true, false, false, false, true}); |
| 214 | ValidatePacketLossStatistics(tracker, 7.0f / 15.0f, 4.0f / 13.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 215 | } |
| 216 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 217 | // Correct calculation with different packet lengths. |
| 218 | TEST_P(TransportFeedbackPacketLossTrackerTest, DifferentSentIntervals) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 219 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 220 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 221 | int64_t frames[] = {20, 60, 120, 20, 60}; |
| 222 | for (size_t i = 0; i < sizeof(frames) / sizeof(frames[0]); i++) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 223 | SendPackets(&tracker, {static_cast<uint16_t>(base_ + i)}, frames[i]); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 224 | } |
| 225 | |
| 226 | // Expected window contents: [] -> [10011]. |
| 227 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 228 | {true, false, false, true, true}); |
| 229 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f); |
| 230 | } |
| 231 | |
| 232 | // The window retains information up to sent times that exceed the the max |
| 233 | // window size. The oldest packets get shifted out of window to make room |
| 234 | // for the newer ones. |
| 235 | TEST_P(TransportFeedbackPacketLossTrackerTest, MaxWindowSize) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 236 | TransportFeedbackPacketLossTracker tracker(4 * kDefaultSendIntervalMs, 5, 1); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 237 | |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 238 | SendPackets(&tracker, base_, 6, kDefaultSendIntervalMs, true); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 239 | |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 240 | // Up to the maximum time-span retained (first + 4 * kDefaultSendIntervalMs). |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 241 | // Expected window contents: [] -> [01001]. |
| 242 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 243 | {false, true, false, false, true}); |
| 244 | ValidatePacketLossStatistics(tracker, 3.0f / 5.0f, 2.0f / 4.0f); |
| 245 | |
| 246 | // After the maximum time-span, older entries are discarded to accommodate |
| 247 | // newer ones. |
| 248 | // Expected window contents: [01001] -> [10011]. |
| 249 | AddTransportFeedbackAndValidate(&tracker, base_ + 5, {true}); |
| 250 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f); |
| 251 | } |
| 252 | |
| 253 | // All packets received. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 254 | TEST_P(TransportFeedbackPacketLossTrackerTest, AllReceived) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 255 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 256 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 257 | // Expected window contents: [] -> [11111]. |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 258 | SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 259 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 260 | {true, true, true, true, true}); |
| 261 | ValidatePacketLossStatistics(tracker, 0.0f, 0.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 262 | } |
| 263 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 264 | // All packets lost. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 265 | TEST_P(TransportFeedbackPacketLossTrackerTest, AllLost) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 266 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 267 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 268 | // Note: The last packet in the feedback does not belong to the stream. |
| 269 | // It's only there because we're not allowed to end a feedback with a loss. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 270 | // Expected window contents: [] -> [00000]. |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 271 | SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 272 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 273 | {false, false, false, false, false, true}); |
| 274 | ValidatePacketLossStatistics(tracker, 1.0f, 0.0f); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 275 | } |
| 276 | |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 277 | // Repeated reports are ignored. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 278 | TEST_P(TransportFeedbackPacketLossTrackerTest, ReportRepetition) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 279 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 280 | |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 281 | SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 282 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 283 | // Expected window contents: [] -> [10011]. |
| 284 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 285 | {true, false, false, true, true}); |
| 286 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 287 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 288 | // Repeat entire previous feedback |
| 289 | // Expected window contents: [10011] -> [10011]. |
| 290 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 291 | {true, false, false, true, true}); |
| 292 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 293 | } |
| 294 | |
| 295 | // Report overlap. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 296 | TEST_P(TransportFeedbackPacketLossTrackerTest, ReportOverlap) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 297 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 1); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 298 | |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 299 | SendPackets(&tracker, base_, 15, kDefaultSendIntervalMs); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 300 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 301 | // Expected window contents: [] -> [10011]. |
| 302 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 303 | {true, false, false, true, true}); |
| 304 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 305 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 306 | // Expected window contents: [10011] -> [1001101]. |
| 307 | AddTransportFeedbackAndValidate(&tracker, base_ + 3, |
| 308 | {true, true, false, true}); |
| 309 | ValidatePacketLossStatistics(tracker, 3.0f / 7.0f, 2.0f / 6.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 310 | } |
| 311 | |
| 312 | // Report conflict. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 313 | TEST_P(TransportFeedbackPacketLossTrackerTest, ReportConflict) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 314 | TransportFeedbackPacketLossTracker tracker(kDefaultMaxWindowSizeMs, 5, 4); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 315 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 316 | SendPackets(&tracker, base_, 15, 10); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 317 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 318 | // Expected window contents: [] -> [01001]. |
| 319 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 320 | {false, true, false, false, true}); |
| 321 | ValidatePacketLossStatistics(tracker, 3.0f / 5.0f, 2.0f / 4.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 322 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 323 | // Expected window contents: [01001] -> [11101]. |
| 324 | // While false->true will be applied, true -> false will be ignored. |
| 325 | AddTransportFeedbackAndValidate(&tracker, base_, {true, false, true}); |
| 326 | ValidatePacketLossStatistics(tracker, 1.0f / 5.0f, 1.0f / 4.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 327 | } |
| 328 | |
| 329 | // Skipped packets treated as unknown (not lost). |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 330 | TEST_P(TransportFeedbackPacketLossTrackerTest, SkippedPackets) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 331 | TransportFeedbackPacketLossTracker tracker(200 * kDefaultSendIntervalMs, 5, |
| 332 | 1); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 333 | |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 334 | SendPackets(&tracker, base_, 200, kDefaultSendIntervalMs); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 335 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 336 | // Expected window contents: [] -> [10011]. |
| 337 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 338 | {true, false, false, true, true}); |
| 339 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 340 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 341 | // Expected window contents: [10011] -> [10011-GAP-101]. |
| 342 | AddTransportFeedbackAndValidate(&tracker, base_ + 100, {true, false, true}); |
| 343 | ValidatePacketLossStatistics(tracker, 3.0f / 8.0f, 2.0f / 6.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 344 | } |
| 345 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 346 | // Moving a window, if it excludes some old acked messages, can leave |
| 347 | // in-window unacked messages intact, and ready to be used later. |
| 348 | TEST_P(TransportFeedbackPacketLossTrackerTest, MovedWindowRetainsRelevantInfo) { |
| 349 | constexpr int64_t max_window_size_ms = 100; |
| 350 | TransportFeedbackPacketLossTracker tracker(max_window_size_ms, 5, 1); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 351 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 352 | // Note: All messages in this test are sent 1ms apart from each other. |
| 353 | // Therefore, the delta in sequence numbers equals the timestamps delta. |
| 354 | SendPackets(&tracker, base_, 4 * max_window_size_ms, 1); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 355 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 356 | // Expected window contents: [] -> [10101]. |
| 357 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 358 | {true, false, true, false, true}); |
| 359 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 2.0f / 4.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 360 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 361 | // Expected window contents: [10101] -> [100011]. |
| 362 | const int64_t moved_oldest_acked = base_ + 2 * max_window_size_ms; |
| 363 | const std::vector<bool> feedback = {true, false, false, false, true, true}; |
| 364 | AddTransportFeedbackAndValidate(&tracker, moved_oldest_acked, feedback); |
| 365 | ValidatePacketLossStatistics(tracker, 3.0f / 6.0f, 1.0f / 5.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 366 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 367 | // Having acked |feedback.size()| starting with |moved_oldest_acked|, the |
| 368 | // newest of the acked ones is now: |
| 369 | const int64_t moved_newest_acked = moved_oldest_acked + feedback.size() - 1; |
| 370 | |
| 371 | // Messages that *are* more than the span-limit away from the newest |
| 372 | // acked message *are* too old. Acking them would have no effect. |
| 373 | AddTransportFeedbackAndValidate( |
| 374 | &tracker, moved_newest_acked - max_window_size_ms - 1, {true}); |
| 375 | ValidatePacketLossStatistics(tracker, 3.0f / 6.0f, 1.0f / 5.0f); |
| 376 | |
| 377 | // Messages that are *not* more than the span-limit away from the newest |
| 378 | // acked message are *not* too old. Acking them would have an effect. |
| 379 | AddTransportFeedbackAndValidate( |
| 380 | &tracker, moved_newest_acked - max_window_size_ms, {true}); |
| 381 | ValidatePacketLossStatistics(tracker, 3.0f / 7.0f, 1.0f / 5.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 382 | } |
| 383 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 384 | // Inserting feedback into the middle of a window works correctly - can |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 385 | // complete two pairs. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 386 | TEST_P(TransportFeedbackPacketLossTrackerTest, InsertionCompletesTwoPairs) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 387 | TransportFeedbackPacketLossTracker tracker(150 * kDefaultSendIntervalMs, 5, |
| 388 | 1); |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 389 | |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 390 | SendPackets(&tracker, base_, 15, kDefaultSendIntervalMs); |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 391 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 392 | // Expected window contents: [] -> [10111]. |
| 393 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 394 | {true, false, true, true, true}); |
| 395 | ValidatePacketLossStatistics(tracker, 1.0f / 5.0f, 1.0f / 4.0f); |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 396 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 397 | // Expected window contents: [10111] -> [10111-GAP-10101]. |
| 398 | AddTransportFeedbackAndValidate(&tracker, base_ + 7, |
| 399 | {true, false, true, false, true}); |
| 400 | ValidatePacketLossStatistics(tracker, 3.0f / 10.0f, 3.0f / 8.0f); |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 401 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 402 | // Insert in between, closing the gap completely. |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 403 | // Expected window contents: [10111-GAP-10101] -> [101110110101]. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 404 | AddTransportFeedbackAndValidate(&tracker, base_ + 5, {false, true}); |
| 405 | ValidatePacketLossStatistics(tracker, 4.0f / 12.0f, 4.0f / 11.0f); |
elad.alon | d83b967 | 2017-02-01 08:36:09 -0800 | [diff] [blame] | 406 | } |
| 407 | |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 408 | // Sequence number gaps are not gaps in reception. However, gaps in reception |
| 409 | // are still possible, if a packet which WAS sent on the stream is not acked. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 410 | TEST_P(TransportFeedbackPacketLossTrackerTest, SanityGapsInSequenceNumbers) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 411 | TransportFeedbackPacketLossTracker tracker(50 * kDefaultSendIntervalMs, 5, 1); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 412 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 413 | SendPackets( |
| 414 | &tracker, |
| 415 | {static_cast<uint16_t>(base_), static_cast<uint16_t>(base_ + 2), |
| 416 | static_cast<uint16_t>(base_ + 4), static_cast<uint16_t>(base_ + 6), |
| 417 | static_cast<uint16_t>(base_ + 8)}, |
| 418 | kDefaultSendIntervalMs); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 419 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 420 | // Gaps in sequence numbers not considered as gaps in window, because only |
| 421 | // those sequence numbers which were associated with the stream count. |
| 422 | // Expected window contents: [] -> [11011]. |
| 423 | AddTransportFeedbackAndValidate( |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 424 | // Note: Left packets belong to this stream, right ones ignored. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 425 | &tracker, base_, |
| 426 | {true, false, true, false, false, false, true, false, true, true}); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 427 | ValidatePacketLossStatistics(tracker, 1.0f / 5.0f, 1.0f / 4.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 428 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 429 | // Create gap by sending [base + 10] but not acking it. |
| 430 | // Note: Acks for [base + 11] and [base + 13] ignored (other stream). |
| 431 | // Expected window contents: [11011] -> [11011-GAP-01]. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 432 | SendPackets( |
| 433 | &tracker, |
| 434 | {static_cast<uint16_t>(base_ + 10), static_cast<uint16_t>(base_ + 12), |
| 435 | static_cast<uint16_t>(base_ + 14)}, |
| 436 | kDefaultSendIntervalMs); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 437 | AddTransportFeedbackAndValidate(&tracker, base_ + 11, |
| 438 | {false, false, false, true, true}); |
| 439 | ValidatePacketLossStatistics(tracker, 2.0f / 7.0f, 2.0f / 5.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 440 | } |
| 441 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 442 | // The window cannot span more than 0x8000 in sequence numbers, regardless |
| 443 | // of time stamps and ack/unacked status. |
| 444 | TEST_P(TransportFeedbackPacketLossTrackerTest, MaxUnackedPackets) { |
| 445 | TransportFeedbackPacketLossTracker tracker(0x10000, 4, 1); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 446 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 447 | SendPackets(&tracker, base_, 0x2000, 1, false); |
| 448 | |
| 449 | // Expected window contents: [] -> [10011]. |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 450 | AddTransportFeedbackAndValidate(&tracker, base_, |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 451 | {true, false, false, true, true}); |
| 452 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 453 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 454 | // Sending more unacked packets, up to 0x7fff from the base, does not |
| 455 | // move the window or discard any information. |
| 456 | SendPackets(&tracker, static_cast<uint16_t>(base_ + 0x8000 - 0x2000), 0x2000, |
| 457 | 1, false); |
| 458 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 1.0f / 4.0f); |
| 459 | |
| 460 | // Sending more unacked packets, up to 0x7fff from the base, does not |
| 461 | // move the window or discard any information. |
| 462 | // Expected window contents: [10011] -> [0011]. |
| 463 | SendPackets(&tracker, static_cast<uint16_t>(base_ + 0x8000), 1, 1); |
| 464 | ValidatePacketLossStatistics(tracker, 2.0f / 4.0f, 1.0f / 3.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 465 | } |
| 466 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 467 | // The window holds acked packets up until the difference in timestamps between |
| 468 | // the oldest and newest reaches the configured maximum. Once this maximum |
| 469 | // is exceeded, old packets are shifted out of window until the maximum is |
| 470 | // once again observed. |
| 471 | TEST_P(TransportFeedbackPacketLossTrackerTest, TimeDifferenceMaximumObserved) { |
| 472 | constexpr int64_t max_window_size_ms = 500; |
| 473 | TransportFeedbackPacketLossTracker tracker(max_window_size_ms, 3, 1); |
| 474 | |
| 475 | // Note: All messages in this test are sent 1ms apart from each other. |
| 476 | // Therefore, the delta in sequence numbers equals the timestamps delta. |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 477 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 478 | // Baseline - window has acked messages. |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 479 | // Expected window contents: [] -> [01101]. |
| 480 | const std::vector<bool> feedback = {false, true, true, false, true}; |
| 481 | SendPackets(&tracker, base_, feedback.size(), 1); |
| 482 | AddTransportFeedbackAndValidate(&tracker, base_, feedback); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 483 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 2.0f / 4.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 484 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 485 | // Test - window base not moved. |
| 486 | // Expected window contents: [01101] -> [011011]. |
| 487 | AdvanceClock(max_window_size_ms - feedback.size()); |
| 488 | SendPackets(&tracker, static_cast<uint16_t>(base_ + feedback.size()), 1, 1); |
| 489 | AddTransportFeedbackAndValidate( |
| 490 | &tracker, static_cast<uint16_t>(base_ + feedback.size()), {true}); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 491 | ValidatePacketLossStatistics(tracker, 2.0f / 6.0f, 2.0f / 5.0f); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 492 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 493 | // Another packet, sent 1ms later, would already be too late. The window will |
| 494 | // be moved, but only after the ACK is received. |
| 495 | const uint16_t new_packet_seq_num = |
| 496 | static_cast<uint16_t>(base_ + feedback.size() + 1); |
| 497 | SendPackets(&tracker, {new_packet_seq_num}, 1); |
| 498 | ValidatePacketLossStatistics(tracker, 2.0f / 6.0f, 2.0f / 5.0f); |
| 499 | // Expected window contents: [011011] -> [110111]. |
| 500 | AddTransportFeedbackAndValidate(&tracker, new_packet_seq_num, {true}); |
| 501 | ValidatePacketLossStatistics(tracker, 1.0f / 6.0f, 1.0f / 5.0f); |
| 502 | } |
elad.alon | 7af9357 | 2017-03-03 10:51:35 -0800 | [diff] [blame] | 503 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 504 | TEST_P(TransportFeedbackPacketLossTrackerTest, RepeatedSeqNumResetsWindow) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 505 | TransportFeedbackPacketLossTracker tracker(50 * kDefaultSendIntervalMs, 2, 1); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 506 | |
| 507 | // Baseline - window has acked messages. |
| 508 | // Expected window contents: [] -> [01101]. |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 509 | SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 510 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 511 | {false, true, true, false, true}); |
| 512 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 2.0f / 4.0f); |
| 513 | |
| 514 | // A reset occurs. |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 515 | SendPackets(&tracker, {static_cast<uint16_t>(base_ + 2)}, |
| 516 | kDefaultSendIntervalMs); |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 517 | ValidatePacketLossStatistics(tracker, absl::nullopt, absl::nullopt); |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 518 | } |
| 519 | |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 520 | // The window is reset by the sending of a packet which is 0x8000 or more |
| 521 | // away from the newest packet acked/unacked packet. |
| 522 | TEST_P(TransportFeedbackPacketLossTrackerTest, |
| 523 | SendAfterLongSuspensionResetsWindow) { |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 524 | TransportFeedbackPacketLossTracker tracker(50 * kDefaultSendIntervalMs, 2, 1); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 525 | |
| 526 | // Baseline - window has acked messages. |
| 527 | // Expected window contents: [] -> [01101]. |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 528 | SendPackets(&tracker, base_, 5, kDefaultSendIntervalMs); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 529 | AddTransportFeedbackAndValidate(&tracker, base_, |
| 530 | {false, true, true, false, true}); |
| 531 | ValidatePacketLossStatistics(tracker, 2.0f / 5.0f, 2.0f / 4.0f); |
| 532 | |
| 533 | // A reset occurs. |
elad.alon | 6a64bd9 | 2017-03-21 05:58:04 -0700 | [diff] [blame] | 534 | SendPackets(&tracker, {static_cast<uint16_t>(base_ + 5 + 0x8000)}, |
| 535 | kDefaultSendIntervalMs); |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 536 | ValidatePacketLossStatistics(tracker, absl::nullopt, absl::nullopt); |
elad.alon | 3f9b12d | 2017-03-15 07:38:13 -0700 | [diff] [blame] | 537 | } |
| 538 | |
| 539 | #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
| 540 | TEST(TransportFeedbackPacketLossTrackerTest, InvalidConfigMaxWindowSize) { |
| 541 | EXPECT_DEATH(TransportFeedbackPacketLossTracker tracker(0, 20, 10), ""); |
| 542 | } |
| 543 | |
| 544 | TEST(TransportFeedbackPacketLossTrackerTest, InvalidConfigPlrMinAcked) { |
| 545 | EXPECT_DEATH(TransportFeedbackPacketLossTracker tracker(5000, 0, 10), ""); |
| 546 | } |
| 547 | |
| 548 | TEST(TransportFeedbackPacketLossTrackerTest, InvalidConfigRplrMinPairs) { |
| 549 | EXPECT_DEATH(TransportFeedbackPacketLossTracker tracker(5000, 20, 0), ""); |
| 550 | } |
| 551 | |
| 552 | TEST(TransportFeedbackPacketLossTrackerTest, TimeCantFlowBackwards) { |
| 553 | TransportFeedbackPacketLossTracker tracker(5000, 2, 1); |
| 554 | tracker.OnPacketAdded(100, 0); |
| 555 | tracker.OnPacketAdded(101, 2); |
| 556 | EXPECT_DEATH(tracker.OnPacketAdded(102, 1), ""); |
| 557 | } |
| 558 | #endif |
| 559 | |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 560 | // All tests are run multiple times with various baseline sequence number, |
| 561 | // to weed out potential bugs with wrap-around handling. |
| 562 | constexpr uint16_t kBases[] = {0x0000, 0x3456, 0xc032, 0xfffe}; |
| 563 | |
Mirko Bonadei | c84f661 | 2019-01-31 12:20:57 +0100 | [diff] [blame] | 564 | INSTANTIATE_TEST_SUITE_P(_, |
| 565 | TransportFeedbackPacketLossTrackerTest, |
Mirko Bonadei | 6a489f2 | 2019-04-09 15:11:12 +0200 | [diff] [blame^] | 566 | ::testing::ValuesIn(kBases)); |
elad.alon | 02455b2 | 2017-03-03 11:11:06 -0800 | [diff] [blame] | 567 | |
minyue | 435ddf9 | 2017-01-23 08:07:05 -0800 | [diff] [blame] | 568 | } // namespace webrtc |