base/metrics/histogram_unittest.cc

   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 // Test of Histogram class
   6
   7 #include <climits>
   8 #include <algorithm>
   9 #include <vector>
  10
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/metrics/bucket_ranges.h"
  14 #include "base/metrics/histogram.h"
  15 #include "base/metrics/sample_vector.h"
  16 #include "base/metrics/statistics_recorder.h"
  17 #include "base/pickle.h"
  18 #include "base/time/time.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 using std::vector;
  22
  23 namespace base {
  24
  25 class HistogramTest : public testing::Test {
  26  protected:
  27   virtual void SetUp() {
  28     // Each test will have a clean state (no Histogram / BucketRanges
  29     // registered).
  30     InitializeStatisticsRecorder();
  31   }
  32
  33   virtual void TearDown() {
  34     UninitializeStatisticsRecorder();
  35   }
  36
  37   void InitializeStatisticsRecorder() {
  38     statistics_recorder_ = new StatisticsRecorder();
  39   }
  40
  41   void UninitializeStatisticsRecorder() {
  42     delete statistics_recorder_;
  43     statistics_recorder_ = NULL;
  44   }
  45
  46   StatisticsRecorder* statistics_recorder_;
  47 };
  48
  49 // Check for basic syntax and use.
  50 TEST_F(HistogramTest, BasicTest) {
  51   // Try basic construction
  52   HistogramBase* histogram = Histogram::FactoryGet(
  53       "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
  54   EXPECT_TRUE(histogram);
  55
  56   HistogramBase* linear_histogram = LinearHistogram::FactoryGet(
  57       "TestLinearHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
  58   EXPECT_TRUE(linear_histogram);
  59
  60   vector<int> custom_ranges;
  61   custom_ranges.push_back(1);
  62   custom_ranges.push_back(5);
  63   HistogramBase* custom_histogram = CustomHistogram::FactoryGet(
  64       "TestCustomHistogram", custom_ranges, HistogramBase::kNoFlags);
  65   EXPECT_TRUE(custom_histogram);
  66
  67   // Use standard macros (but with fixed samples)
  68   HISTOGRAM_TIMES("Test2Histogram", TimeDelta::FromDays(1));
  69   HISTOGRAM_COUNTS("Test3Histogram", 30);
  70
  71   DHISTOGRAM_TIMES("Test4Histogram", TimeDelta::FromDays(1));
  72   DHISTOGRAM_COUNTS("Test5Histogram", 30);
  73
  74   HISTOGRAM_ENUMERATION("Test6Histogram", 129, 130);
  75 }
  76
  77 // Check that the macro correctly matches histograms by name and records their
  78 // data together.
  79 TEST_F(HistogramTest, NameMatchTest) {
  80   HISTOGRAM_PERCENTAGE("DuplicatedHistogram", 10);
  81   HISTOGRAM_PERCENTAGE("DuplicatedHistogram", 10);
  82   HistogramBase* histogram = LinearHistogram::FactoryGet(
  83       "DuplicatedHistogram", 1, 101, 102, HistogramBase::kNoFlags);
  84
  85   scoped_ptr<HistogramSamples> samples = histogram->SnapshotSamples();
  86   EXPECT_EQ(2, samples->TotalCount());
  87   EXPECT_EQ(2, samples->GetCount(10));
  88 }
  89
  90 TEST_F(HistogramTest, ExponentialRangesTest) {
  91   // Check that we got a nice exponential when there was enough rooom.
  92   BucketRanges ranges(9);
  93   Histogram::InitializeBucketRanges(1, 64, &ranges);
  94   EXPECT_EQ(0, ranges.range(0));
  95   int power_of_2 = 1;
  96   for (int i = 1; i < 8; i++) {
  97     EXPECT_EQ(power_of_2, ranges.range(i));
  98     power_of_2 *= 2;
  99   }
 100   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges.range(8));
 101
 102   // Check the corresponding Histogram will use the correct ranges.
 103   Histogram* histogram = static_cast<Histogram*>(
 104       Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags));
 105   EXPECT_TRUE(ranges.Equals(histogram->bucket_ranges()));
 106
 107   // When bucket count is limited, exponential ranges will partially look like
 108   // linear.
 109   BucketRanges ranges2(16);
 110   Histogram::InitializeBucketRanges(1, 32, &ranges2);
 111
 112   EXPECT_EQ(0, ranges2.range(0));
 113   EXPECT_EQ(1, ranges2.range(1));
 114   EXPECT_EQ(2, ranges2.range(2));
 115   EXPECT_EQ(3, ranges2.range(3));
 116   EXPECT_EQ(4, ranges2.range(4));
 117   EXPECT_EQ(5, ranges2.range(5));
 118   EXPECT_EQ(6, ranges2.range(6));
 119   EXPECT_EQ(7, ranges2.range(7));
 120   EXPECT_EQ(9, ranges2.range(8));
 121   EXPECT_EQ(11, ranges2.range(9));
 122   EXPECT_EQ(14, ranges2.range(10));
 123   EXPECT_EQ(17, ranges2.range(11));
 124   EXPECT_EQ(21, ranges2.range(12));
 125   EXPECT_EQ(26, ranges2.range(13));
 126   EXPECT_EQ(32, ranges2.range(14));
 127   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges2.range(15));
 128
 129   // Check the corresponding Histogram will use the correct ranges.
 130   Histogram* histogram2 = static_cast<Histogram*>(
 131       Histogram::FactoryGet("Histogram2", 1, 32, 15, HistogramBase::kNoFlags));
 132   EXPECT_TRUE(ranges2.Equals(histogram2->bucket_ranges()));
 133 }
 134
 135 TEST_F(HistogramTest, LinearRangesTest) {
 136   BucketRanges ranges(9);
 137   LinearHistogram::InitializeBucketRanges(1, 7, &ranges);
 138   // Gets a nice linear set of bucket ranges.
 139   for (int i = 0; i < 8; i++)
 140     EXPECT_EQ(i, ranges.range(i));
 141   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges.range(8));
 142
 143   // The correspoding LinearHistogram should use the correct ranges.
 144   Histogram* histogram = static_cast<Histogram*>(
 145       LinearHistogram::FactoryGet("Linear", 1, 7, 8, HistogramBase::kNoFlags));
 146   EXPECT_TRUE(ranges.Equals(histogram->bucket_ranges()));
 147
 148   // Linear ranges are not divisible.
 149   BucketRanges ranges2(6);
 150   LinearHistogram::InitializeBucketRanges(1, 6, &ranges2);
 151   EXPECT_EQ(0, ranges2.range(0));
 152   EXPECT_EQ(1, ranges2.range(1));
 153   EXPECT_EQ(3, ranges2.range(2));
 154   EXPECT_EQ(4, ranges2.range(3));
 155   EXPECT_EQ(6, ranges2.range(4));
 156   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges2.range(5));
 157   // The correspoding LinearHistogram should use the correct ranges.
 158   Histogram* histogram2 = static_cast<Histogram*>(
 159       LinearHistogram::FactoryGet("Linear2", 1, 6, 5, HistogramBase::kNoFlags));
 160   EXPECT_TRUE(ranges2.Equals(histogram2->bucket_ranges()));
 161 }
 162
 163 TEST_F(HistogramTest, ArrayToCustomRangesTest) {
 164   const HistogramBase::Sample ranges[3] = {5, 10, 20};
 165   vector<HistogramBase::Sample> ranges_vec =
 166       CustomHistogram::ArrayToCustomRanges(ranges, 3);
 167   ASSERT_EQ(6u, ranges_vec.size());
 168   EXPECT_EQ(5, ranges_vec[0]);
 169   EXPECT_EQ(6, ranges_vec[1]);
 170   EXPECT_EQ(10, ranges_vec[2]);
 171   EXPECT_EQ(11, ranges_vec[3]);
 172   EXPECT_EQ(20, ranges_vec[4]);
 173   EXPECT_EQ(21, ranges_vec[5]);
 174 }
 175
 176 TEST_F(HistogramTest, CustomHistogramTest) {
 177   // A well prepared custom ranges.
 178   vector<HistogramBase::Sample> custom_ranges;
 179   custom_ranges.push_back(1);
 180   custom_ranges.push_back(2);
 181
 182   Histogram* histogram = static_cast<Histogram*>(
 183       CustomHistogram::FactoryGet("TestCustomHistogram1", custom_ranges,
 184                                   HistogramBase::kNoFlags));
 185   const BucketRanges* ranges = histogram->bucket_ranges();
 186   ASSERT_EQ(4u, ranges->size());
 187   EXPECT_EQ(0, ranges->range(0));  // Auto added.
 188   EXPECT_EQ(1, ranges->range(1));
 189   EXPECT_EQ(2, ranges->range(2));
 190   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(3));  // Auto added.
 191
 192   // A unordered custom ranges.
 193   custom_ranges.clear();
 194   custom_ranges.push_back(2);
 195   custom_ranges.push_back(1);
 196   histogram = static_cast<Histogram*>(
 197       CustomHistogram::FactoryGet("TestCustomHistogram2", custom_ranges,
 198                                   HistogramBase::kNoFlags));
 199   ranges = histogram->bucket_ranges();
 200   ASSERT_EQ(4u, ranges->size());
 201   EXPECT_EQ(0, ranges->range(0));
 202   EXPECT_EQ(1, ranges->range(1));
 203   EXPECT_EQ(2, ranges->range(2));
 204   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(3));
 205
 206   // A custom ranges with duplicated values.
 207   custom_ranges.clear();
 208   custom_ranges.push_back(4);
 209   custom_ranges.push_back(1);
 210   custom_ranges.push_back(4);
 211   histogram = static_cast<Histogram*>(
 212       CustomHistogram::FactoryGet("TestCustomHistogram3", custom_ranges,
 213                                   HistogramBase::kNoFlags));
 214   ranges = histogram->bucket_ranges();
 215   ASSERT_EQ(4u, ranges->size());
 216   EXPECT_EQ(0, ranges->range(0));
 217   EXPECT_EQ(1, ranges->range(1));
 218   EXPECT_EQ(4, ranges->range(2));
 219   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(3));
 220 }
 221
 222 TEST_F(HistogramTest, CustomHistogramWithOnly2Buckets) {
 223   // This test exploits the fact that the CustomHistogram can have 2 buckets,
 224   // while the base class Histogram is *supposed* to have at least 3 buckets.
 225   // We should probably change the restriction on the base class (or not inherit
 226   // the base class!).
 227
 228   vector<HistogramBase::Sample> custom_ranges;
 229   custom_ranges.push_back(4);
 230
 231   Histogram* histogram = static_cast<Histogram*>(
 232       CustomHistogram::FactoryGet("2BucketsCustomHistogram", custom_ranges,
 233                                   HistogramBase::kNoFlags));
 234   const BucketRanges* ranges = histogram->bucket_ranges();
 235   ASSERT_EQ(3u, ranges->size());
 236   EXPECT_EQ(0, ranges->range(0));
 237   EXPECT_EQ(4, ranges->range(1));
 238   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(2));
 239 }
 240
 241 // Make sure histogram handles out-of-bounds data gracefully.
 242 TEST_F(HistogramTest, BoundsTest) {
 243   const size_t kBucketCount = 50;
 244   Histogram* histogram = static_cast<Histogram*>(
 245       Histogram::FactoryGet("Bounded", 10, 100, kBucketCount,
 246                             HistogramBase::kNoFlags));
 247
 248   // Put two samples "out of bounds" above and below.
 249   histogram->Add(5);
 250   histogram->Add(-50);
 251
 252   histogram->Add(100);
 253   histogram->Add(10000);
 254
 255   // Verify they landed in the underflow, and overflow buckets.
 256   scoped_ptr<SampleVector> samples = histogram->SnapshotSampleVector();
 257   EXPECT_EQ(2, samples->GetCountAtIndex(0));
 258   EXPECT_EQ(0, samples->GetCountAtIndex(1));
 259   size_t array_size = histogram->bucket_count();
 260   EXPECT_EQ(kBucketCount, array_size);
 261   EXPECT_EQ(0, samples->GetCountAtIndex(array_size - 2));
 262   EXPECT_EQ(2, samples->GetCountAtIndex(array_size - 1));
 263
 264   vector<int> custom_ranges;
 265   custom_ranges.push_back(10);
 266   custom_ranges.push_back(50);
 267   custom_ranges.push_back(100);
 268   Histogram* test_custom_histogram = static_cast<Histogram*>(
 269       CustomHistogram::FactoryGet("TestCustomRangeBoundedHistogram",
 270                                   custom_ranges, HistogramBase::kNoFlags));
 271
 272   // Put two samples "out of bounds" above and below.
 273   test_custom_histogram->Add(5);
 274   test_custom_histogram->Add(-50);
 275   test_custom_histogram->Add(100);
 276   test_custom_histogram->Add(1000);
 277   test_custom_histogram->Add(INT_MAX);
 278
 279   // Verify they landed in the underflow, and overflow buckets.
 280   scoped_ptr<SampleVector> custom_samples =
 281       test_custom_histogram->SnapshotSampleVector();
 282   EXPECT_EQ(2, custom_samples->GetCountAtIndex(0));
 283   EXPECT_EQ(0, custom_samples->GetCountAtIndex(1));
 284   size_t bucket_count = test_custom_histogram->bucket_count();
 285   EXPECT_EQ(0, custom_samples->GetCountAtIndex(bucket_count - 2));
 286   EXPECT_EQ(3, custom_samples->GetCountAtIndex(bucket_count - 1));
 287 }
 288
 289 // Check to be sure samples land as expected is "correct" buckets.
 290 TEST_F(HistogramTest, BucketPlacementTest) {
 291   Histogram* histogram = static_cast<Histogram*>(
 292       Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags));
 293
 294   // Add i+1 samples to the i'th bucket.
 295   histogram->Add(0);
 296   int power_of_2 = 1;
 297   for (int i = 1; i < 8; i++) {
 298     for (int j = 0; j <= i; j++)
 299       histogram->Add(power_of_2);
 300     power_of_2 *= 2;
 301   }
 302
 303   // Check to see that the bucket counts reflect our additions.
 304   scoped_ptr<SampleVector> samples = histogram->SnapshotSampleVector();
 305   for (int i = 0; i < 8; i++)
 306     EXPECT_EQ(i + 1, samples->GetCountAtIndex(i));
 307 }
 308
 309 TEST_F(HistogramTest, CorruptSampleCounts) {
 310   Histogram* histogram = static_cast<Histogram*>(
 311       Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags));
 312
 313   // Add some samples.
 314   histogram->Add(20);
 315   histogram->Add(40);
 316
 317   scoped_ptr<SampleVector> snapshot = histogram->SnapshotSampleVector();
 318   EXPECT_EQ(HistogramBase::NO_INCONSISTENCIES,
 319             histogram->FindCorruption(*snapshot));
 320   EXPECT_EQ(2, snapshot->redundant_count());
 321   EXPECT_EQ(2, snapshot->TotalCount());
 322
 323   snapshot->counts_[3] += 100;  // Sample count won't match redundant count.
 324   EXPECT_EQ(HistogramBase::COUNT_LOW_ERROR,
 325             histogram->FindCorruption(*snapshot));
 326   snapshot->counts_[2] -= 200;
 327   EXPECT_EQ(HistogramBase::COUNT_HIGH_ERROR,
 328             histogram->FindCorruption(*snapshot));
 329
 330   // But we can't spot a corruption if it is compensated for.
 331   snapshot->counts_[1] += 100;
 332   EXPECT_EQ(HistogramBase::NO_INCONSISTENCIES,
 333             histogram->FindCorruption(*snapshot));
 334 }
 335
 336 TEST_F(HistogramTest, CorruptBucketBounds) {
 337   Histogram* histogram = static_cast<Histogram*>(
 338       Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags));
 339
 340   scoped_ptr<SampleVector> snapshot = histogram->SnapshotSampleVector();
 341   EXPECT_EQ(HistogramBase::NO_INCONSISTENCIES,
 342             histogram->FindCorruption(*snapshot));
 343
 344   BucketRanges* bucket_ranges =
 345       const_cast<BucketRanges*>(histogram->bucket_ranges());
 346   HistogramBase::Sample tmp = bucket_ranges->range(1);
 347   bucket_ranges->set_range(1, bucket_ranges->range(2));
 348   bucket_ranges->set_range(2, tmp);
 349   EXPECT_EQ(
 350       HistogramBase::BUCKET_ORDER_ERROR | HistogramBase::RANGE_CHECKSUM_ERROR,
 351       histogram->FindCorruption(*snapshot));
 352
 353   bucket_ranges->set_range(2, bucket_ranges->range(1));
 354   bucket_ranges->set_range(1, tmp);
 355   EXPECT_EQ(0, histogram->FindCorruption(*snapshot));
 356
 357   // Show that two simple changes don't offset each other
 358   bucket_ranges->set_range(3, bucket_ranges->range(3) + 1);
 359   EXPECT_EQ(HistogramBase::RANGE_CHECKSUM_ERROR,
 360             histogram->FindCorruption(*snapshot));
 361
 362   bucket_ranges->set_range(4, bucket_ranges->range(4) - 1);
 363   EXPECT_EQ(HistogramBase::RANGE_CHECKSUM_ERROR,
 364             histogram->FindCorruption(*snapshot));
 365
 366   // Repair histogram so that destructor won't DCHECK().
 367   bucket_ranges->set_range(3, bucket_ranges->range(3) - 1);
 368   bucket_ranges->set_range(4, bucket_ranges->range(4) + 1);
 369 }
 370
 371 TEST_F(HistogramTest, HistogramSerializeInfo) {
 372   Histogram* histogram = static_cast<Histogram*>(
 373       Histogram::FactoryGet("Histogram", 1, 64, 8,
 374                             HistogramBase::kIPCSerializationSourceFlag));
 375   Pickle pickle;
 376   histogram->SerializeInfo(&pickle);
 377
 378   PickleIterator iter(pickle);
 379
 380   int type;
 381   EXPECT_TRUE(iter.ReadInt(&type));
 382   EXPECT_EQ(HISTOGRAM, type);
 383
 384   std::string name;
 385   EXPECT_TRUE(iter.ReadString(&name));
 386   EXPECT_EQ("Histogram", name);
 387
 388   int flag;
 389   EXPECT_TRUE(iter.ReadInt(&flag));
 390   EXPECT_EQ(HistogramBase::kIPCSerializationSourceFlag, flag);
 391
 392   int min;
 393   EXPECT_TRUE(iter.ReadInt(&min));
 394   EXPECT_EQ(1, min);
 395
 396   int max;
 397   EXPECT_TRUE(iter.ReadInt(&max));
 398   EXPECT_EQ(64, max);
 399
 400   int64 bucket_count;
 401   EXPECT_TRUE(iter.ReadInt64(&bucket_count));
 402   EXPECT_EQ(8, bucket_count);
 403
 404   uint32 checksum;
 405   EXPECT_TRUE(iter.ReadUInt32(&checksum));
 406   EXPECT_EQ(histogram->bucket_ranges()->checksum(), checksum);
 407
 408   // No more data in the pickle.
 409   EXPECT_FALSE(iter.SkipBytes(1));
 410 }
 411
 412 TEST_F(HistogramTest, CustomHistogramSerializeInfo) {
 413   vector<int> custom_ranges;
 414   custom_ranges.push_back(10);
 415   custom_ranges.push_back(100);
 416
 417   HistogramBase* custom_histogram = CustomHistogram::FactoryGet(
 418       "TestCustomRangeBoundedHistogram",
 419       custom_ranges,
 420       HistogramBase::kNoFlags);
 421   Pickle pickle;
 422   custom_histogram->SerializeInfo(&pickle);
 423
 424   // Validate the pickle.
 425   PickleIterator iter(pickle);
 426
 427   int i;
 428   std::string s;
 429   int64 bucket_count;
 430   uint32 ui32;
 431   EXPECT_TRUE(iter.ReadInt(&i) && iter.ReadString(&s) && iter.ReadInt(&i) &&
 432               iter.ReadInt(&i) && iter.ReadInt(&i) &&
 433               iter.ReadInt64(&bucket_count) && iter.ReadUInt32(&ui32));
 434   EXPECT_EQ(3, bucket_count);
 435
 436   int range;
 437   EXPECT_TRUE(iter.ReadInt(&range));
 438   EXPECT_EQ(10, range);
 439   EXPECT_TRUE(iter.ReadInt(&range));
 440   EXPECT_EQ(100, range);
 441
 442   // No more data in the pickle.
 443   EXPECT_FALSE(iter.SkipBytes(1));
 444 }
 445
 446 #if GTEST_HAS_DEATH_TEST
 447 // For Histogram, LinearHistogram and CustomHistogram, the minimum for a
 448 // declared range is 1, while the maximum is (HistogramBase::kSampleType_MAX -
 449 // 1). But we accept ranges exceeding those limits, and silently clamped to
 450 // those limits. This is for backwards compatibility.
 451 TEST(HistogramDeathTest, BadRangesTest) {
 452   HistogramBase* histogram = Histogram::FactoryGet(
 453       "BadRanges", 0, HistogramBase::kSampleType_MAX, 8,
 454       HistogramBase::kNoFlags);
 455   EXPECT_TRUE(
 456       histogram->HasConstructionArguments(
 457           1, HistogramBase::kSampleType_MAX - 1, 8));
 458
 459   HistogramBase* linear_histogram = LinearHistogram::FactoryGet(
 460       "BadRangesLinear", 0, HistogramBase::kSampleType_MAX, 8,
 461       HistogramBase::kNoFlags);
 462   EXPECT_TRUE(
 463       linear_histogram->HasConstructionArguments(
 464           1, HistogramBase::kSampleType_MAX - 1, 8));
 465
 466   vector<int> custom_ranges;
 467   custom_ranges.push_back(0);
 468   custom_ranges.push_back(5);
 469   Histogram* custom_histogram = static_cast<Histogram*>(
 470       CustomHistogram::FactoryGet(
 471           "BadRangesCustom", custom_ranges, HistogramBase::kNoFlags));
 472   const BucketRanges* ranges = custom_histogram->bucket_ranges();
 473   ASSERT_EQ(3u, ranges->size());
 474   EXPECT_EQ(0, ranges->range(0));
 475   EXPECT_EQ(5, ranges->range(1));
 476   EXPECT_EQ(HistogramBase::kSampleType_MAX, ranges->range(2));
 477
 478   // CustomHistogram does not accepts kSampleType_MAX as range.
 479   custom_ranges.push_back(HistogramBase::kSampleType_MAX);
 480   EXPECT_DEATH(CustomHistogram::FactoryGet("BadRangesCustom2", custom_ranges,
 481                                            HistogramBase::kNoFlags),
 482                "");
 483
 484   // CustomHistogram needs at least 1 valid range.
 485   custom_ranges.clear();
 486   custom_ranges.push_back(0);
 487   EXPECT_DEATH(CustomHistogram::FactoryGet("BadRangesCustom3", custom_ranges,
 488                                            HistogramBase::kNoFlags),
 489                "");
 490 }
 491 #endif
 492
 493 }  // namespace base