base/histogram_unittest.cc - chromium/src - Git at Google

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 // Test of Histogram class

 #include "base/histogram.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "testing/gtest/include/gtest/gtest.h"

 using base::TimeDelta;

 namespace {

 class HistogramTest : public testing::Test {
 };

 // Check for basic syntax and use.
 TEST(HistogramTest, StartupShutdownTest) {
   // Try basic construction
   scoped_refptr<Histogram> histogram = Histogram::FactoryGet(
       "TestHistogram", 1, 1000, 10, Histogram::kNoFlags);
   scoped_refptr<Histogram> histogram1 = Histogram::FactoryGet(
       "Test1Histogram", 1, 1000, 10, Histogram::kNoFlags);

   scoped_refptr<Histogram> linear_histogram = LinearHistogram::FactoryGet(
       "TestLinearHistogram", 1, 1000, 10, Histogram::kNoFlags);
   scoped_refptr<Histogram> linear_histogram1 = LinearHistogram::FactoryGet(
       "Test1LinearHistogram", 1, 1000, 10, Histogram::kNoFlags);

   std::vector<int> custom_ranges;
   custom_ranges.push_back(1);
   custom_ranges.push_back(5);
   custom_ranges.push_back(10);
   custom_ranges.push_back(20);
   custom_ranges.push_back(30);
   scoped_refptr<Histogram> custom_histogram = CustomHistogram::FactoryGet(
       "TestCustomHistogram", custom_ranges, Histogram::kNoFlags);
   scoped_refptr<Histogram> custom_histogram1 = CustomHistogram::FactoryGet(
       "Test1CustomHistogram", custom_ranges, Histogram::kNoFlags);

   // Use standard macros (but with fixed samples)
   HISTOGRAM_TIMES("Test2Histogram", TimeDelta::FromDays(1));
   HISTOGRAM_COUNTS("Test3Histogram", 30);

   DHISTOGRAM_TIMES("Test4Histogram", TimeDelta::FromDays(1));
   DHISTOGRAM_COUNTS("Test5Histogram", 30);

   HISTOGRAM_ENUMERATION("Test6Histogram", 129, 130);

   // Try to construct samples.
   Histogram::SampleSet sample1;
   Histogram::SampleSet sample2;

   // Use copy constructor of SampleSet
   sample1 = sample2;
   Histogram::SampleSet sample3(sample1);

   // Finally test a statistics recorder, without really using it.
   StatisticsRecorder recorder;
 }

 // Repeat with a recorder present to register with.
 TEST(HistogramTest, RecordedStartupTest) {
   // Test a statistics recorder, by letting histograms register.
   StatisticsRecorder recorder;  // This initializes the global state.

   StatisticsRecorder::Histograms histograms;
   EXPECT_EQ(0U, histograms.size());
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(0U, histograms.size());

   // Try basic construction
   scoped_refptr<Histogram> histogram = Histogram::FactoryGet(
       "TestHistogram", 1, 1000, 10, Histogram::kNoFlags);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(1U, histograms.size());
   scoped_refptr<Histogram> histogram1 = Histogram::FactoryGet(
       "Test1Histogram", 1, 1000, 10, Histogram::kNoFlags);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(2U, histograms.size());

   scoped_refptr<Histogram> linear_histogram = LinearHistogram::FactoryGet(
       "TestLinearHistogram", 1, 1000, 10, Histogram::kNoFlags);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(3U, histograms.size());

   scoped_refptr<Histogram> linear_histogram1 = LinearHistogram::FactoryGet(
       "Test1LinearHistogram", 1, 1000, 10, Histogram::kNoFlags);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(4U, histograms.size());

   std::vector<int> custom_ranges;
   custom_ranges.push_back(1);
   custom_ranges.push_back(5);
   custom_ranges.push_back(10);
   custom_ranges.push_back(20);
   custom_ranges.push_back(30);
   scoped_refptr<Histogram> custom_histogram = CustomHistogram::FactoryGet(
       "TestCustomHistogram", custom_ranges, Histogram::kNoFlags);
   scoped_refptr<Histogram> custom_histogram1 = CustomHistogram::FactoryGet(
       "TestCustomHistogram", custom_ranges, Histogram::kNoFlags);

   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(5U, histograms.size());

   // Use standard macros (but with fixed samples)
   HISTOGRAM_TIMES("Test2Histogram", TimeDelta::FromDays(1));
   HISTOGRAM_COUNTS("Test3Histogram", 30);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(7U, histograms.size());

   HISTOGRAM_ENUMERATION("TestEnumerationHistogram", 20, 200);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
   EXPECT_EQ(8U, histograms.size());

   DHISTOGRAM_TIMES("Test4Histogram", TimeDelta::FromDays(1));
   DHISTOGRAM_COUNTS("Test5Histogram", 30);
   histograms.clear();
   StatisticsRecorder::GetHistograms(&histograms);  // Load up lists
 #ifndef NDEBUG
   EXPECT_EQ(10U, histograms.size());
 #else
   EXPECT_EQ(8U, histograms.size());
 #endif
 }

 TEST(HistogramTest, RangeTest) {
   StatisticsRecorder recorder;
   StatisticsRecorder::Histograms histograms;

   recorder.GetHistograms(&histograms);
   EXPECT_EQ(0U, histograms.size());

   scoped_refptr<Histogram> histogram = Histogram::FactoryGet(
       "Histogram", 1, 64, 8, Histogram::kNoFlags);  // As per header file.
   // Check that we got a nice exponential when there was enough rooom.
   EXPECT_EQ(0, histogram->ranges(0));
   int power_of_2 = 1;
   for (int i = 1; i < 8; i++) {
     EXPECT_EQ(power_of_2, histogram->ranges(i));
     power_of_2 *= 2;
   }
   EXPECT_EQ(INT_MAX, histogram->ranges(8));

   scoped_refptr<Histogram> short_histogram = Histogram::FactoryGet(
       "Histogram Shortened", 1, 7, 8, Histogram::kNoFlags);
   // Check that when the number of buckets is short, we get a linear histogram
   // for lack of space to do otherwise.
   for (int i = 0; i < 8; i++)
     EXPECT_EQ(i, short_histogram->ranges(i));
   EXPECT_EQ(INT_MAX, short_histogram->ranges(8));

   scoped_refptr<Histogram> linear_histogram = LinearHistogram::FactoryGet(
       "Linear", 1, 7, 8, Histogram::kNoFlags);
   // We also get a nice linear set of bucket ranges when we ask for it
   for (int i = 0; i < 8; i++)
     EXPECT_EQ(i, linear_histogram->ranges(i));
   EXPECT_EQ(INT_MAX, linear_histogram->ranges(8));

   scoped_refptr<Histogram> linear_broad_histogram = LinearHistogram::FactoryGet(
       "Linear widened", 2, 14, 8, Histogram::kNoFlags);
   // ...but when the list has more space, then the ranges naturally spread out.
   for (int i = 0; i < 8; i++)
     EXPECT_EQ(2 * i, linear_broad_histogram->ranges(i));
   EXPECT_EQ(INT_MAX, linear_broad_histogram->ranges(8));

   scoped_refptr<Histogram> transitioning_histogram =
       Histogram::FactoryGet("LinearAndExponential", 1, 32, 15,
                                       Histogram::kNoFlags);
   // When space is a little tight, we transition from linear to exponential.
   EXPECT_EQ(0, transitioning_histogram->ranges(0));
   EXPECT_EQ(1, transitioning_histogram->ranges(1));
   EXPECT_EQ(2, transitioning_histogram->ranges(2));
   EXPECT_EQ(3, transitioning_histogram->ranges(3));
   EXPECT_EQ(4, transitioning_histogram->ranges(4));
   EXPECT_EQ(5, transitioning_histogram->ranges(5));
   EXPECT_EQ(6, transitioning_histogram->ranges(6));
   EXPECT_EQ(7, transitioning_histogram->ranges(7));
   EXPECT_EQ(9, transitioning_histogram->ranges(8));
   EXPECT_EQ(11, transitioning_histogram->ranges(9));
   EXPECT_EQ(14, transitioning_histogram->ranges(10));
   EXPECT_EQ(17, transitioning_histogram->ranges(11));
   EXPECT_EQ(21, transitioning_histogram->ranges(12));
   EXPECT_EQ(26, transitioning_histogram->ranges(13));
   EXPECT_EQ(32, transitioning_histogram->ranges(14));
   EXPECT_EQ(INT_MAX, transitioning_histogram->ranges(15));

   std::vector<int> custom_ranges;
   custom_ranges.push_back(0);
   custom_ranges.push_back(9);
   custom_ranges.push_back(10);
   custom_ranges.push_back(11);
   custom_ranges.push_back(300);
   scoped_refptr<Histogram> test_custom_histogram = CustomHistogram::FactoryGet(
       "TestCustomRangeHistogram", custom_ranges, Histogram::kNoFlags);

   EXPECT_EQ(custom_ranges[0], test_custom_histogram->ranges(0));
   EXPECT_EQ(custom_ranges[1], test_custom_histogram->ranges(1));
   EXPECT_EQ(custom_ranges[2], test_custom_histogram->ranges(2));
   EXPECT_EQ(custom_ranges[3], test_custom_histogram->ranges(3));
   EXPECT_EQ(custom_ranges[4], test_custom_histogram->ranges(4));

   recorder.GetHistograms(&histograms);
   EXPECT_EQ(6U, histograms.size());
 }

 TEST(HistogramTest, CustomRangeTest) {
   StatisticsRecorder recorder;
   StatisticsRecorder::Histograms histograms;

   // Check that missing leading zero is handled by an auto-insertion.
   std::vector<int> custom_ranges;
   // Don't include a zero.
   custom_ranges.push_back(9);
   custom_ranges.push_back(10);
   custom_ranges.push_back(11);
   scoped_refptr<Histogram> test_custom_histogram = CustomHistogram::FactoryGet(
       "TestCustomRangeHistogram", custom_ranges, Histogram::kNoFlags);

   EXPECT_EQ(0, test_custom_histogram->ranges(0));  // Auto added
   EXPECT_EQ(custom_ranges[0], test_custom_histogram->ranges(1));
   EXPECT_EQ(custom_ranges[1], test_custom_histogram->ranges(2));
   EXPECT_EQ(custom_ranges[2], test_custom_histogram->ranges(3));

   // Check that unsorted data with dups is handled gracefully.
   const int kSmall = 7;
   const int kMid = 8;
   const int kBig = 9;
   custom_ranges.clear();
   custom_ranges.push_back(kBig);
   custom_ranges.push_back(kMid);
   custom_ranges.push_back(kSmall);
   custom_ranges.push_back(kSmall);
   custom_ranges.push_back(kMid);
   custom_ranges.push_back(0);  // Push an explicit zero.
   custom_ranges.push_back(kBig);

   scoped_refptr<Histogram> unsorted_histogram = CustomHistogram::FactoryGet(
       "TestCustomUnsortedDupedHistogram", custom_ranges, Histogram::kNoFlags);
   EXPECT_EQ(0, unsorted_histogram->ranges(0));
   EXPECT_EQ(kSmall, unsorted_histogram->ranges(1));
   EXPECT_EQ(kMid, unsorted_histogram->ranges(2));
   EXPECT_EQ(kBig, unsorted_histogram->ranges(3));
 }


 // Make sure histogram handles out-of-bounds data gracefully.
 TEST(HistogramTest, BoundsTest) {
   const size_t kBucketCount = 50;
   scoped_refptr<Histogram> histogram = Histogram::FactoryGet(
       "Bounded", 10, 100, kBucketCount, Histogram::kNoFlags);

   // Put two samples "out of bounds" above and below.
   histogram->Add(5);
   histogram->Add(-50);

   histogram->Add(100);
   histogram->Add(10000);

   // Verify they landed in the underflow, and overflow buckets.
   Histogram::SampleSet sample;
   histogram->SnapshotSample(&sample);
   EXPECT_EQ(2, sample.counts(0));
   EXPECT_EQ(0, sample.counts(1));
   size_t array_size = histogram->bucket_count();
   EXPECT_EQ(kBucketCount, array_size);
   EXPECT_EQ(0, sample.counts(array_size - 2));
   EXPECT_EQ(2, sample.counts(array_size - 1));
 }

 // Check to be sure samples land as expected is "correct" buckets.
 TEST(HistogramTest, BucketPlacementTest) {
   scoped_refptr<Histogram> histogram = Histogram::FactoryGet(
       "Histogram", 1, 64, 8, Histogram::kNoFlags);  // As per header file.

   // Check that we got a nice exponential since there was enough rooom.
   EXPECT_EQ(0, histogram->ranges(0));
   int power_of_2 = 1;
   for (int i = 1; i < 8; i++) {
     EXPECT_EQ(power_of_2, histogram->ranges(i));
     power_of_2 *= 2;
   }
   EXPECT_EQ(INT_MAX, histogram->ranges(8));

   // Add i+1 samples to the i'th bucket.
   histogram->Add(0);
   power_of_2 = 1;
   for (int i = 1; i < 8; i++) {
     for (int j = 0; j <= i; j++)
       histogram->Add(power_of_2);
     power_of_2 *= 2;
   }
   // Leave overflow bucket empty.

   // Check to see that the bucket counts reflect our additions.
   Histogram::SampleSet sample;
   histogram->SnapshotSample(&sample);
   EXPECT_EQ(INT_MAX, histogram->ranges(8));
   for (int i = 0; i < 8; i++)
     EXPECT_EQ(i + 1, sample.counts(i));
 }


 }  // namespace
	// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	// Test of Histogram class

	#include "base/histogram.h"
	#include "base/string_util.h"
	#include "base/time.h"
	#include "testing/gtest/include/gtest/gtest.h"

	using base::TimeDelta;

	namespace {

	class HistogramTest : public testing::Test {
	};

	// Check for basic syntax and use.
	TEST(HistogramTest, StartupShutdownTest) {
	// Try basic construction
	scoped_refptr<Histogram> histogram = Histogram::FactoryGet(
	"TestHistogram", 1, 1000, 10, Histogram::kNoFlags);
	scoped_refptr<Histogram> histogram1 = Histogram::FactoryGet(
	"Test1Histogram", 1, 1000, 10, Histogram::kNoFlags);

	scoped_refptr<Histogram> linear_histogram = LinearHistogram::FactoryGet(
	"TestLinearHistogram", 1, 1000, 10, Histogram::kNoFlags);
	scoped_refptr<Histogram> linear_histogram1 = LinearHistogram::FactoryGet(
	"Test1LinearHistogram", 1, 1000, 10, Histogram::kNoFlags);

	std::vector<int> custom_ranges;
	custom_ranges.push_back(1);
	custom_ranges.push_back(5);
	custom_ranges.push_back(10);
	custom_ranges.push_back(20);
	custom_ranges.push_back(30);
	scoped_refptr<Histogram> custom_histogram = CustomHistogram::FactoryGet(
	"TestCustomHistogram", custom_ranges, Histogram::kNoFlags);
	scoped_refptr<Histogram> custom_histogram1 = CustomHistogram::FactoryGet(
	"Test1CustomHistogram", custom_ranges, Histogram::kNoFlags);

	// Use standard macros (but with fixed samples)
	HISTOGRAM_TIMES("Test2Histogram", TimeDelta::FromDays(1));
	HISTOGRAM_COUNTS("Test3Histogram", 30);

	DHISTOGRAM_TIMES("Test4Histogram", TimeDelta::FromDays(1));
	DHISTOGRAM_COUNTS("Test5Histogram", 30);

	HISTOGRAM_ENUMERATION("Test6Histogram", 129, 130);

	// Try to construct samples.
	Histogram::SampleSet sample1;
	Histogram::SampleSet sample2;

	// Use copy constructor of SampleSet
	sample1 = sample2;
	Histogram::SampleSet sample3(sample1);

	// Finally test a statistics recorder, without really using it.
	StatisticsRecorder recorder;
	}

	// Repeat with a recorder present to register with.
	TEST(HistogramTest, RecordedStartupTest) {
	// Test a statistics recorder, by letting histograms register.
	StatisticsRecorder recorder; // This initializes the global state.

	StatisticsRecorder::Histograms histograms;
	EXPECT_EQ(0U, histograms.size());
	StatisticsRecorder::GetHistograms(&histograms); // Load up lists
	EXPECT_EQ(0U, histograms.size());

	// Try basic construction
	scoped_refptr<Histogram> histogram = Histogram::FactoryGet(
	"TestHistogram", 1, 1000, 10, Histogram::kNoFlags);
	histograms.clear();
	StatisticsRecorder::GetHistograms(&histograms); // Load up lists
	EXPECT_EQ(1U, histograms.size());
	scoped_refptr<Histogram> histogram1 = Histogram::FactoryGet(
	"Test1Histogram", 1, 1000, 10, Histogram::kNoFlags);
	histograms.clear();
	StatisticsRecorder::GetHistograms(&histograms); // Load up lists
	EXPECT_EQ(2U, histograms.size());

	scoped_refptr<Histogram> linear_histogram = LinearHistogram::FactoryGet(
	"TestLinearHistogram", 1, 1000, 10, Histogram::kNoFlags);
	histograms.clear();
	StatisticsRecorder::GetHistograms(&histograms); // Load up lists
	EXPECT_EQ(3U, histograms.size());

	scoped_refptr<Histogram> linear_histogram1 = LinearHistogram::FactoryGet(
	"Test1LinearHistogram", 1, 1000, 10, Histogram::kNoFlags);
	histograms.clear();
	StatisticsRecorder::GetHistograms(&histograms); // Load up lists
	EXPECT_EQ(4U, histograms.size());

	std::vector<int> custom_ranges;
	custom_ranges.push_back(1);
	custom_ranges.push_back(5);
	custom_ranges.push_back(10);
	custom_ranges.push_back(20);
	custom_ranges.push_back(30);
	scoped_refptr<Histogram> custom_histogram = CustomHistogram::FactoryGet(
	"TestCustomHistogram", custom_ranges, Histogram::kNoFlags);
	scoped_refptr<Histogram> custom_histogram1 = CustomHistogram::FactoryGet(
	"TestCustomHistogram", custom_ranges, Histogram::kNoFlags);

	histograms.clear();
	StatisticsRecorder::GetHistograms(&histograms); // Load up lists
	EXPECT_EQ(5U, histograms.size());

	// Use standard macros (but with fixed samples)
	HISTOGRAM_TIMES("Test2Histogram", TimeDelta::FromDays(1));
	HISTOGRAM_COUNTS("Test3Histogram", 30);
	histograms.clear();
	StatisticsRecorder::GetHistograms(&histograms); // Load up lists
	EXPECT_EQ(7U, histograms.size());

	HISTOGRAM_ENUMERATION("TestEnumerationHistogram", 20, 200);
	histograms.clear();
	StatisticsRecorder::GetHistograms(&histograms); // Load up lists
	EXPECT_EQ(8U, histograms.size());

	DHISTOGRAM_TIMES("Test4Histogram", TimeDelta::FromDays(1));
	DHISTOGRAM_COUNTS("Test5Histogram", 30);
	histograms.clear();
	StatisticsRecorder::GetHistograms(&histograms); // Load up lists
	#ifndef NDEBUG
	EXPECT_EQ(10U, histograms.size());
	#else
	EXPECT_EQ(8U, histograms.size());
	#endif
	}

	TEST(HistogramTest, RangeTest) {
	StatisticsRecorder recorder;
	StatisticsRecorder::Histograms histograms;

	recorder.GetHistograms(&histograms);
	EXPECT_EQ(0U, histograms.size());

	scoped_refptr<Histogram> histogram = Histogram::FactoryGet(
	"Histogram", 1, 64, 8, Histogram::kNoFlags); // As per header file.
	// Check that we got a nice exponential when there was enough rooom.
	EXPECT_EQ(0, histogram->ranges(0));
	int power_of_2 = 1;
	for (int i = 1; i < 8; i++) {
	EXPECT_EQ(power_of_2, histogram->ranges(i));
	power_of_2 *= 2;
	}
	EXPECT_EQ(INT_MAX, histogram->ranges(8));

	scoped_refptr<Histogram> short_histogram = Histogram::FactoryGet(
	"Histogram Shortened", 1, 7, 8, Histogram::kNoFlags);
	// Check that when the number of buckets is short, we get a linear histogram
	// for lack of space to do otherwise.
	for (int i = 0; i < 8; i++)
	EXPECT_EQ(i, short_histogram->ranges(i));
	EXPECT_EQ(INT_MAX, short_histogram->ranges(8));

	scoped_refptr<Histogram> linear_histogram = LinearHistogram::FactoryGet(
	"Linear", 1, 7, 8, Histogram::kNoFlags);
	// We also get a nice linear set of bucket ranges when we ask for it
	for (int i = 0; i < 8; i++)
	EXPECT_EQ(i, linear_histogram->ranges(i));
	EXPECT_EQ(INT_MAX, linear_histogram->ranges(8));

	scoped_refptr<Histogram> linear_broad_histogram = LinearHistogram::FactoryGet(
	"Linear widened", 2, 14, 8, Histogram::kNoFlags);
	// ...but when the list has more space, then the ranges naturally spread out.
	for (int i = 0; i < 8; i++)
	EXPECT_EQ(2 * i, linear_broad_histogram->ranges(i));
	EXPECT_EQ(INT_MAX, linear_broad_histogram->ranges(8));

	scoped_refptr<Histogram> transitioning_histogram =
	Histogram::FactoryGet("LinearAndExponential", 1, 32, 15,
	Histogram::kNoFlags);
	// When space is a little tight, we transition from linear to exponential.
	EXPECT_EQ(0, transitioning_histogram->ranges(0));
	EXPECT_EQ(1, transitioning_histogram->ranges(1));
	EXPECT_EQ(2, transitioning_histogram->ranges(2));
	EXPECT_EQ(3, transitioning_histogram->ranges(3));
	EXPECT_EQ(4, transitioning_histogram->ranges(4));
	EXPECT_EQ(5, transitioning_histogram->ranges(5));
	EXPECT_EQ(6, transitioning_histogram->ranges(6));
	EXPECT_EQ(7, transitioning_histogram->ranges(7));
	EXPECT_EQ(9, transitioning_histogram->ranges(8));
	EXPECT_EQ(11, transitioning_histogram->ranges(9));
	EXPECT_EQ(14, transitioning_histogram->ranges(10));
	EXPECT_EQ(17, transitioning_histogram->ranges(11));
	EXPECT_EQ(21, transitioning_histogram->ranges(12));
	EXPECT_EQ(26, transitioning_histogram->ranges(13));
	EXPECT_EQ(32, transitioning_histogram->ranges(14));
	EXPECT_EQ(INT_MAX, transitioning_histogram->ranges(15));

	std::vector<int> custom_ranges;
	custom_ranges.push_back(0);
	custom_ranges.push_back(9);
	custom_ranges.push_back(10);
	custom_ranges.push_back(11);
	custom_ranges.push_back(300);
	scoped_refptr<Histogram> test_custom_histogram = CustomHistogram::FactoryGet(
	"TestCustomRangeHistogram", custom_ranges, Histogram::kNoFlags);

	EXPECT_EQ(custom_ranges[0], test_custom_histogram->ranges(0));
	EXPECT_EQ(custom_ranges[1], test_custom_histogram->ranges(1));
	EXPECT_EQ(custom_ranges[2], test_custom_histogram->ranges(2));
	EXPECT_EQ(custom_ranges[3], test_custom_histogram->ranges(3));
	EXPECT_EQ(custom_ranges[4], test_custom_histogram->ranges(4));

	recorder.GetHistograms(&histograms);
	EXPECT_EQ(6U, histograms.size());
	}

	TEST(HistogramTest, CustomRangeTest) {
	StatisticsRecorder recorder;
	StatisticsRecorder::Histograms histograms;

	// Check that missing leading zero is handled by an auto-insertion.
	std::vector<int> custom_ranges;
	// Don't include a zero.
	custom_ranges.push_back(9);
	custom_ranges.push_back(10);
	custom_ranges.push_back(11);
	scoped_refptr<Histogram> test_custom_histogram = CustomHistogram::FactoryGet(
	"TestCustomRangeHistogram", custom_ranges, Histogram::kNoFlags);

	EXPECT_EQ(0, test_custom_histogram->ranges(0)); // Auto added
	EXPECT_EQ(custom_ranges[0], test_custom_histogram->ranges(1));
	EXPECT_EQ(custom_ranges[1], test_custom_histogram->ranges(2));
	EXPECT_EQ(custom_ranges[2], test_custom_histogram->ranges(3));

	// Check that unsorted data with dups is handled gracefully.
	const int kSmall = 7;
	const int kMid = 8;
	const int kBig = 9;
	custom_ranges.clear();
	custom_ranges.push_back(kBig);
	custom_ranges.push_back(kMid);
	custom_ranges.push_back(kSmall);
	custom_ranges.push_back(kSmall);
	custom_ranges.push_back(kMid);
	custom_ranges.push_back(0); // Push an explicit zero.
	custom_ranges.push_back(kBig);

	scoped_refptr<Histogram> unsorted_histogram = CustomHistogram::FactoryGet(
	"TestCustomUnsortedDupedHistogram", custom_ranges, Histogram::kNoFlags);
	EXPECT_EQ(0, unsorted_histogram->ranges(0));
	EXPECT_EQ(kSmall, unsorted_histogram->ranges(1));
	EXPECT_EQ(kMid, unsorted_histogram->ranges(2));
	EXPECT_EQ(kBig, unsorted_histogram->ranges(3));
	}


	// Make sure histogram handles out-of-bounds data gracefully.
	TEST(HistogramTest, BoundsTest) {
	const size_t kBucketCount = 50;
	scoped_refptr<Histogram> histogram = Histogram::FactoryGet(
	"Bounded", 10, 100, kBucketCount, Histogram::kNoFlags);

	// Put two samples "out of bounds" above and below.
	histogram->Add(5);
	histogram->Add(-50);

	histogram->Add(100);
	histogram->Add(10000);

	// Verify they landed in the underflow, and overflow buckets.
	Histogram::SampleSet sample;
	histogram->SnapshotSample(&sample);
	EXPECT_EQ(2, sample.counts(0));
	EXPECT_EQ(0, sample.counts(1));
	size_t array_size = histogram->bucket_count();
	EXPECT_EQ(kBucketCount, array_size);
	EXPECT_EQ(0, sample.counts(array_size - 2));
	EXPECT_EQ(2, sample.counts(array_size - 1));
	}

	// Check to be sure samples land as expected is "correct" buckets.
	TEST(HistogramTest, BucketPlacementTest) {
	scoped_refptr<Histogram> histogram = Histogram::FactoryGet(
	"Histogram", 1, 64, 8, Histogram::kNoFlags); // As per header file.

	// Check that we got a nice exponential since there was enough rooom.
	EXPECT_EQ(0, histogram->ranges(0));
	int power_of_2 = 1;
	for (int i = 1; i < 8; i++) {
	EXPECT_EQ(power_of_2, histogram->ranges(i));
	power_of_2 *= 2;
	}
	EXPECT_EQ(INT_MAX, histogram->ranges(8));

	// Add i+1 samples to the i'th bucket.
	histogram->Add(0);
	power_of_2 = 1;
	for (int i = 1; i < 8; i++) {
	for (int j = 0; j <= i; j++)
	histogram->Add(power_of_2);
	power_of_2 *= 2;
	}
	// Leave overflow bucket empty.

	// Check to see that the bucket counts reflect our additions.
	Histogram::SampleSet sample;
	histogram->SnapshotSample(&sample);
	EXPECT_EQ(INT_MAX, histogram->ranges(8));
	for (int i = 0; i < 8; i++)
	EXPECT_EQ(i + 1, sample.counts(i));
	}


	} // namespace