Keep only base/extractor.[cc|h].

statsreport/metrics_unittest.cc

-// Copyright 2006-2009 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// ========================================================================
-//
-// metrics report unit testing
-#include "omaha/third_party/gtest/include/gtest/gtest.h"
-#include "metrics.h"
-#include <algorithm>
-#include <new>
-
-DECLARE_METRIC_count(count);
-DEFINE_METRIC_count(count);
-
-DECLARE_METRIC_timing(timing);
-DEFINE_METRIC_timing(timing);
-
-DECLARE_METRIC_integer(integer);
-DEFINE_METRIC_integer(integer);
-
-DECLARE_METRIC_bool(bool);
-DEFINE_METRIC_bool(bool);
-
-using namespace stats_report;
-
-namespace {
-
-class MetricsTest: public testing::Test {
-protected:
-  MetricCollection coll_;
-};
-
-class MetricsEnumTest: public MetricsTest {
-public:
-  virtual void SetUp() {
-    coll_.Initialize();
-  }
-
-  virtual void TearDown() {
-    coll_.Uninitialize();
-  }
-
-protected:
-  MetricsEnumTest(): count_("count", &coll_), timing_("timing", &coll_),
-       integer_("integer", &coll_), bool_("bool", &coll_){
-  }
-
-  CountMetric count_;
-  TimingMetric timing_;
-  IntegerMetric integer_;
-  BoolMetric bool_;
-};
-
-} // namespace
-
-// Validates that the above-declared metrics are available
-// in the expected namespace
-TEST_F(MetricsTest, Globals) {
-  EXPECT_EQ(0, ::metric_count.Reset());
-  TimingMetric::TimingData data = ::metric_timing.Reset();
-  EXPECT_EQ(0, data.count);
-  EXPECT_EQ(0, data.maximum);
-  EXPECT_EQ(0, data.minimum);
-  EXPECT_EQ(0, data.sum);
-
-  EXPECT_EQ(0, ::metric_integer.value());
-  EXPECT_EQ(BoolMetric::kBoolUnset, ::metric_bool.Reset());
-
-  // Check for correct initialization
-  EXPECT_STREQ("count", metric_count.name());
-  EXPECT_STREQ("timing", metric_timing.name());
-  EXPECT_STREQ("integer", metric_integer.name());
-  EXPECT_STREQ("bool", metric_bool.name());
-}
-
-
-// make GTest happy
-inline std::ostream &operator << (std::ostream &str, const MetricIterator &it) {
-  str << std::hex << (void*)*it;
-  return str;
-}
-
-TEST_F(MetricsTest, CollectionInitialization) {
-  // The global MetricCollection is aliased to zero memory so as to ensure
-  // no initialization order snafus. If an initialized MetricCollection
-  // sets any of its storage to non-zero, there's a good chance that e.g. a
-  // vtbl has snuck in there, which must not happen
-  char buf1[sizeof(MetricCollection)] = { 0 };
-  char buf2[sizeof(MetricCollection)] = { 0 };
-
-  // Placement new a MetricCollection to one of the buffers
-  new (buf1) MetricCollection();
-
-  // and check they're still equivalent
-  EXPECT_EQ(0, memcmp(buf1, buf2, sizeof(MetricCollection)));
-
-  // MetricCollection must not extend MetricCollectionBase in size
-  EXPECT_EQ(sizeof(MetricCollection), sizeof(MetricCollectionBase));
-}
-
-TEST_F(MetricsTest, Count) {
-  CountMetric foo("foo", &coll_);
-
-  EXPECT_EQ(0, foo.Reset());
-  EXPECT_EQ(kCountType, foo.type());
-  CountMetric &foo_ref = foo.AsCount();
-
-  ++foo;
-  EXPECT_EQ(1, foo.value());
-  foo++;
-  EXPECT_EQ(2, foo.value());
-
-  foo += 100;
-  EXPECT_EQ(102, foo.value());
-}
-
-TEST_F(MetricsTest, Timing) {
-  TimingMetric foo("foo", &coll_);
-
-  EXPECT_EQ(kTimingType, foo.type());
-  TimingMetric &foo_ref = foo.AsTiming();
-
-  foo.AddSample(100);
-  foo.AddSample(50);
-
-  EXPECT_EQ(2, foo.count());
-  EXPECT_EQ(150, foo.sum());
-  EXPECT_EQ(100, foo.maximum());
-  EXPECT_EQ(50, foo.minimum());
-  EXPECT_EQ(75, foo.average());
-
-  TimingMetric::TimingData data = foo.Reset();
-  EXPECT_EQ(2, data.count);
-  EXPECT_EQ(150, data.sum);
-  EXPECT_EQ(100, data.maximum);
-  EXPECT_EQ(50, data.minimum);
-
-  EXPECT_EQ(0, foo.count());
-  EXPECT_EQ(0, foo.sum());
-  EXPECT_EQ(0, foo.maximum());
-  EXPECT_EQ(0, foo.minimum());
-  EXPECT_EQ(0, foo.average());
-
-  // Test counted samples
-  foo.AddSamples(10, 1000);
-  foo.AddSamples(10, 500);
-  EXPECT_EQ(20, foo.count());
-  EXPECT_EQ(1500, foo.sum());
-  EXPECT_EQ(100, foo.maximum());
-  EXPECT_EQ(50, foo.minimum());
-  EXPECT_EQ(75, foo.average());
-}
-
-TEST_F(MetricsTest, TimingSample) {
-  TimingMetric foo("foo", &coll_);
-
-  // add a sample to foo
-  {
-    TimingSample sample(foo);
-
-    ::Sleep(30);
-  }
-
-  TimingMetric::TimingData data = foo.Reset();
-
-  // Should be precisely one sample in there
-  EXPECT_EQ(1, data.count);
-
-  // Let's hope the scheduler doesn't leave us hanging more than 10 ms.
-  // Increased time from 40 to 100 because test failed intermittently on Pulse.
-  EXPECT_GE(30 + 70, data.sum);
-  // The sleep above seems to often terminate early on the build server,
-  // I've observed captured times down to 18 ms, which is strange.
-  // TODO(omaha): figure out whether the timer is broken or whether
-  //    sleep is breaking its promise, or whether e.g. we're getting different
-  //    walltimes on different CPUs due to BIOS bugs on the build server
-  EXPECT_LE(14, data.sum);
-
-  // again, this time with a non-unity count
-  {
-    TimingSample sample(foo, 2);
-
-    EXPECT_EQ(2, sample.count());
-    ::Sleep(30);
-  }
-
-  data = foo.Reset();
-
-  // Should be precisely two samples in there
-  EXPECT_EQ(2, data.count);
-
-  // Let's hope the scheduler doesn't leave us hanging more than 10 ms.
-  // Increased time from 40 to 100 because test failed intermittently on Pulse.
-  EXPECT_GE(30 + 70, data.sum);
-  EXPECT_LE(14, data.sum);
-
-  // now with zero count
-  {
-    TimingSample sample(foo, 0);
-  }
-
-  data = foo.Reset();
-
-  // Should be no samples in there
-  EXPECT_EQ(0, data.count);
-}
-
-TEST_F(MetricsTest, Integer) {
-  IntegerMetric foo("foo", &coll_);
-
-  EXPECT_EQ(kIntegerType, foo.type());
-  IntegerMetric &foo_ref = foo.AsInteger();
-
-  EXPECT_EQ(0, foo.value());
-  foo.Set(1005);
-  EXPECT_EQ(1005, foo.value());
-  foo = 1009UL;
-  EXPECT_EQ(1009, foo.value());
-
-  foo.Set(0);
-
-  ++foo;
-  EXPECT_EQ(1, foo.value());
-  foo++;
-  EXPECT_EQ(2, foo.value());
-
-  foo += 100;
-  EXPECT_EQ(102, foo.value());
-
-  foo -= 100;
-  EXPECT_EQ(2, foo.value());
-  foo--;
-  EXPECT_EQ(1, foo.value());
-  --foo;
-  EXPECT_EQ(0, foo.value());
-}
-
-TEST_F(MetricsTest, Bool) {
-  BoolMetric foo("foo", &coll_);
-
-  EXPECT_EQ(kBoolType, foo.type());
-  BoolMetric &foo_ref = foo.AsBool();
-
-  EXPECT_EQ(BoolMetric::kBoolUnset, foo.Reset());
-  foo.Set(true);
-  EXPECT_EQ(BoolMetric::kBoolTrue, foo.Reset());
-  foo.Set(false);
-  EXPECT_EQ(BoolMetric::kBoolFalse, foo.Reset());
-  EXPECT_EQ(BoolMetric::kBoolUnset, foo.Reset());
-}
-
-TEST_F(MetricsEnumTest, Enumeration) {
-  MetricBase *metrics[] = {
-        &count_,
-        &timing_,
-        &integer_,
-        &bool_,
-  };
-
-  for (int i = 0; i < sizeof(metrics) / sizeof(metrics[0]); ++i) {
-    MetricBase *stat = metrics[i];
-    MetricBase *curr = coll_.first();
-
-    for (; NULL != curr; curr = curr->next()) {
-      if (stat == curr)
-        break;
-    }
-
-    // if NULL, we didn't find our counter
-    EXPECT_TRUE(NULL != curr);
-  }
-}
-
-TEST_F(MetricsEnumTest, Iterator) {
-  typedef MetricBase *MetricBasePtr;
-  MetricBasePtr metrics[] = { &count_, &timing_, &integer_, &bool_, };
-  int num_stats = sizeof(metrics) / sizeof(metrics[0]);
-
-  MetricIterator it(coll_), end;
-  EXPECT_NE(it, end);
-
-  // copy construction
-  EXPECT_EQ(it, MetricIterator(it));
-  EXPECT_EQ(end, MetricIterator(end));
-
-  // # of iterations
-  int i = 0;
-  while (it++ != end)
-    ++i;
-  DCHECK_EQ(i, num_stats);
-  DCHECK_EQ(it, end);
-
-  // increment past end is idempotent
-  ++it;
-  DCHECK_EQ(it, end);
-
-  // Check that we return no garbage or nonsense
-  for (it = MetricIterator(coll_); it != end; ++it) {
-    MetricBasePtr *stats_end = &metrics[num_stats];
-    EXPECT_NE(stats_end, std::find(metrics, stats_end, *it));
-  }
-
-  // and that all metrics can be found
-  for (int i = 0; i < sizeof(metrics) / sizeof(metrics[0]); ++i) {
-    MetricBase *stat = metrics[i];
-
-    EXPECT_EQ(stat, *std::find(MetricIterator(coll_), end, stat));
-  }
-}
-
-TEST_F(MetricsTest, SimpleConstruction) {
-  const CountMetric c("c", 100);
-
-  EXPECT_EQ(100, c.value());
-  EXPECT_EQ(kCountType, c.type());
-  EXPECT_STREQ("c", c.name());
-  EXPECT_TRUE(NULL == c.next());
-
-  TimingMetric::TimingData data = { 10, 0, 1000, 10, 500 };
-  const TimingMetric t("t", data);
-
-  EXPECT_EQ(10, t.count());
-  EXPECT_EQ(1000, t.sum());
-  EXPECT_EQ(10, t.minimum());
-  EXPECT_EQ(500, t.maximum());
-  EXPECT_EQ(kTimingType, t.type());
-  EXPECT_STREQ("t", t.name());
-  EXPECT_TRUE(NULL == t.next());
-
-  const IntegerMetric i("i", 200);
-
-  EXPECT_EQ(200, i.value());
-  EXPECT_EQ(kIntegerType, i.type());
-  EXPECT_STREQ("i", i.name());
-  EXPECT_TRUE(NULL == i.next());
-
-  const BoolMetric bool_true("bool_true", BoolMetric::kBoolTrue);
-
-  EXPECT_EQ(BoolMetric::kBoolTrue, bool_true.value());
-  EXPECT_EQ(kBoolType, bool_true.type());
-  EXPECT_STREQ("bool_true", bool_true.name());
-  EXPECT_TRUE(NULL == bool_true.next());
-
-  const BoolMetric bool_false("bool_false", BoolMetric::kBoolFalse);
-
-  EXPECT_EQ(BoolMetric::kBoolFalse, bool_false.value());
-  EXPECT_EQ(kBoolType, bool_false.type());
-  EXPECT_STREQ("bool_false", bool_false.name());
-  EXPECT_TRUE(NULL == bool_false.next());
-}
-