base/metrics/statistics_recorder_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 #include <vector>
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/metrics/statistics_recorder.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace base {
  13
  14 class StatisticsRecorderTest : public testing::Test {
  15  protected:
  16   virtual void SetUp() {
  17     // Each test will have a clean state (no Histogram / BucketRanges
  18     // registered).
  19     InitializeStatisticsRecorder();
  20   }
  21
  22   virtual void TearDown() {
  23     UninitializeStatisticsRecorder();
  24   }
  25
  26   void InitializeStatisticsRecorder() {
  27     statistics_recorder_ = new StatisticsRecorder();
  28   }
  29
  30   void UninitializeStatisticsRecorder() {
  31     delete statistics_recorder_;
  32     statistics_recorder_ = NULL;
  33   }
  34
  35   Histogram* CreateHistogram(const std::string& name,
  36                              HistogramBase::Sample min,
  37                              HistogramBase::Sample max,
  38                              size_t bucket_count) {
  39     BucketRanges* ranges = new BucketRanges(bucket_count + 1);
  40     Histogram::InitializeBucketRanges(min, max, ranges);
  41     const BucketRanges* registered_ranges =
  42         StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges);
  43     return new Histogram(name, min, max, registered_ranges);
  44   }
  45
  46   void DeleteHistogram(HistogramBase* histogram) {
  47     delete histogram;
  48   }
  49
  50   StatisticsRecorder* statistics_recorder_;
  51 };
  52
  53 TEST_F(StatisticsRecorderTest, NotInitialized) {
  54   UninitializeStatisticsRecorder();
  55
  56   ASSERT_FALSE(StatisticsRecorder::IsActive());
  57
  58   StatisticsRecorder::Histograms registered_histograms;
  59   std::vector<const BucketRanges*> registered_ranges;
  60
  61   StatisticsRecorder::GetHistograms(&registered_histograms);
  62   EXPECT_EQ(0u, registered_histograms.size());
  63
  64   Histogram* histogram = CreateHistogram("TestHistogram", 1, 1000, 10);
  65
  66   // When StatisticsRecorder is not initialized, register is a noop.
  67   EXPECT_EQ(histogram,
  68             StatisticsRecorder::RegisterOrDeleteDuplicate(histogram));
  69   // Manually delete histogram that was not registered.
  70   DeleteHistogram(histogram);
  71
  72   // RegisterOrDeleteDuplicateRanges is a no-op.
  73   BucketRanges* ranges = new BucketRanges(3);;
  74   ranges->ResetChecksum();
  75   EXPECT_EQ(ranges,
  76             StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges));
  77   StatisticsRecorder::GetBucketRanges(&registered_ranges);
  78   EXPECT_EQ(0u, registered_ranges.size());
  79 }
  80
  81 TEST_F(StatisticsRecorderTest, RegisterBucketRanges) {
  82   std::vector<const BucketRanges*> registered_ranges;
  83
  84   BucketRanges* ranges1 = new BucketRanges(3);;
  85   ranges1->ResetChecksum();
  86   BucketRanges* ranges2 = new BucketRanges(4);;
  87   ranges2->ResetChecksum();
  88
  89   // Register new ranges.
  90   EXPECT_EQ(ranges1,
  91             StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges1));
  92   EXPECT_EQ(ranges2,
  93             StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges2));
  94   StatisticsRecorder::GetBucketRanges(&registered_ranges);
  95   ASSERT_EQ(2u, registered_ranges.size());
  96
  97   // Register some ranges again.
  98   EXPECT_EQ(ranges1,
  99             StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges1));
 100   registered_ranges.clear();
 101   StatisticsRecorder::GetBucketRanges(&registered_ranges);
 102   ASSERT_EQ(2u, registered_ranges.size());
 103   // Make sure the ranges is still the one we know.
 104   ASSERT_EQ(3u, ranges1->size());
 105   EXPECT_EQ(0, ranges1->range(0));
 106   EXPECT_EQ(0, ranges1->range(1));
 107   EXPECT_EQ(0, ranges1->range(2));
 108
 109   // Register ranges with same values.
 110   BucketRanges* ranges3 = new BucketRanges(3);;
 111   ranges3->ResetChecksum();
 112   EXPECT_EQ(ranges1,  // returning ranges1
 113             StatisticsRecorder::RegisterOrDeleteDuplicateRanges(ranges3));
 114   registered_ranges.clear();
 115   StatisticsRecorder::GetBucketRanges(&registered_ranges);
 116   ASSERT_EQ(2u, registered_ranges.size());
 117 }
 118
 119 TEST_F(StatisticsRecorderTest, RegisterHistogram) {
 120   // Create a Histogram that was not registered.
 121   Histogram* histogram = CreateHistogram("TestHistogram", 1, 1000, 10);
 122
 123   StatisticsRecorder::Histograms registered_histograms;
 124   StatisticsRecorder::GetHistograms(&registered_histograms);
 125   EXPECT_EQ(0u, registered_histograms.size());
 126
 127   // Register the Histogram.
 128   EXPECT_EQ(histogram,
 129             StatisticsRecorder::RegisterOrDeleteDuplicate(histogram));
 130   StatisticsRecorder::GetHistograms(&registered_histograms);
 131   EXPECT_EQ(1u, registered_histograms.size());
 132
 133   // Register the same Histogram again.
 134   EXPECT_EQ(histogram,
 135             StatisticsRecorder::RegisterOrDeleteDuplicate(histogram));
 136   registered_histograms.clear();
 137   StatisticsRecorder::GetHistograms(&registered_histograms);
 138   EXPECT_EQ(1u, registered_histograms.size());
 139 }
 140
 141 TEST_F(StatisticsRecorderTest, FindHistogram) {
 142   HistogramBase* histogram1 = Histogram::FactoryGet(
 143       "TestHistogram1", 1, 1000, 10, HistogramBase::kNoFlags);
 144   HistogramBase* histogram2 = Histogram::FactoryGet(
 145       "TestHistogram2", 1, 1000, 10, HistogramBase::kNoFlags);
 146
 147   EXPECT_EQ(histogram1, StatisticsRecorder::FindHistogram("TestHistogram1"));
 148   EXPECT_EQ(histogram2, StatisticsRecorder::FindHistogram("TestHistogram2"));
 149   EXPECT_TRUE(StatisticsRecorder::FindHistogram("TestHistogram") == NULL);
 150 }
 151
 152 TEST_F(StatisticsRecorderTest, GetSnapshot) {
 153   Histogram::FactoryGet("TestHistogram1", 1, 1000, 10, Histogram::kNoFlags);
 154   Histogram::FactoryGet("TestHistogram2", 1, 1000, 10, Histogram::kNoFlags);
 155   Histogram::FactoryGet("TestHistogram3", 1, 1000, 10, Histogram::kNoFlags);
 156
 157   StatisticsRecorder::Histograms snapshot;
 158   StatisticsRecorder::GetSnapshot("Test", &snapshot);
 159   EXPECT_EQ(3u, snapshot.size());
 160
 161   snapshot.clear();
 162   StatisticsRecorder::GetSnapshot("1", &snapshot);
 163   EXPECT_EQ(1u, snapshot.size());
 164
 165   snapshot.clear();
 166   StatisticsRecorder::GetSnapshot("hello", &snapshot);
 167   EXPECT_EQ(0u, snapshot.size());
 168 }
 169
 170 TEST_F(StatisticsRecorderTest, RegisterHistogramWithFactoryGet) {
 171   StatisticsRecorder::Histograms registered_histograms;
 172
 173   StatisticsRecorder::GetHistograms(&registered_histograms);
 174   ASSERT_EQ(0u, registered_histograms.size());
 175
 176   // Create a histogram.
 177   HistogramBase* histogram = Histogram::FactoryGet(
 178       "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
 179   registered_histograms.clear();
 180   StatisticsRecorder::GetHistograms(&registered_histograms);
 181   EXPECT_EQ(1u, registered_histograms.size());
 182
 183   // Get an existing histogram.
 184   HistogramBase* histogram2 = Histogram::FactoryGet(
 185       "TestHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
 186   registered_histograms.clear();
 187   StatisticsRecorder::GetHistograms(&registered_histograms);
 188   EXPECT_EQ(1u, registered_histograms.size());
 189   EXPECT_EQ(histogram, histogram2);
 190
 191   // Create a LinearHistogram.
 192   histogram = LinearHistogram::FactoryGet(
 193       "TestLinearHistogram", 1, 1000, 10, HistogramBase::kNoFlags);
 194   registered_histograms.clear();
 195   StatisticsRecorder::GetHistograms(&registered_histograms);
 196   EXPECT_EQ(2u, registered_histograms.size());
 197
 198   // Create a BooleanHistogram.
 199   histogram = BooleanHistogram::FactoryGet(
 200       "TestBooleanHistogram", HistogramBase::kNoFlags);
 201   registered_histograms.clear();
 202   StatisticsRecorder::GetHistograms(&registered_histograms);
 203   EXPECT_EQ(3u, registered_histograms.size());
 204
 205   // Create a CustomHistogram.
 206   std::vector<int> custom_ranges;
 207   custom_ranges.push_back(1);
 208   custom_ranges.push_back(5);
 209   histogram = CustomHistogram::FactoryGet(
 210       "TestCustomHistogram", custom_ranges, HistogramBase::kNoFlags);
 211   registered_histograms.clear();
 212   StatisticsRecorder::GetHistograms(&registered_histograms);
 213   EXPECT_EQ(4u, registered_histograms.size());
 214 }
 215
 216 TEST_F(StatisticsRecorderTest, RegisterHistogramWithMacros) {
 217   StatisticsRecorder::Histograms registered_histograms;
 218
 219   HistogramBase* histogram = Histogram::FactoryGet(
 220       "TestHistogramCounts", 1, 1000000, 50, HistogramBase::kNoFlags);
 221
 222   // The histogram we got from macro is the same as from FactoryGet.
 223   HISTOGRAM_COUNTS("TestHistogramCounts", 30);
 224   registered_histograms.clear();
 225   StatisticsRecorder::GetHistograms(&registered_histograms);
 226   ASSERT_EQ(1u, registered_histograms.size());
 227   EXPECT_EQ(histogram, registered_histograms[0]);
 228
 229   HISTOGRAM_TIMES("TestHistogramTimes", TimeDelta::FromDays(1));
 230   HISTOGRAM_ENUMERATION("TestHistogramEnumeration", 20, 200);
 231
 232   registered_histograms.clear();
 233   StatisticsRecorder::GetHistograms(&registered_histograms);
 234   EXPECT_EQ(3u, registered_histograms.size());
 235
 236   // Debugging only macros.
 237   DHISTOGRAM_TIMES("TestHistogramDebugTimes", TimeDelta::FromDays(1));
 238   DHISTOGRAM_COUNTS("TestHistogramDebugCounts", 30);
 239   registered_histograms.clear();
 240   StatisticsRecorder::GetHistograms(&registered_histograms);
 241 #ifndef NDEBUG
 242   EXPECT_EQ(5u, registered_histograms.size());
 243 #else
 244   EXPECT_EQ(3u, registered_histograms.size());
 245 #endif
 246 }
 247
 248 TEST_F(StatisticsRecorderTest, BucketRangesSharing) {
 249   std::vector<const BucketRanges*> ranges;
 250   StatisticsRecorder::GetBucketRanges(&ranges);
 251   EXPECT_EQ(0u, ranges.size());
 252
 253   Histogram::FactoryGet("Histogram", 1, 64, 8, HistogramBase::kNoFlags);
 254   Histogram::FactoryGet("Histogram2", 1, 64, 8, HistogramBase::kNoFlags);
 255
 256   StatisticsRecorder::GetBucketRanges(&ranges);
 257   EXPECT_EQ(1u, ranges.size());
 258
 259   Histogram::FactoryGet("Histogram3", 1, 64, 16, HistogramBase::kNoFlags);
 260
 261   ranges.clear();
 262   StatisticsRecorder::GetBucketRanges(&ranges);
 263   EXPECT_EQ(2u, ranges.size());
 264 }
 265
 266 }  // namespace base