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.Add(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.Add(srtt); 43 estimate_time = estimate_time.Add(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.Add(srtt.Multiply(3)); 64 const int64 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.Add(srtt.Multiply(3)); 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.Add(srtt.Multiply(3)); 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.Add(srtt.Multiply(3)); 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 132
