| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/base/backoff_entry.h" | |
| 6 #include "testing/gtest/include/gtest/gtest.h" | |
| 7 | |
| 8 namespace { | |
| 9 | |
| 10 using base::TimeDelta; | |
| 11 using base::TimeTicks; | |
| 12 using net::BackoffEntry; | |
| 13 | |
| 14 BackoffEntry::Policy base_policy = { 0, 1000, 2.0, 0.0, 20000, 2000, false }; | |
| 15 | |
| 16 class TestBackoffEntry : public BackoffEntry { | |
| 17 public: | |
| 18 explicit TestBackoffEntry(const Policy* const policy) | |
| 19 : BackoffEntry(policy), | |
| 20 now_(TimeTicks()) { | |
| 21 // Work around initialization in constructor not picking up | |
| 22 // fake time. | |
| 23 SetCustomReleaseTime(TimeTicks()); | |
| 24 } | |
| 25 | |
| 26 ~TestBackoffEntry() override {} | |
| 27 | |
| 28 TimeTicks ImplGetTimeNow() const override { return now_; } | |
| 29 | |
| 30 void set_now(const TimeTicks& now) { | |
| 31 now_ = now; | |
| 32 } | |
| 33 | |
| 34 private: | |
| 35 TimeTicks now_; | |
| 36 | |
| 37 DISALLOW_COPY_AND_ASSIGN(TestBackoffEntry); | |
| 38 }; | |
| 39 | |
| 40 TEST(BackoffEntryTest, BaseTest) { | |
| 41 TestBackoffEntry entry(&base_policy); | |
| 42 EXPECT_FALSE(entry.ShouldRejectRequest()); | |
| 43 EXPECT_EQ(TimeDelta(), entry.GetTimeUntilRelease()); | |
| 44 | |
| 45 entry.InformOfRequest(false); | |
| 46 EXPECT_TRUE(entry.ShouldRejectRequest()); | |
| 47 EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease()); | |
| 48 } | |
| 49 | |
| 50 TEST(BackoffEntryTest, CanDiscardNeverExpires) { | |
| 51 BackoffEntry::Policy never_expires_policy = base_policy; | |
| 52 never_expires_policy.entry_lifetime_ms = -1; | |
| 53 TestBackoffEntry never_expires(&never_expires_policy); | |
| 54 EXPECT_FALSE(never_expires.CanDiscard()); | |
| 55 never_expires.set_now(TimeTicks() + TimeDelta::FromDays(100)); | |
| 56 EXPECT_FALSE(never_expires.CanDiscard()); | |
| 57 } | |
| 58 | |
| 59 TEST(BackoffEntryTest, CanDiscard) { | |
| 60 TestBackoffEntry entry(&base_policy); | |
| 61 // Because lifetime is non-zero, we shouldn't be able to discard yet. | |
| 62 EXPECT_FALSE(entry.CanDiscard()); | |
| 63 | |
| 64 // Test the "being used" case. | |
| 65 entry.InformOfRequest(false); | |
| 66 EXPECT_FALSE(entry.CanDiscard()); | |
| 67 | |
| 68 // Test the case where there are errors but we can time out. | |
| 69 entry.set_now( | |
| 70 entry.GetReleaseTime() + TimeDelta::FromMilliseconds(1)); | |
| 71 EXPECT_FALSE(entry.CanDiscard()); | |
| 72 entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds( | |
| 73 base_policy.maximum_backoff_ms + 1)); | |
| 74 EXPECT_TRUE(entry.CanDiscard()); | |
| 75 | |
| 76 // Test the final case (no errors, dependent only on specified lifetime). | |
| 77 entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds( | |
| 78 base_policy.entry_lifetime_ms - 1)); | |
| 79 entry.InformOfRequest(true); | |
| 80 EXPECT_FALSE(entry.CanDiscard()); | |
| 81 entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds( | |
| 82 base_policy.entry_lifetime_ms)); | |
| 83 EXPECT_TRUE(entry.CanDiscard()); | |
| 84 } | |
| 85 | |
| 86 TEST(BackoffEntryTest, CanDiscardAlwaysDelay) { | |
| 87 BackoffEntry::Policy always_delay_policy = base_policy; | |
| 88 always_delay_policy.always_use_initial_delay = true; | |
| 89 always_delay_policy.entry_lifetime_ms = 0; | |
| 90 | |
| 91 TestBackoffEntry entry(&always_delay_policy); | |
| 92 | |
| 93 // Because lifetime is non-zero, we shouldn't be able to discard yet. | |
| 94 entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(2000)); | |
| 95 EXPECT_TRUE(entry.CanDiscard()); | |
| 96 | |
| 97 // Even with no failures, we wait until the delay before we allow discard. | |
| 98 entry.InformOfRequest(true); | |
| 99 EXPECT_FALSE(entry.CanDiscard()); | |
| 100 | |
| 101 // Wait until the delay expires, and we can discard the entry again. | |
| 102 entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(1000)); | |
| 103 EXPECT_TRUE(entry.CanDiscard()); | |
| 104 } | |
| 105 | |
| 106 TEST(BackoffEntryTest, CanDiscardNotStored) { | |
| 107 BackoffEntry::Policy no_store_policy = base_policy; | |
| 108 no_store_policy.entry_lifetime_ms = 0; | |
| 109 TestBackoffEntry not_stored(&no_store_policy); | |
| 110 EXPECT_TRUE(not_stored.CanDiscard()); | |
| 111 } | |
| 112 | |
| 113 TEST(BackoffEntryTest, ShouldIgnoreFirstTwo) { | |
| 114 BackoffEntry::Policy lenient_policy = base_policy; | |
| 115 lenient_policy.num_errors_to_ignore = 2; | |
| 116 | |
| 117 BackoffEntry entry(&lenient_policy); | |
| 118 | |
| 119 entry.InformOfRequest(false); | |
| 120 EXPECT_FALSE(entry.ShouldRejectRequest()); | |
| 121 | |
| 122 entry.InformOfRequest(false); | |
| 123 EXPECT_FALSE(entry.ShouldRejectRequest()); | |
| 124 | |
| 125 entry.InformOfRequest(false); | |
| 126 EXPECT_TRUE(entry.ShouldRejectRequest()); | |
| 127 } | |
| 128 | |
| 129 TEST(BackoffEntryTest, ReleaseTimeCalculation) { | |
| 130 TestBackoffEntry entry(&base_policy); | |
| 131 | |
| 132 // With zero errors, should return "now". | |
| 133 TimeTicks result = entry.GetReleaseTime(); | |
| 134 EXPECT_EQ(entry.ImplGetTimeNow(), result); | |
| 135 | |
| 136 // 1 error. | |
| 137 entry.InformOfRequest(false); | |
| 138 result = entry.GetReleaseTime(); | |
| 139 EXPECT_EQ(entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(1000), result); | |
| 140 EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease()); | |
| 141 | |
| 142 // 2 errors. | |
| 143 entry.InformOfRequest(false); | |
| 144 result = entry.GetReleaseTime(); | |
| 145 EXPECT_EQ(entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(2000), result); | |
| 146 EXPECT_EQ(TimeDelta::FromMilliseconds(2000), entry.GetTimeUntilRelease()); | |
| 147 | |
| 148 // 3 errors. | |
| 149 entry.InformOfRequest(false); | |
| 150 result = entry.GetReleaseTime(); | |
| 151 EXPECT_EQ(entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(4000), result); | |
| 152 EXPECT_EQ(TimeDelta::FromMilliseconds(4000), entry.GetTimeUntilRelease()); | |
| 153 | |
| 154 // 6 errors (to check it doesn't pass maximum). | |
| 155 entry.InformOfRequest(false); | |
| 156 entry.InformOfRequest(false); | |
| 157 entry.InformOfRequest(false); | |
| 158 result = entry.GetReleaseTime(); | |
| 159 EXPECT_EQ( | |
| 160 entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(20000), result); | |
| 161 } | |
| 162 | |
| 163 TEST(BackoffEntryTest, ReleaseTimeCalculationAlwaysDelay) { | |
| 164 BackoffEntry::Policy always_delay_policy = base_policy; | |
| 165 always_delay_policy.always_use_initial_delay = true; | |
| 166 always_delay_policy.num_errors_to_ignore = 2; | |
| 167 | |
| 168 TestBackoffEntry entry(&always_delay_policy); | |
| 169 | |
| 170 // With previous requests, should return "now". | |
| 171 TimeTicks result = entry.GetReleaseTime(); | |
| 172 EXPECT_EQ(TimeDelta(), entry.GetTimeUntilRelease()); | |
| 173 | |
| 174 // 1 error. | |
| 175 entry.InformOfRequest(false); | |
| 176 EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease()); | |
| 177 | |
| 178 // 2 errors. | |
| 179 entry.InformOfRequest(false); | |
| 180 EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease()); | |
| 181 | |
| 182 // 3 errors, exponential backoff starts. | |
| 183 entry.InformOfRequest(false); | |
| 184 EXPECT_EQ(TimeDelta::FromMilliseconds(2000), entry.GetTimeUntilRelease()); | |
| 185 | |
| 186 // 4 errors. | |
| 187 entry.InformOfRequest(false); | |
| 188 EXPECT_EQ(TimeDelta::FromMilliseconds(4000), entry.GetTimeUntilRelease()); | |
| 189 | |
| 190 // 8 errors (to check it doesn't pass maximum). | |
| 191 entry.InformOfRequest(false); | |
| 192 entry.InformOfRequest(false); | |
| 193 entry.InformOfRequest(false); | |
| 194 entry.InformOfRequest(false); | |
| 195 result = entry.GetReleaseTime(); | |
| 196 EXPECT_EQ(TimeDelta::FromMilliseconds(20000), entry.GetTimeUntilRelease()); | |
| 197 } | |
| 198 | |
| 199 TEST(BackoffEntryTest, ReleaseTimeCalculationWithJitter) { | |
| 200 for (int i = 0; i < 10; ++i) { | |
| 201 BackoffEntry::Policy jittery_policy = base_policy; | |
| 202 jittery_policy.jitter_factor = 0.2; | |
| 203 | |
| 204 TestBackoffEntry entry(&jittery_policy); | |
| 205 | |
| 206 entry.InformOfRequest(false); | |
| 207 entry.InformOfRequest(false); | |
| 208 entry.InformOfRequest(false); | |
| 209 TimeTicks result = entry.GetReleaseTime(); | |
| 210 EXPECT_LE( | |
| 211 entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(3200), result); | |
| 212 EXPECT_GE( | |
| 213 entry.ImplGetTimeNow() + TimeDelta::FromMilliseconds(4000), result); | |
| 214 } | |
| 215 } | |
| 216 | |
| 217 TEST(BackoffEntryTest, FailureThenSuccess) { | |
| 218 TestBackoffEntry entry(&base_policy); | |
| 219 | |
| 220 // Failure count 1, establishes horizon. | |
| 221 entry.InformOfRequest(false); | |
| 222 TimeTicks release_time = entry.GetReleaseTime(); | |
| 223 EXPECT_EQ(TimeTicks() + TimeDelta::FromMilliseconds(1000), release_time); | |
| 224 | |
| 225 // Success, failure count 0, should not advance past | |
| 226 // the horizon that was already set. | |
| 227 entry.set_now(release_time - TimeDelta::FromMilliseconds(200)); | |
| 228 entry.InformOfRequest(true); | |
| 229 EXPECT_EQ(release_time, entry.GetReleaseTime()); | |
| 230 | |
| 231 // Failure, failure count 1. | |
| 232 entry.InformOfRequest(false); | |
| 233 EXPECT_EQ(release_time + TimeDelta::FromMilliseconds(800), | |
| 234 entry.GetReleaseTime()); | |
| 235 } | |
| 236 | |
| 237 TEST(BackoffEntryTest, FailureThenSuccessAlwaysDelay) { | |
| 238 BackoffEntry::Policy always_delay_policy = base_policy; | |
| 239 always_delay_policy.always_use_initial_delay = true; | |
| 240 always_delay_policy.num_errors_to_ignore = 1; | |
| 241 | |
| 242 TestBackoffEntry entry(&always_delay_policy); | |
| 243 | |
| 244 // Failure count 1. | |
| 245 entry.InformOfRequest(false); | |
| 246 EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease()); | |
| 247 | |
| 248 // Failure count 2. | |
| 249 entry.InformOfRequest(false); | |
| 250 EXPECT_EQ(TimeDelta::FromMilliseconds(2000), entry.GetTimeUntilRelease()); | |
| 251 entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(2000)); | |
| 252 | |
| 253 // Success. We should go back to the original delay. | |
| 254 entry.InformOfRequest(true); | |
| 255 EXPECT_EQ(TimeDelta::FromMilliseconds(1000), entry.GetTimeUntilRelease()); | |
| 256 | |
| 257 // Failure count reaches 2 again. We should increase the delay once more. | |
| 258 entry.InformOfRequest(false); | |
| 259 EXPECT_EQ(TimeDelta::FromMilliseconds(2000), entry.GetTimeUntilRelease()); | |
| 260 entry.set_now(entry.GetReleaseTime() + TimeDelta::FromMilliseconds(2000)); | |
| 261 } | |
| 262 | |
| 263 TEST(BackoffEntryTest, RetainCustomHorizon) { | |
| 264 TestBackoffEntry custom(&base_policy); | |
| 265 TimeTicks custom_horizon = TimeTicks() + TimeDelta::FromDays(3); | |
| 266 custom.SetCustomReleaseTime(custom_horizon); | |
| 267 custom.InformOfRequest(false); | |
| 268 custom.InformOfRequest(true); | |
| 269 custom.set_now(TimeTicks() + TimeDelta::FromDays(2)); | |
| 270 custom.InformOfRequest(false); | |
| 271 custom.InformOfRequest(true); | |
| 272 EXPECT_EQ(custom_horizon, custom.GetReleaseTime()); | |
| 273 | |
| 274 // Now check that once we are at or past the custom horizon, | |
| 275 // we get normal behavior. | |
| 276 custom.set_now(TimeTicks() + TimeDelta::FromDays(3)); | |
| 277 custom.InformOfRequest(false); | |
| 278 EXPECT_EQ( | |
| 279 TimeTicks() + TimeDelta::FromDays(3) + TimeDelta::FromMilliseconds(1000), | |
| 280 custom.GetReleaseTime()); | |
| 281 } | |
| 282 | |
| 283 TEST(BackoffEntryTest, RetainCustomHorizonWhenInitialErrorsIgnored) { | |
| 284 // Regression test for a bug discovered during code review. | |
| 285 BackoffEntry::Policy lenient_policy = base_policy; | |
| 286 lenient_policy.num_errors_to_ignore = 1; | |
| 287 TestBackoffEntry custom(&lenient_policy); | |
| 288 TimeTicks custom_horizon = TimeTicks() + TimeDelta::FromDays(3); | |
| 289 custom.SetCustomReleaseTime(custom_horizon); | |
| 290 custom.InformOfRequest(false); // This must not reset the horizon. | |
| 291 EXPECT_EQ(custom_horizon, custom.GetReleaseTime()); | |
| 292 } | |
| 293 | |
| 294 TEST(BackoffEntryTest, OverflowProtection) { | |
| 295 BackoffEntry::Policy large_multiply_policy = base_policy; | |
| 296 large_multiply_policy.multiply_factor = 256; | |
| 297 TestBackoffEntry custom(&large_multiply_policy); | |
| 298 | |
| 299 // Trigger enough failures such that more than 11 bits of exponent are used | |
| 300 // to represent the exponential backoff intermediate values. Given a multiply | |
| 301 // factor of 256 (2^8), 129 iterations is enough: 2^(8*(129-1)) = 2^1024. | |
| 302 for (int i = 0; i < 129; ++i) { | |
| 303 custom.set_now(custom.ImplGetTimeNow() + custom.GetTimeUntilRelease()); | |
| 304 custom.InformOfRequest(false); | |
| 305 ASSERT_TRUE(custom.ShouldRejectRequest()); | |
| 306 } | |
| 307 | |
| 308 // Max delay should still be respected. | |
| 309 EXPECT_EQ(20000, custom.GetTimeUntilRelease().InMilliseconds()); | |
| 310 } | |
| 311 | |
| 312 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master