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 |