Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(762)

Side by Side Diff: net/nqe/observation_buffer_unittest.cc

Issue 2367143002: NQE: Cleanup observation buffer code (Closed)
Patch Set: ps Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « net/nqe/observation_buffer.h ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2016 The Chromium Authors. All rights reserved. 1 // Copyright 2016 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/nqe/network_quality_observation.h" 5 #include "net/nqe/observation_buffer.h"
6 6
7 #include <stddef.h> 7 #include <stddef.h>
8 8
9 #include <memory>
10 #include <utility>
9 #include <vector> 11 #include <vector>
10 12
11 #include "base/logging.h" 13 #include "base/logging.h"
12 #include "base/macros.h" 14 #include "base/macros.h"
15 #include "base/memory/ptr_util.h"
16 #include "base/test/simple_test_tick_clock.h"
13 #include "base/time/time.h" 17 #include "base/time/time.h"
18 #include "net/nqe/network_quality_observation.h"
14 #include "net/nqe/network_quality_observation_source.h" 19 #include "net/nqe/network_quality_observation_source.h"
15 #include "net/nqe/observation_buffer.h"
16 #include "testing/gtest/include/gtest/gtest.h" 20 #include "testing/gtest/include/gtest/gtest.h"
17 21
18 namespace net { 22 namespace net {
19 23
20 namespace nqe { 24 namespace nqe {
21 25
26 namespace internal {
27
22 namespace { 28 namespace {
23 29
30 // Verify that the buffer size is never exceeded.
31 TEST(NetworkQualityObservationBufferTest, BoundedBuffer) {
32 ObservationBuffer<int32_t> observation_buffer(1.0);
33 const base::TimeTicks now =
34 base::TimeTicks() + base::TimeDelta::FromSeconds(1);
35 for (int i = 1; i <= 1000; ++i) {
36 observation_buffer.AddObservation(
37 Observation<int32_t>(i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
38 // The number of entries should be at most the maximum buffer size.
39 EXPECT_GE(300u, observation_buffer.Size());
40 }
41 }
42
43 // Test disabled on OS_WIN to avoid linking errors when calling
44 // SetTickClockForTesting.
45 // TODO(tbansal): crbug.com/651963. Pass the clock through NQE's constructor.
46 #if !defined(OS_WIN)
47 // Verify that the percentiles are monotonically non-decreasing when a weight is
48 // applied.
49 TEST(NetworkQualityObservationBufferTest, GetPercentileWithWeights) {
50 std::unique_ptr<base::SimpleTestTickClock> tick_clock(
51 new base::SimpleTestTickClock());
52 base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
53
54 ObservationBuffer<int32_t> observation_buffer(0.98);
55 observation_buffer.SetTickClockForTesting(std::move(tick_clock));
56 const base::TimeTicks now = tick_clock_ptr->NowTicks();
57 for (int i = 1; i <= 100; ++i) {
58 tick_clock_ptr->Advance(base::TimeDelta::FromSeconds(1));
59 observation_buffer.AddObservation(Observation<int32_t>(
60 i, tick_clock_ptr->NowTicks(), NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
61 }
62 EXPECT_EQ(100U, observation_buffer.Size());
63
64 int32_t result_lowest = INT32_MAX;
65 int32_t result_highest = INT32_MIN;
66
67 for (int i = 1; i <= 100; ++i) {
68 // Verify that i'th percentile is more than i-1'th percentile.
69 int32_t result_i;
70 EXPECT_TRUE(observation_buffer.GetPercentile(
71 now, &result_i, i, std::vector<NetworkQualityObservationSource>()));
72 result_lowest = std::min(result_lowest, result_i);
73
74 result_highest = std::max(result_highest, result_i);
75
76 int32_t result_i_1;
77 EXPECT_TRUE(observation_buffer.GetPercentile(
78 now, &result_i_1, i - 1,
79 std::vector<NetworkQualityObservationSource>()));
80
81 EXPECT_LE(result_i_1, result_i);
82 }
83 EXPECT_LT(result_lowest, result_highest);
84 }
85 #endif
86
24 // Verifies that the percentiles are correctly computed. All observations have 87 // Verifies that the percentiles are correctly computed. All observations have
25 // the same timestamp. 88 // the same timestamp.
26 TEST(NetworkQualityObservationTest, PercentileSameTimestamps) { 89 TEST(NetworkQualityObservationBufferTest, PercentileSameTimestamps) {
27 internal::ObservationBuffer<int32_t> int_buffer(0.5); 90 ObservationBuffer<int32_t> int_buffer(0.5);
28 internal::ObservationBuffer<base::TimeDelta> time_delta_buffer(0.5); 91 ObservationBuffer<base::TimeDelta> time_delta_buffer(0.5);
29 ASSERT_EQ(0u, int_buffer.Size()); 92 ASSERT_EQ(0u, int_buffer.Size());
30 ASSERT_LT(0u, int_buffer.Capacity()); 93 ASSERT_LT(0u, int_buffer.Capacity());
31 ASSERT_EQ(0u, time_delta_buffer.Size()); 94 ASSERT_EQ(0u, time_delta_buffer.Size());
32 ASSERT_LT(0u, time_delta_buffer.Capacity()); 95 ASSERT_LT(0u, time_delta_buffer.Capacity());
33 96
34 const base::TimeTicks now = base::TimeTicks::Now(); 97 const base::TimeTicks now = base::TimeTicks::Now();
35 98
36 int32_t result; 99 int32_t result;
37 base::TimeDelta time_delta_result; 100 base::TimeDelta time_delta_result;
38 101
39 // Percentiles should be unavailable when no observations are available. 102 // Percentiles should be unavailable when no observations are available.
40 EXPECT_FALSE( 103 EXPECT_FALSE(
41 int_buffer.GetPercentile(base::TimeTicks(), &result, 50, 104 int_buffer.GetPercentile(base::TimeTicks(), &result, 50,
42 std::vector<NetworkQualityObservationSource>())); 105 std::vector<NetworkQualityObservationSource>()));
43 EXPECT_FALSE(time_delta_buffer.GetPercentile( 106 EXPECT_FALSE(time_delta_buffer.GetPercentile(
44 base::TimeTicks(), &time_delta_result, 50, 107 base::TimeTicks(), &time_delta_result, 50,
45 std::vector<NetworkQualityObservationSource>())); 108 std::vector<NetworkQualityObservationSource>()));
46 109
47 // Insert samples from {1,2,3,..., 100}. First insert odd samples, then even 110 // Insert samples from {1,2,3,..., 100}. First insert odd samples, then even
48 // samples. This helps in verifying that the order of samples does not matter. 111 // samples. This helps in verifying that the order of samples does not matter.
49 for (int i = 1; i <= 99; i += 2) { 112 for (int i = 1; i <= 99; i += 2) {
50 int_buffer.AddObservation(internal::Observation<int32_t>( 113 int_buffer.AddObservation(Observation<int32_t>(
51 i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 114 i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
52 time_delta_buffer.AddObservation(internal::Observation<base::TimeDelta>( 115 time_delta_buffer.AddObservation(Observation<base::TimeDelta>(
53 base::TimeDelta::FromMilliseconds(i), now, 116 base::TimeDelta::FromMilliseconds(i), now,
54 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 117 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
55 EXPECT_TRUE(int_buffer.GetPercentile( 118 EXPECT_TRUE(int_buffer.GetPercentile(
56 base::TimeTicks(), &result, 50, 119 base::TimeTicks(), &result, 50,
57 std::vector<NetworkQualityObservationSource>())); 120 std::vector<NetworkQualityObservationSource>()));
58 ASSERT_EQ(static_cast<size_t>(i / 2 + 1), int_buffer.Size()); 121 ASSERT_EQ(static_cast<size_t>(i / 2 + 1), int_buffer.Size());
59 EXPECT_TRUE(time_delta_buffer.GetPercentile( 122 EXPECT_TRUE(time_delta_buffer.GetPercentile(
60 base::TimeTicks(), &time_delta_result, 50, 123 base::TimeTicks(), &time_delta_result, 50,
61 std::vector<NetworkQualityObservationSource>())); 124 std::vector<NetworkQualityObservationSource>()));
62 ASSERT_EQ(static_cast<size_t>(i / 2 + 1), time_delta_buffer.Size()); 125 ASSERT_EQ(static_cast<size_t>(i / 2 + 1), time_delta_buffer.Size());
63 } 126 }
64 127
65 for (int i = 2; i <= 100; i += 2) { 128 for (int i = 2; i <= 100; i += 2) {
66 int_buffer.AddObservation(internal::Observation<int32_t>( 129 int_buffer.AddObservation(Observation<int32_t>(
67 i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 130 i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
68 time_delta_buffer.AddObservation(internal::Observation<base::TimeDelta>( 131 time_delta_buffer.AddObservation(Observation<base::TimeDelta>(
69 base::TimeDelta::FromMilliseconds(i), now, 132 base::TimeDelta::FromMilliseconds(i), now,
70 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 133 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
71 EXPECT_TRUE(int_buffer.GetPercentile( 134 EXPECT_TRUE(int_buffer.GetPercentile(
72 base::TimeTicks(), &result, 50, 135 base::TimeTicks(), &result, 50,
73 std::vector<NetworkQualityObservationSource>())); 136 std::vector<NetworkQualityObservationSource>()));
74 ASSERT_EQ(static_cast<size_t>(i / 2 + 50), int_buffer.Size()); 137 ASSERT_EQ(static_cast<size_t>(i / 2 + 50), int_buffer.Size());
75 EXPECT_TRUE(time_delta_buffer.GetPercentile( 138 EXPECT_TRUE(time_delta_buffer.GetPercentile(
76 base::TimeTicks(), &time_delta_result, 50, 139 base::TimeTicks(), &time_delta_result, 50,
77 std::vector<NetworkQualityObservationSource>())); 140 std::vector<NetworkQualityObservationSource>()));
78 ASSERT_EQ(static_cast<size_t>(i / 2 + 50), time_delta_buffer.Size()); 141 ASSERT_EQ(static_cast<size_t>(i / 2 + 50), time_delta_buffer.Size());
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
111 std::vector<NetworkQualityObservationSource>())); 174 std::vector<NetworkQualityObservationSource>()));
112 EXPECT_FALSE(time_delta_buffer.GetPercentile( 175 EXPECT_FALSE(time_delta_buffer.GetPercentile(
113 base::TimeTicks(), &time_delta_result, 50, 176 base::TimeTicks(), &time_delta_result, 50,
114 std::vector<NetworkQualityObservationSource>())); 177 std::vector<NetworkQualityObservationSource>()));
115 } 178 }
116 179
117 // Verifies that the percentiles are correctly computed. Observations have 180 // Verifies that the percentiles are correctly computed. Observations have
118 // different timestamps with half the observations being very old and the rest 181 // different timestamps with half the observations being very old and the rest
119 // of them being very recent. Percentiles should factor in recent observations 182 // of them being very recent. Percentiles should factor in recent observations
120 // much more heavily than older samples. 183 // much more heavily than older samples.
121 TEST(NetworkQualityObservationTest, PercentileDifferentTimestamps) { 184 TEST(NetworkQualityObservationBufferTest, PercentileDifferentTimestamps) {
122 internal::ObservationBuffer<int32_t> int_buffer(0.5); 185 ObservationBuffer<int32_t> int_buffer(0.5);
123 internal::ObservationBuffer<base::TimeDelta> time_delta_buffer(0.5); 186 ObservationBuffer<base::TimeDelta> time_delta_buffer(0.5);
124 const base::TimeTicks now = base::TimeTicks::Now(); 187 const base::TimeTicks now = base::TimeTicks::Now();
125 const base::TimeTicks very_old = now - base::TimeDelta::FromDays(365); 188 const base::TimeTicks very_old = now - base::TimeDelta::FromDays(365);
126 189
127 int32_t result; 190 int32_t result;
128 base::TimeDelta time_delta_result; 191 base::TimeDelta time_delta_result;
129 192
130 // Network quality should be unavailable when no observations are available. 193 // Network quality should be unavailable when no observations are available.
131 EXPECT_FALSE( 194 EXPECT_FALSE(
132 int_buffer.GetPercentile(base::TimeTicks(), &result, 50, 195 int_buffer.GetPercentile(base::TimeTicks(), &result, 50,
133 std::vector<NetworkQualityObservationSource>())); 196 std::vector<NetworkQualityObservationSource>()));
134 EXPECT_FALSE(time_delta_buffer.GetPercentile( 197 EXPECT_FALSE(time_delta_buffer.GetPercentile(
135 base::TimeTicks(), &time_delta_result, 50, 198 base::TimeTicks(), &time_delta_result, 50,
136 std::vector<NetworkQualityObservationSource>())); 199 std::vector<NetworkQualityObservationSource>()));
137 200
138 // First 50 samples have very old timestamp. 201 // First 50 samples have very old timestamp.
139 for (int i = 1; i <= 50; ++i) { 202 for (int i = 1; i <= 50; ++i) {
140 int_buffer.AddObservation(internal::Observation<int32_t>( 203 int_buffer.AddObservation(Observation<int32_t>(
141 i, very_old, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 204 i, very_old, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
142 time_delta_buffer.AddObservation(internal::Observation<base::TimeDelta>( 205 time_delta_buffer.AddObservation(Observation<base::TimeDelta>(
143 base::TimeDelta::FromMilliseconds(i), very_old, 206 base::TimeDelta::FromMilliseconds(i), very_old,
144 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 207 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
145 } 208 }
146 209
147 // Next 50 (i.e., from 51 to 100) have recent timestamp. 210 // Next 50 (i.e., from 51 to 100) have recent timestamp.
148 for (int i = 51; i <= 100; ++i) { 211 for (int i = 51; i <= 100; ++i) {
149 int_buffer.AddObservation(internal::Observation<int32_t>( 212 int_buffer.AddObservation(Observation<int32_t>(
150 i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 213 i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
151 time_delta_buffer.AddObservation(internal::Observation<base::TimeDelta>( 214 time_delta_buffer.AddObservation(Observation<base::TimeDelta>(
152 base::TimeDelta::FromMilliseconds(i), now, 215 base::TimeDelta::FromMilliseconds(i), now,
153 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 216 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
154 } 217 }
155 218
156 // Older samples have very little weight. So, all percentiles are >= 51 219 // Older samples have very little weight. So, all percentiles are >= 51
157 // (lowest value among recent observations). 220 // (lowest value among recent observations).
158 for (int i = 1; i < 100; ++i) { 221 for (int i = 1; i < 100; ++i) {
159 // Checks if the difference between the two integers is less than 1. This is 222 // Checks if the difference between the two integers is less than 1. This is
160 // required because computed percentiles may be slightly different from 223 // required because computed percentiles may be slightly different from
161 // what is expected due to floating point computation errors and integer 224 // what is expected due to floating point computation errors and integer
(...skipping 12 matching lines...) Expand all
174 EXPECT_FALSE(int_buffer.GetPercentile( 237 EXPECT_FALSE(int_buffer.GetPercentile(
175 now + base::TimeDelta::FromSeconds(1), &result, 50, 238 now + base::TimeDelta::FromSeconds(1), &result, 50,
176 std::vector<NetworkQualityObservationSource>())); 239 std::vector<NetworkQualityObservationSource>()));
177 EXPECT_FALSE(time_delta_buffer.GetPercentile( 240 EXPECT_FALSE(time_delta_buffer.GetPercentile(
178 now + base::TimeDelta::FromSeconds(1), &time_delta_result, 50, 241 now + base::TimeDelta::FromSeconds(1), &time_delta_result, 50,
179 std::vector<NetworkQualityObservationSource>())); 242 std::vector<NetworkQualityObservationSource>()));
180 } 243 }
181 244
182 // Verifies that the percentiles are correctly computed when some of the 245 // Verifies that the percentiles are correctly computed when some of the
183 // observation sources are disallowed. All observations have the same timestamp. 246 // observation sources are disallowed. All observations have the same timestamp.
184 TEST(NetworkQualityObservationTest, DisallowedObservationSources) { 247 TEST(NetworkQualityObservationBufferTest, DisallowedObservationSources) {
185 internal::ObservationBuffer<int32_t> int_buffer(0.5); 248 ObservationBuffer<int32_t> int_buffer(0.5);
186 internal::ObservationBuffer<base::TimeDelta> time_delta_buffer(0.5); 249 ObservationBuffer<base::TimeDelta> time_delta_buffer(0.5);
187 const base::TimeTicks now = base::TimeTicks::Now(); 250 const base::TimeTicks now = base::TimeTicks::Now();
188 251
189 int32_t result; 252 int32_t result;
190 base::TimeDelta time_delta_result; 253 base::TimeDelta time_delta_result;
191 254
192 // Network quality should be unavailable when no observations are available. 255 // Network quality should be unavailable when no observations are available.
193 EXPECT_FALSE( 256 EXPECT_FALSE(
194 int_buffer.GetPercentile(base::TimeTicks(), &result, 50, 257 int_buffer.GetPercentile(base::TimeTicks(), &result, 50,
195 std::vector<NetworkQualityObservationSource>())); 258 std::vector<NetworkQualityObservationSource>()));
196 EXPECT_FALSE(time_delta_buffer.GetPercentile( 259 EXPECT_FALSE(time_delta_buffer.GetPercentile(
197 base::TimeTicks(), &time_delta_result, 50, 260 base::TimeTicks(), &time_delta_result, 50,
198 std::vector<NetworkQualityObservationSource>())); 261 std::vector<NetworkQualityObservationSource>()));
199 262
200 // Insert samples from {1,2,3,..., 100}. First insert odd samples, then even 263 // Insert samples from {1,2,3,..., 100}. First insert odd samples, then even
201 // samples. This helps in verifying that the order of samples does not matter. 264 // samples. This helps in verifying that the order of samples does not matter.
202 for (int i = 1; i <= 99; i += 2) { 265 for (int i = 1; i <= 99; i += 2) {
203 int_buffer.AddObservation(internal::Observation<int32_t>( 266 int_buffer.AddObservation(Observation<int32_t>(
204 i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 267 i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
205 time_delta_buffer.AddObservation(internal::Observation<base::TimeDelta>( 268 time_delta_buffer.AddObservation(Observation<base::TimeDelta>(
206 base::TimeDelta::FromMilliseconds(i), now, 269 base::TimeDelta::FromMilliseconds(i), now,
207 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 270 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
208 } 271 }
209 272
210 // Add samples for TCP and QUIC observations which should not be taken into 273 // Add samples for TCP and QUIC observations which should not be taken into
211 // account when computing the percentile. 274 // account when computing the percentile.
212 for (int i = 1; i <= 99; i += 2) { 275 for (int i = 1; i <= 99; i += 2) {
213 int_buffer.AddObservation(internal::Observation<int32_t>( 276 int_buffer.AddObservation(Observation<int32_t>(
214 10000, now, NETWORK_QUALITY_OBSERVATION_SOURCE_TCP)); 277 10000, now, NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
215 int_buffer.AddObservation(internal::Observation<int32_t>( 278 int_buffer.AddObservation(Observation<int32_t>(
216 10000, now, NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC)); 279 10000, now, NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC));
217 time_delta_buffer.AddObservation(internal::Observation<base::TimeDelta>( 280 time_delta_buffer.AddObservation(Observation<base::TimeDelta>(
218 base::TimeDelta::FromMilliseconds(10000), now, 281 base::TimeDelta::FromMilliseconds(10000), now,
219 NETWORK_QUALITY_OBSERVATION_SOURCE_TCP)); 282 NETWORK_QUALITY_OBSERVATION_SOURCE_TCP));
220 time_delta_buffer.AddObservation(internal::Observation<base::TimeDelta>( 283 time_delta_buffer.AddObservation(Observation<base::TimeDelta>(
221 base::TimeDelta::FromMilliseconds(10000), now, 284 base::TimeDelta::FromMilliseconds(10000), now,
222 NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC)); 285 NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC));
223 } 286 }
224 287
225 for (int i = 2; i <= 100; i += 2) { 288 for (int i = 2; i <= 100; i += 2) {
226 int_buffer.AddObservation(internal::Observation<int32_t>( 289 int_buffer.AddObservation(Observation<int32_t>(
227 i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 290 i, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
228 time_delta_buffer.AddObservation(internal::Observation<base::TimeDelta>( 291 time_delta_buffer.AddObservation(Observation<base::TimeDelta>(
229 base::TimeDelta::FromMilliseconds(i), now, 292 base::TimeDelta::FromMilliseconds(i), now,
230 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 293 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
231 } 294 }
232 295
233 std::vector<NetworkQualityObservationSource> disallowed_observation_sources; 296 std::vector<NetworkQualityObservationSource> disallowed_observation_sources;
234 disallowed_observation_sources.push_back( 297 disallowed_observation_sources.push_back(
235 NETWORK_QUALITY_OBSERVATION_SOURCE_TCP); 298 NETWORK_QUALITY_OBSERVATION_SOURCE_TCP);
236 disallowed_observation_sources.push_back( 299 disallowed_observation_sources.push_back(
237 NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC); 300 NETWORK_QUALITY_OBSERVATION_SOURCE_QUIC);
238 301
(...skipping 23 matching lines...) Expand all
262 EXPECT_TRUE(int_buffer.GetPercentile(base::TimeTicks(), &result, i, 325 EXPECT_TRUE(int_buffer.GetPercentile(base::TimeTicks(), &result, i,
263 disallowed_observation_sources)); 326 disallowed_observation_sources));
264 EXPECT_NEAR(result, 10000, 1); 327 EXPECT_NEAR(result, 10000, 1);
265 EXPECT_TRUE( 328 EXPECT_TRUE(
266 time_delta_buffer.GetPercentile(base::TimeTicks(), &time_delta_result, 329 time_delta_buffer.GetPercentile(base::TimeTicks(), &time_delta_result,
267 i, disallowed_observation_sources)); 330 i, disallowed_observation_sources));
268 EXPECT_NEAR(time_delta_result.InMilliseconds(), 10000, 1); 331 EXPECT_NEAR(time_delta_result.InMilliseconds(), 10000, 1);
269 } 332 }
270 } 333 }
271 334
272 TEST(NetworkQualityObservationTest, TestGetMedianRTTSince) { 335 TEST(NetworkQualityObservationBufferTest, TestGetMedianRTTSince) {
273 internal::ObservationBuffer<int32_t> int_buffer(0.5); 336 ObservationBuffer<int32_t> int_buffer(0.5);
274 internal::ObservationBuffer<base::TimeDelta> time_delta_buffer(0.5); 337 ObservationBuffer<base::TimeDelta> time_delta_buffer(0.5);
275 base::TimeTicks now = base::TimeTicks::Now(); 338 base::TimeTicks now = base::TimeTicks::Now();
276 base::TimeTicks old = now - base::TimeDelta::FromMilliseconds(1); 339 base::TimeTicks old = now - base::TimeDelta::FromMilliseconds(1);
277 ASSERT_NE(old, now); 340 ASSERT_NE(old, now);
278 341
279 // First sample has very old timestamp. 342 // First sample has very old timestamp.
280 int_buffer.AddObservation(internal::Observation<int32_t>( 343 int_buffer.AddObservation(Observation<int32_t>(
281 1, old, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 344 1, old, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
282 time_delta_buffer.AddObservation(internal::Observation<base::TimeDelta>( 345 time_delta_buffer.AddObservation(Observation<base::TimeDelta>(
283 base::TimeDelta::FromMilliseconds(1), old, 346 base::TimeDelta::FromMilliseconds(1), old,
284 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 347 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
285 348
286 int_buffer.AddObservation(internal::Observation<int32_t>( 349 int_buffer.AddObservation(Observation<int32_t>(
287 100, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 350 100, now, NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
288 time_delta_buffer.AddObservation(internal::Observation<base::TimeDelta>( 351 time_delta_buffer.AddObservation(Observation<base::TimeDelta>(
289 base::TimeDelta::FromMilliseconds(100), now, 352 base::TimeDelta::FromMilliseconds(100), now,
290 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST)); 353 NETWORK_QUALITY_OBSERVATION_SOURCE_URL_REQUEST));
291 354
292 const struct { 355 const struct {
293 base::TimeTicks start_timestamp; 356 base::TimeTicks start_timestamp;
294 bool expect_network_quality_available; 357 bool expect_network_quality_available;
295 base::TimeDelta expected_url_request_rtt; 358 base::TimeDelta expected_url_request_rtt;
296 int32_t expected_downstream_throughput; 359 int32_t expected_downstream_throughput;
297 } tests[] = { 360 } tests[] = {
298 {now + base::TimeDelta::FromSeconds(10), false, 361 {now + base::TimeDelta::FromSeconds(10), false,
(...skipping 21 matching lines...) Expand all
320 if (test.expect_network_quality_available) { 383 if (test.expect_network_quality_available) {
321 EXPECT_EQ(test.expected_url_request_rtt, url_request_rtt); 384 EXPECT_EQ(test.expected_url_request_rtt, url_request_rtt);
322 EXPECT_EQ(test.expected_downstream_throughput, 385 EXPECT_EQ(test.expected_downstream_throughput,
323 downstream_throughput_kbps); 386 downstream_throughput_kbps);
324 } 387 }
325 } 388 }
326 } 389 }
327 390
328 } // namespace 391 } // namespace
329 392
393 } // namespace internal
394
330 } // namespace nqe 395 } // namespace nqe
331 396
332 } // namespace net 397 } // namespace net
OLDNEW
« no previous file with comments | « net/nqe/observation_buffer.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698