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