| OLD | NEW |
| (Empty) |
| 1 // Copyright 2014 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/quic/quic_sustained_bandwidth_recorder.h" | |
| 6 | |
| 7 #include "net/quic/quic_bandwidth.h" | |
| 8 #include "net/quic/quic_time.h" | |
| 9 #include "testing/gtest/include/gtest/gtest.h" | |
| 10 | |
| 11 namespace net { | |
| 12 namespace test { | |
| 13 namespace { | |
| 14 | |
| 15 TEST(QuicSustainedBandwidthRecorderTest, BandwidthEstimates) { | |
| 16 QuicSustainedBandwidthRecorder recorder; | |
| 17 EXPECT_FALSE(recorder.HasEstimate()); | |
| 18 | |
| 19 QuicTime estimate_time = QuicTime::Zero(); | |
| 20 QuicWallTime wall_time = QuicWallTime::Zero(); | |
| 21 QuicTime::Delta srtt = QuicTime::Delta::FromMilliseconds(150); | |
| 22 const int kBandwidthBitsPerSecond = 12345678; | |
| 23 QuicBandwidth bandwidth = | |
| 24 QuicBandwidth::FromBitsPerSecond(kBandwidthBitsPerSecond); | |
| 25 | |
| 26 bool in_recovery = false; | |
| 27 bool in_slow_start = false; | |
| 28 | |
| 29 // This triggers recording, but should not yield a valid estimate yet. | |
| 30 recorder.RecordEstimate(in_recovery, in_slow_start, bandwidth, estimate_time, | |
| 31 wall_time, srtt); | |
| 32 EXPECT_FALSE(recorder.HasEstimate()); | |
| 33 | |
| 34 // Send a second reading, again this should not result in a valid estimate, | |
| 35 // as not enough time has passed. | |
| 36 estimate_time = estimate_time + srtt; | |
| 37 recorder.RecordEstimate(in_recovery, in_slow_start, bandwidth, estimate_time, | |
| 38 wall_time, srtt); | |
| 39 EXPECT_FALSE(recorder.HasEstimate()); | |
| 40 | |
| 41 // Now 3 * kSRTT has elapsed since first recording, expect a valid estimate. | |
| 42 estimate_time = estimate_time + srtt; | |
| 43 estimate_time = estimate_time + srtt; | |
| 44 recorder.RecordEstimate(in_recovery, in_slow_start, bandwidth, estimate_time, | |
| 45 wall_time, srtt); | |
| 46 EXPECT_TRUE(recorder.HasEstimate()); | |
| 47 EXPECT_EQ(recorder.BandwidthEstimate(), bandwidth); | |
| 48 EXPECT_EQ(recorder.BandwidthEstimate(), recorder.MaxBandwidthEstimate()); | |
| 49 | |
| 50 // Resetting, and sending a different estimate will only change output after | |
| 51 // a further 3 * kSRTT has passed. | |
| 52 QuicBandwidth second_bandwidth = | |
| 53 QuicBandwidth::FromBitsPerSecond(2 * kBandwidthBitsPerSecond); | |
| 54 // Reset the recorder by passing in a measurement while in recovery. | |
| 55 in_recovery = true; | |
| 56 recorder.RecordEstimate(in_recovery, in_slow_start, bandwidth, estimate_time, | |
| 57 wall_time, srtt); | |
| 58 in_recovery = false; | |
| 59 recorder.RecordEstimate(in_recovery, in_slow_start, bandwidth, estimate_time, | |
| 60 wall_time, srtt); | |
| 61 EXPECT_EQ(recorder.BandwidthEstimate(), bandwidth); | |
| 62 | |
| 63 estimate_time = estimate_time + 3 * srtt; | |
| 64 const int64_t kSeconds = 556677; | |
| 65 QuicWallTime second_bandwidth_wall_time = | |
| 66 QuicWallTime::FromUNIXSeconds(kSeconds); | |
| 67 recorder.RecordEstimate(in_recovery, in_slow_start, second_bandwidth, | |
| 68 estimate_time, second_bandwidth_wall_time, srtt); | |
| 69 EXPECT_EQ(recorder.BandwidthEstimate(), second_bandwidth); | |
| 70 EXPECT_EQ(recorder.BandwidthEstimate(), recorder.MaxBandwidthEstimate()); | |
| 71 EXPECT_EQ(recorder.MaxBandwidthTimestamp(), kSeconds); | |
| 72 | |
| 73 // Reset again, this time recording a lower bandwidth than before. | |
| 74 QuicBandwidth third_bandwidth = | |
| 75 QuicBandwidth::FromBitsPerSecond(0.5 * kBandwidthBitsPerSecond); | |
| 76 // Reset the recorder by passing in an unreliable measurement. | |
| 77 recorder.RecordEstimate(in_recovery, in_slow_start, third_bandwidth, | |
| 78 estimate_time, wall_time, srtt); | |
| 79 recorder.RecordEstimate(in_recovery, in_slow_start, third_bandwidth, | |
| 80 estimate_time, wall_time, srtt); | |
| 81 EXPECT_EQ(recorder.BandwidthEstimate(), third_bandwidth); | |
| 82 | |
| 83 estimate_time = estimate_time + 3 * srtt; | |
| 84 recorder.RecordEstimate(in_recovery, in_slow_start, third_bandwidth, | |
| 85 estimate_time, wall_time, srtt); | |
| 86 EXPECT_EQ(recorder.BandwidthEstimate(), third_bandwidth); | |
| 87 | |
| 88 // Max bandwidth should not have changed. | |
| 89 EXPECT_LT(third_bandwidth, second_bandwidth); | |
| 90 EXPECT_EQ(recorder.MaxBandwidthEstimate(), second_bandwidth); | |
| 91 EXPECT_EQ(recorder.MaxBandwidthTimestamp(), kSeconds); | |
| 92 } | |
| 93 | |
| 94 TEST(QuicSustainedBandwidthRecorderTest, SlowStart) { | |
| 95 // Verify that slow start status is correctly recorded. | |
| 96 QuicSustainedBandwidthRecorder recorder; | |
| 97 EXPECT_FALSE(recorder.HasEstimate()); | |
| 98 | |
| 99 QuicTime estimate_time = QuicTime::Zero(); | |
| 100 QuicWallTime wall_time = QuicWallTime::Zero(); | |
| 101 QuicTime::Delta srtt = QuicTime::Delta::FromMilliseconds(150); | |
| 102 const int kBandwidthBitsPerSecond = 12345678; | |
| 103 QuicBandwidth bandwidth = | |
| 104 QuicBandwidth::FromBitsPerSecond(kBandwidthBitsPerSecond); | |
| 105 | |
| 106 bool in_recovery = false; | |
| 107 bool in_slow_start = true; | |
| 108 | |
| 109 // This triggers recording, but should not yield a valid estimate yet. | |
| 110 recorder.RecordEstimate(in_recovery, in_slow_start, bandwidth, estimate_time, | |
| 111 wall_time, srtt); | |
| 112 | |
| 113 // Now 3 * kSRTT has elapsed since first recording, expect a valid estimate. | |
| 114 estimate_time = estimate_time + 3 * srtt; | |
| 115 recorder.RecordEstimate(in_recovery, in_slow_start, bandwidth, estimate_time, | |
| 116 wall_time, srtt); | |
| 117 EXPECT_TRUE(recorder.HasEstimate()); | |
| 118 EXPECT_TRUE(recorder.EstimateRecordedDuringSlowStart()); | |
| 119 | |
| 120 // Now send another estimate, this time not in slow start. | |
| 121 estimate_time = estimate_time + 3 * srtt; | |
| 122 in_slow_start = false; | |
| 123 recorder.RecordEstimate(in_recovery, in_slow_start, bandwidth, estimate_time, | |
| 124 wall_time, srtt); | |
| 125 EXPECT_TRUE(recorder.HasEstimate()); | |
| 126 EXPECT_FALSE(recorder.EstimateRecordedDuringSlowStart()); | |
| 127 } | |
| 128 | |
| 129 } // namespace | |
| 130 } // namespace test | |
| 131 } // namespace net | |
| OLD | NEW |