| 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 <vector> | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/json/json_reader.h" | |
| 9 #include "base/memory/scoped_ptr.h" | |
| 10 #include "base/metrics/histogram_macros.h" | |
| 11 #include "base/metrics/sparse_histogram.h" | |
| 12 #include "base/metrics/statistics_recorder.h" | |
| 13 #include "base/values.h" | |
| 14 #include "testing/gtest/include/gtest/gtest.h" | |
| 15 | |
| 16 namespace base { | |
| 17 | |
| 18 class StatisticsRecorderTest : public testing::Test { | |
| 19 protected: | |
| 20 void SetUp() override { | |
| 21 // Each test will have a clean state (no Histogram / BucketRanges | |
| 22 // registered). | |
| 23 InitializeStatisticsRecorder(); | |
| 24 } | |
| 25 | |
| 26 void TearDown() override { UninitializeStatisticsRecorder(); } | |
| 27 | |
| 28 void InitializeStatisticsRecorder() { | |
| 29 statistics_recorder_ = new StatisticsRecorder(); | |
| 30 } | |
| 31 | |
| 32 void UninitializeStatisticsRecorder() { | |
| 33 delete statistics_recorder_; | |
| 34 statistics_recorder_ = NULL; | |
| 35 } | |
| 36 | |
| 37 Histogram* CreateHistogram(const std::string& name, | |
| 38 HistogramBase::Sample min, | |
| 39 HistogramBase::Sample max, | |
| 40 size_t bucket_count) { | |
| 41 BucketRanges* ranges = new BucketRanges(bucket_count + 1); | |
| 42 Histogram::InitializeBucketRanges(min, max, ranges); | |
| 43 const BucketRanges* registered_ranges = | |
| 44 StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges); | |
| 45 return new Histogram(name, min, max, registered_ranges); | |
| 46 } | |
| 47 | |
| 48 void DeleteHistogram(HistogramBase* histogram) { | |
| 49 delete histogram; | |
| 50 } | |
| 51 | |
| 52 StatisticsRecorder* statistics_recorder_; | |
| 53 }; | |
| 54 | |
| 55 TEST_F(StatisticsRecorderTest, NotInitialized) { | |
| 56 UninitializeStatisticsRecorder(); | |
| 57 | |
| 58 ASSERT_FALSE(StatisticsRecorder::IsActive()); | |
| 59 | |
| 60 StatisticsRecorder::Histograms registered_histograms; | |
| 61 std::vector<const BucketRanges*> registered_ranges; | |
| 62 | |
| 63 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 64 EXPECT_EQ(0u, registered_histograms.size()); | |
| 65 | |
| 66 Histogram* histogram = CreateHistogram("TestHistogram", 1, 1000, 10); | |
| 67 | |
| 68 // When StatisticsRecorder is not initialized, register is a noop. | |
| 69 EXPECT_EQ(histogram, | |
| 70 StatisticsRecorder::RegisterOrDeleteDuplicate(histogram)); | |
| 71 // Manually delete histogram that was not registered. | |
| 72 DeleteHistogram(histogram); | |
| 73 | |
| 74 // RegisterOrDeleteDuplicateRanges is a no-op. | |
| 75 BucketRanges* ranges = new BucketRanges(3);; | |
| 76 ranges->ResetChecksum(); | |
| 77 EXPECT_EQ(ranges, | |
| 78 StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges)); | |
| 79 StatisticsRecorder::GetBucketRanges(®istered_ranges); | |
| 80 EXPECT_EQ(0u, registered_ranges.size()); | |
| 81 } | |
| 82 | |
| 83 TEST_F(StatisticsRecorderTest, RegisterBucketRanges) { | |
| 84 std::vector<const BucketRanges*> registered_ranges; | |
| 85 | |
| 86 BucketRanges* ranges1 = new BucketRanges(3);; | |
| 87 ranges1->ResetChecksum(); | |
| 88 BucketRanges* ranges2 = new BucketRanges(4);; | |
| 89 ranges2->ResetChecksum(); | |
| 90 | |
| 91 // Register new ranges. | |
| 92 EXPECT_EQ(ranges1, | |
| 93 StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges1)); | |
| 94 EXPECT_EQ(ranges2, | |
| 95 StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges2)); | |
| 96 StatisticsRecorder::GetBucketRanges(®istered_ranges); | |
| 97 ASSERT_EQ(2u, registered_ranges.size()); | |
| 98 | |
| 99 // Register some ranges again. | |
| 100 EXPECT_EQ(ranges1, | |
| 101 StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges1)); | |
| 102 registered_ranges.clear(); | |
| 103 StatisticsRecorder::GetBucketRanges(®istered_ranges); | |
| 104 ASSERT_EQ(2u, registered_ranges.size()); | |
| 105 // Make sure the ranges is still the one we know. | |
| 106 ASSERT_EQ(3u, ranges1->size()); | |
| 107 EXPECT_EQ(0, ranges1->range(0)); | |
| 108 EXPECT_EQ(0, ranges1->range(1)); | |
| 109 EXPECT_EQ(0, ranges1->range(2)); | |
| 110 | |
| 111 // Register ranges with same values. | |
| 112 BucketRanges* ranges3 = new BucketRanges(3);; | |
| 113 ranges3->ResetChecksum(); | |
| 114 EXPECT_EQ(ranges1, // returning ranges1 | |
| 115 StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges3)); | |
| 116 registered_ranges.clear(); | |
| 117 StatisticsRecorder::GetBucketRanges(®istered_ranges); | |
| 118 ASSERT_EQ(2u, registered_ranges.size()); | |
| 119 } | |
| 120 | |
| 121 TEST_F(StatisticsRecorderTest, RegisterHistogram) { | |
| 122 // Create a Histogram that was not registered. | |
| 123 Histogram* histogram = CreateHistogram("TestHistogram", 1, 1000, 10); | |
| 124 | |
| 125 StatisticsRecorder::Histograms registered_histograms; | |
| 126 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 127 EXPECT_EQ(0u, registered_histograms.size()); | |
| 128 | |
| 129 // Register the Histogram. | |
| 130 EXPECT_EQ(histogram, | |
| 131 StatisticsRecorder::RegisterOrDeleteDuplicate(histogram)); | |
| 132 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 133 EXPECT_EQ(1u, registered_histograms.size()); | |
| 134 | |
| 135 // Register the same Histogram again. | |
| 136 EXPECT_EQ(histogram, | |
| 137 StatisticsRecorder::RegisterOrDeleteDuplicate(histogram)); | |
| 138 registered_histograms.clear(); | |
| 139 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 140 EXPECT_EQ(1u, registered_histograms.size()); | |
| 141 } | |
| 142 | |
| 143 TEST_F(StatisticsRecorderTest, FindHistogram) { | |
| 144 HistogramBase* histogram1 = Histogram::FactoryGet( | |
| 145 "TestHistogram1", 1, 1000, 10, HistogramBase::kNoFlags); | |
| 146 HistogramBase* histogram2 = Histogram::FactoryGet( | |
| 147 "TestHistogram2", 1, 1000, 10, HistogramBase::kNoFlags); | |
| 148 | |
| 149 EXPECT_EQ(histogram1, StatisticsRecorder::FindHistogram("TestHistogram1")); | |
| 150 EXPECT_EQ(histogram2, StatisticsRecorder::FindHistogram("TestHistogram2")); | |
| 151 EXPECT_TRUE(StatisticsRecorder::FindHistogram("TestHistogram") == NULL); | |
| 152 } | |
| 153 | |
| 154 TEST_F(StatisticsRecorderTest, GetSnapshot) { | |
| 155 Histogram::FactoryGet("TestHistogram1", 1, 1000, 10, Histogram::kNoFlags); | |
| 156 Histogram::FactoryGet("TestHistogram2", 1, 1000, 10, Histogram::kNoFlags); | |
| 157 Histogram::FactoryGet("TestHistogram3", 1, 1000, 10, Histogram::kNoFlags); | |
| 158 | |
| 159 StatisticsRecorder::Histograms snapshot; | |
| 160 StatisticsRecorder::GetSnapshot("Test", &snapshot); | |
| 161 EXPECT_EQ(3u, snapshot.size()); | |
| 162 | |
| 163 snapshot.clear(); | |
| 164 StatisticsRecorder::GetSnapshot("1", &snapshot); | |
| 165 EXPECT_EQ(1u, snapshot.size()); | |
| 166 | |
| 167 snapshot.clear(); | |
| 168 StatisticsRecorder::GetSnapshot("hello", &snapshot); | |
| 169 EXPECT_EQ(0u, snapshot.size()); | |
| 170 } | |
| 171 | |
| 172 TEST_F(StatisticsRecorderTest, RegisterHistogramWithFactoryGet) { | |
| 173 StatisticsRecorder::Histograms registered_histograms; | |
| 174 | |
| 175 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 176 ASSERT_EQ(0u, registered_histograms.size()); | |
| 177 | |
| 178 // Create a histogram. | |
| 179 HistogramBase* histogram = Histogram::FactoryGet( | |
| 180 "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags); | |
| 181 registered_histograms.clear(); | |
| 182 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 183 EXPECT_EQ(1u, registered_histograms.size()); | |
| 184 | |
| 185 // Get an existing histogram. | |
| 186 HistogramBase* histogram2 = Histogram::FactoryGet( | |
| 187 "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags); | |
| 188 registered_histograms.clear(); | |
| 189 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 190 EXPECT_EQ(1u, registered_histograms.size()); | |
| 191 EXPECT_EQ(histogram, histogram2); | |
| 192 | |
| 193 // Create a LinearHistogram. | |
| 194 histogram = LinearHistogram::FactoryGet( | |
| 195 "TestLinearHistogram", 1, 1000, 10, HistogramBase::kNoFlags); | |
| 196 registered_histograms.clear(); | |
| 197 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 198 EXPECT_EQ(2u, registered_histograms.size()); | |
| 199 | |
| 200 // Create a BooleanHistogram. | |
| 201 histogram = BooleanHistogram::FactoryGet( | |
| 202 "TestBooleanHistogram", HistogramBase::kNoFlags); | |
| 203 registered_histograms.clear(); | |
| 204 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 205 EXPECT_EQ(3u, registered_histograms.size()); | |
| 206 | |
| 207 // Create a CustomHistogram. | |
| 208 std::vector<int> custom_ranges; | |
| 209 custom_ranges.push_back(1); | |
| 210 custom_ranges.push_back(5); | |
| 211 histogram = CustomHistogram::FactoryGet( | |
| 212 "TestCustomHistogram", custom_ranges, HistogramBase::kNoFlags); | |
| 213 registered_histograms.clear(); | |
| 214 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 215 EXPECT_EQ(4u, registered_histograms.size()); | |
| 216 } | |
| 217 | |
| 218 TEST_F(StatisticsRecorderTest, RegisterHistogramWithMacros) { | |
| 219 StatisticsRecorder::Histograms registered_histograms; | |
| 220 | |
| 221 HistogramBase* histogram = Histogram::FactoryGet( | |
| 222 "TestHistogramCounts", 1, 1000000, 50, HistogramBase::kNoFlags); | |
| 223 | |
| 224 // The histogram we got from macro is the same as from FactoryGet. | |
| 225 LOCAL_HISTOGRAM_COUNTS("TestHistogramCounts", 30); | |
| 226 registered_histograms.clear(); | |
| 227 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 228 ASSERT_EQ(1u, registered_histograms.size()); | |
| 229 EXPECT_EQ(histogram, registered_histograms[0]); | |
| 230 | |
| 231 LOCAL_HISTOGRAM_TIMES("TestHistogramTimes", TimeDelta::FromDays(1)); | |
| 232 LOCAL_HISTOGRAM_ENUMERATION("TestHistogramEnumeration", 20, 200); | |
| 233 | |
| 234 registered_histograms.clear(); | |
| 235 StatisticsRecorder::GetHistograms(®istered_histograms); | |
| 236 EXPECT_EQ(3u, registered_histograms.size()); | |
| 237 } | |
| 238 | |
| 239 TEST_F(StatisticsRecorderTest, BucketRangesSharing) { | |
| 240 std::vector<const BucketRanges*> ranges; | |
| 241 StatisticsRecorder::GetBucketRanges(&ranges); | |
| 242 EXPECT_EQ(0u, ranges.size()); | |
| 243 | |
| 244 Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags); | |
| 245 Histogram::FactoryGet("Histogram2", 1, 64, 8, HistogramBase::kNoFlags); | |
| 246 | |
| 247 StatisticsRecorder::GetBucketRanges(&ranges); | |
| 248 EXPECT_EQ(1u, ranges.size()); | |
| 249 | |
| 250 Histogram::FactoryGet("Histogram3", 1, 64, 16, HistogramBase::kNoFlags); | |
| 251 | |
| 252 ranges.clear(); | |
| 253 StatisticsRecorder::GetBucketRanges(&ranges); | |
| 254 EXPECT_EQ(2u, ranges.size()); | |
| 255 } | |
| 256 | |
| 257 TEST_F(StatisticsRecorderTest, ToJSON) { | |
| 258 LOCAL_HISTOGRAM_COUNTS("TestHistogram1", 30); | |
| 259 LOCAL_HISTOGRAM_COUNTS("TestHistogram1", 40); | |
| 260 LOCAL_HISTOGRAM_COUNTS("TestHistogram2", 30); | |
| 261 LOCAL_HISTOGRAM_COUNTS("TestHistogram2", 40); | |
| 262 | |
| 263 std::string json(StatisticsRecorder::ToJSON(std::string())); | |
| 264 | |
| 265 // Check for valid JSON. | |
| 266 scoped_ptr<Value> root; | |
| 267 root.reset(JSONReader::DeprecatedRead(json)); | |
| 268 ASSERT_TRUE(root.get()); | |
| 269 | |
| 270 DictionaryValue* root_dict = NULL; | |
| 271 ASSERT_TRUE(root->GetAsDictionary(&root_dict)); | |
| 272 | |
| 273 // No query should be set. | |
| 274 ASSERT_FALSE(root_dict->HasKey("query")); | |
| 275 | |
| 276 ListValue* histogram_list = NULL; | |
| 277 ASSERT_TRUE(root_dict->GetList("histograms", &histogram_list)); | |
| 278 ASSERT_EQ(2u, histogram_list->GetSize()); | |
| 279 | |
| 280 // Examine the first histogram. | |
| 281 DictionaryValue* histogram_dict = NULL; | |
| 282 ASSERT_TRUE(histogram_list->GetDictionary(0, &histogram_dict)); | |
| 283 | |
| 284 int sample_count; | |
| 285 ASSERT_TRUE(histogram_dict->GetInteger("count", &sample_count)); | |
| 286 EXPECT_EQ(2, sample_count); | |
| 287 | |
| 288 // Test the query filter. | |
| 289 std::string query("TestHistogram2"); | |
| 290 json = StatisticsRecorder::ToJSON(query); | |
| 291 | |
| 292 root.reset(JSONReader::DeprecatedRead(json)); | |
| 293 ASSERT_TRUE(root.get()); | |
| 294 ASSERT_TRUE(root->GetAsDictionary(&root_dict)); | |
| 295 | |
| 296 std::string query_value; | |
| 297 ASSERT_TRUE(root_dict->GetString("query", &query_value)); | |
| 298 EXPECT_EQ(query, query_value); | |
| 299 | |
| 300 ASSERT_TRUE(root_dict->GetList("histograms", &histogram_list)); | |
| 301 ASSERT_EQ(1u, histogram_list->GetSize()); | |
| 302 | |
| 303 ASSERT_TRUE(histogram_list->GetDictionary(0, &histogram_dict)); | |
| 304 | |
| 305 std::string histogram_name; | |
| 306 ASSERT_TRUE(histogram_dict->GetString("name", &histogram_name)); | |
| 307 EXPECT_EQ("TestHistogram2", histogram_name); | |
| 308 | |
| 309 json.clear(); | |
| 310 UninitializeStatisticsRecorder(); | |
| 311 | |
| 312 // No data should be returned. | |
| 313 json = StatisticsRecorder::ToJSON(query); | |
| 314 EXPECT_TRUE(json.empty()); | |
| 315 } | |
| 316 | |
| 317 namespace { | |
| 318 | |
| 319 // CallbackCheckWrapper is simply a convenient way to check and store that | |
| 320 // a callback was actually run. | |
| 321 struct CallbackCheckWrapper { | |
| 322 CallbackCheckWrapper() : called(false), last_histogram_value(0) {} | |
| 323 | |
| 324 void OnHistogramChanged(base::HistogramBase::Sample histogram_value) { | |
| 325 called = true; | |
| 326 last_histogram_value = histogram_value; | |
| 327 } | |
| 328 | |
| 329 bool called; | |
| 330 base::HistogramBase::Sample last_histogram_value; | |
| 331 }; | |
| 332 | |
| 333 } // namespace | |
| 334 | |
| 335 // Check that you can't overwrite the callback with another. | |
| 336 TEST_F(StatisticsRecorderTest, SetCallbackFailsWithoutHistogramTest) { | |
| 337 CallbackCheckWrapper callback_wrapper; | |
| 338 | |
| 339 bool result = base::StatisticsRecorder::SetCallback( | |
| 340 "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged, | |
| 341 base::Unretained(&callback_wrapper))); | |
| 342 EXPECT_TRUE(result); | |
| 343 | |
| 344 result = base::StatisticsRecorder::SetCallback( | |
| 345 "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged, | |
| 346 base::Unretained(&callback_wrapper))); | |
| 347 EXPECT_FALSE(result); | |
| 348 } | |
| 349 | |
| 350 // Check that you can't overwrite the callback with another. | |
| 351 TEST_F(StatisticsRecorderTest, SetCallbackFailsWithHistogramTest) { | |
| 352 HistogramBase* histogram = Histogram::FactoryGet("TestHistogram", 1, 1000, 10, | |
| 353 HistogramBase::kNoFlags); | |
| 354 EXPECT_TRUE(histogram); | |
| 355 | |
| 356 CallbackCheckWrapper callback_wrapper; | |
| 357 | |
| 358 bool result = base::StatisticsRecorder::SetCallback( | |
| 359 "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged, | |
| 360 base::Unretained(&callback_wrapper))); | |
| 361 EXPECT_TRUE(result); | |
| 362 EXPECT_EQ(histogram->flags() & base::HistogramBase::kCallbackExists, | |
| 363 base::HistogramBase::kCallbackExists); | |
| 364 | |
| 365 result = base::StatisticsRecorder::SetCallback( | |
| 366 "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged, | |
| 367 base::Unretained(&callback_wrapper))); | |
| 368 EXPECT_FALSE(result); | |
| 369 EXPECT_EQ(histogram->flags() & base::HistogramBase::kCallbackExists, | |
| 370 base::HistogramBase::kCallbackExists); | |
| 371 | |
| 372 histogram->Add(1); | |
| 373 | |
| 374 EXPECT_TRUE(callback_wrapper.called); | |
| 375 } | |
| 376 | |
| 377 // Check that you can't overwrite the callback with another. | |
| 378 TEST_F(StatisticsRecorderTest, ClearCallbackSuceedsWithHistogramTest) { | |
| 379 HistogramBase* histogram = Histogram::FactoryGet("TestHistogram", 1, 1000, 10, | |
| 380 HistogramBase::kNoFlags); | |
| 381 EXPECT_TRUE(histogram); | |
| 382 | |
| 383 CallbackCheckWrapper callback_wrapper; | |
| 384 | |
| 385 bool result = base::StatisticsRecorder::SetCallback( | |
| 386 "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged, | |
| 387 base::Unretained(&callback_wrapper))); | |
| 388 EXPECT_TRUE(result); | |
| 389 EXPECT_EQ(histogram->flags() & base::HistogramBase::kCallbackExists, | |
| 390 base::HistogramBase::kCallbackExists); | |
| 391 | |
| 392 base::StatisticsRecorder::ClearCallback("TestHistogram"); | |
| 393 EXPECT_EQ(histogram->flags() & base::HistogramBase::kCallbackExists, 0); | |
| 394 | |
| 395 histogram->Add(1); | |
| 396 | |
| 397 EXPECT_FALSE(callback_wrapper.called); | |
| 398 } | |
| 399 | |
| 400 // Check that callback is used. | |
| 401 TEST_F(StatisticsRecorderTest, CallbackUsedTest) { | |
| 402 { | |
| 403 HistogramBase* histogram = Histogram::FactoryGet( | |
| 404 "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags); | |
| 405 EXPECT_TRUE(histogram); | |
| 406 | |
| 407 CallbackCheckWrapper callback_wrapper; | |
| 408 | |
| 409 base::StatisticsRecorder::SetCallback( | |
| 410 "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged, | |
| 411 base::Unretained(&callback_wrapper))); | |
| 412 | |
| 413 histogram->Add(1); | |
| 414 | |
| 415 EXPECT_TRUE(callback_wrapper.called); | |
| 416 EXPECT_EQ(callback_wrapper.last_histogram_value, 1); | |
| 417 } | |
| 418 | |
| 419 { | |
| 420 HistogramBase* linear_histogram = LinearHistogram::FactoryGet( | |
| 421 "TestLinearHistogram", 1, 1000, 10, HistogramBase::kNoFlags); | |
| 422 | |
| 423 CallbackCheckWrapper callback_wrapper; | |
| 424 | |
| 425 base::StatisticsRecorder::SetCallback( | |
| 426 "TestLinearHistogram", | |
| 427 base::Bind(&CallbackCheckWrapper::OnHistogramChanged, | |
| 428 base::Unretained(&callback_wrapper))); | |
| 429 | |
| 430 linear_histogram->Add(1); | |
| 431 | |
| 432 EXPECT_TRUE(callback_wrapper.called); | |
| 433 EXPECT_EQ(callback_wrapper.last_histogram_value, 1); | |
| 434 } | |
| 435 | |
| 436 { | |
| 437 std::vector<int> custom_ranges; | |
| 438 custom_ranges.push_back(1); | |
| 439 custom_ranges.push_back(5); | |
| 440 HistogramBase* custom_histogram = CustomHistogram::FactoryGet( | |
| 441 "TestCustomHistogram", custom_ranges, HistogramBase::kNoFlags); | |
| 442 | |
| 443 CallbackCheckWrapper callback_wrapper; | |
| 444 | |
| 445 base::StatisticsRecorder::SetCallback( | |
| 446 "TestCustomHistogram", | |
| 447 base::Bind(&CallbackCheckWrapper::OnHistogramChanged, | |
| 448 base::Unretained(&callback_wrapper))); | |
| 449 | |
| 450 custom_histogram->Add(1); | |
| 451 | |
| 452 EXPECT_TRUE(callback_wrapper.called); | |
| 453 EXPECT_EQ(callback_wrapper.last_histogram_value, 1); | |
| 454 } | |
| 455 | |
| 456 { | |
| 457 HistogramBase* custom_histogram = SparseHistogram::FactoryGet( | |
| 458 "TestSparseHistogram", HistogramBase::kNoFlags); | |
| 459 | |
| 460 CallbackCheckWrapper callback_wrapper; | |
| 461 | |
| 462 base::StatisticsRecorder::SetCallback( | |
| 463 "TestSparseHistogram", | |
| 464 base::Bind(&CallbackCheckWrapper::OnHistogramChanged, | |
| 465 base::Unretained(&callback_wrapper))); | |
| 466 | |
| 467 custom_histogram->Add(1); | |
| 468 | |
| 469 EXPECT_TRUE(callback_wrapper.called); | |
| 470 EXPECT_EQ(callback_wrapper.last_histogram_value, 1); | |
| 471 } | |
| 472 } | |
| 473 | |
| 474 // Check that setting a callback before the histogram exists works. | |
| 475 TEST_F(StatisticsRecorderTest, CallbackUsedBeforeHistogramCreatedTest) { | |
| 476 CallbackCheckWrapper callback_wrapper; | |
| 477 | |
| 478 base::StatisticsRecorder::SetCallback( | |
| 479 "TestHistogram", base::Bind(&CallbackCheckWrapper::OnHistogramChanged, | |
| 480 base::Unretained(&callback_wrapper))); | |
| 481 | |
| 482 HistogramBase* histogram = Histogram::FactoryGet("TestHistogram", 1, 1000, 10, | |
| 483 HistogramBase::kNoFlags); | |
| 484 EXPECT_TRUE(histogram); | |
| 485 histogram->Add(1); | |
| 486 | |
| 487 EXPECT_TRUE(callback_wrapper.called); | |
| 488 EXPECT_EQ(callback_wrapper.last_histogram_value, 1); | |
| 489 } | |
| 490 | |
| 491 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
