Add # daily crashes metrics and separate kernel crashes out.

metrics_daemon_test.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <base/file_util.h>
 #include <gtest/gtest.h>
 
 #include "counter_mock.h"
 #include "metrics_daemon.h"
 #include "metrics_library_mock.h"
 
 using base::Time;
 using base::TimeTicks;
+using chromeos_metrics::FrequencyCounterMock;
 using chromeos_metrics::TaggedCounterMock;
 using ::testing::_;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 static const int kSecondsPerDay = 24 * 60 * 60;
 
 // This class allows a TimeTicks object to be initialized with seconds
 // (rather than microseconds) through the protected TimeTicks(int64)
 // constructor.
@@ skipping 28 matching lines @@
     EXPECT_TRUE(NULL != daemon_.kernel_crash_interval_.get());
     EXPECT_TRUE(NULL != daemon_.user_crash_interval_.get());
 
     // Allocates mock counter and transfers ownership.
     daily_use_ = new StrictMock<TaggedCounterMock>();
     daemon_.daily_use_.reset(daily_use_);
     kernel_crash_interval_ = new StrictMock<TaggedCounterMock>();
     daemon_.kernel_crash_interval_.reset(kernel_crash_interval_);
     user_crash_interval_ = new StrictMock<TaggedCounterMock>();
     daemon_.user_crash_interval_.reset(user_crash_interval_);
+    unclean_shutdown_interval_ = new StrictMock<TaggedCounterMock>();
+    daemon_.unclean_shutdown_interval_.reset(unclean_shutdown_interval_);
+    kernel_crashes_daily_ = new StrictMock<FrequencyCounterMock>();
+    daemon_.kernel_crashes_daily_.reset(kernel_crashes_daily_);
+    user_crashes_daily_ = new StrictMock<FrequencyCounterMock>();
+    daemon_.user_crashes_daily_.reset(user_crashes_daily_);
+    unclean_shutdowns_daily_ = new StrictMock<FrequencyCounterMock>();
+    daemon_.unclean_shutdowns_daily_.reset(unclean_shutdowns_daily_);
+    any_crashes_daily_ = new StrictMock<FrequencyCounterMock>();
+    daemon_.any_crashes_daily_.reset(any_crashes_daily_);
 
     EXPECT_FALSE(daemon_.user_active_);
     EXPECT_TRUE(daemon_.user_active_last_.is_null());
     EXPECT_EQ(MetricsDaemon::kUnknownNetworkState, daemon_.network_state_);
     EXPECT_TRUE(daemon_.network_state_last_.is_null());
     EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_);
     EXPECT_EQ(MetricsDaemon::kUnknownSessionState, daemon_.session_state_);
   }
 
   virtual void TearDown() {}
@@ skipping 93 matching lines @@
   // Metrics library mock. It's a strict mock so that all unexpected
   // metric generation calls are marked as failures.
   StrictMock<MetricsLibraryMock> metrics_lib_;
 
   // Counter mocks. They are strict mocks so that all unexpected
   // update calls are marked as failures. They are pointers so that
   // they can replace the scoped_ptr's allocated by the daemon.
   StrictMock<TaggedCounterMock>* daily_use_;
   StrictMock<TaggedCounterMock>* kernel_crash_interval_;
   StrictMock<TaggedCounterMock>* user_crash_interval_;
+  StrictMock<TaggedCounterMock>* unclean_shutdown_interval_;
+
+  StrictMock<FrequencyCounterMock>* kernel_crashes_daily_;
+  StrictMock<FrequencyCounterMock>* user_crashes_daily_;
+  StrictMock<FrequencyCounterMock>* unclean_shutdowns_daily_;
+  StrictMock<FrequencyCounterMock>* any_crashes_daily_;
 };
 
-TEST_F(MetricsDaemonTest, CheckKernelCrash) {
+TEST_F(MetricsDaemonTest, CheckSystemCrash) {
   static const char kKernelCrashDetected[] = "test-kernel-crash-detected";
-  daemon_.CheckKernelCrash(kKernelCrashDetected);
+  EXPECT_FALSE(daemon_.CheckSystemCrash(kKernelCrashDetected));
 
   FilePath crash_detected(kKernelCrashDetected);
   file_util::WriteFile(crash_detected, "", 0);
-  IgnoreActiveUseUpdate();
-  EXPECT_CALL(*kernel_crash_interval_, Flush())
-      .Times(1)
-      .RetiresOnSaturation();
-  daemon_.CheckKernelCrash(kKernelCrashDetected);
+  EXPECT_TRUE(file_util::PathExists(crash_detected));
+  EXPECT_TRUE(daemon_.CheckSystemCrash(kKernelCrashDetected));
+  EXPECT_FALSE(file_util::PathExists(crash_detected));
+  EXPECT_FALSE(daemon_.CheckSystemCrash(kKernelCrashDetected));
+  EXPECT_FALSE(file_util::PathExists(crash_detected));
   file_util::Delete(crash_detected, false);
 }
 
-TEST_F(MetricsDaemonTest, DailyUseReporter) {
+TEST_F(MetricsDaemonTest, ReportDailyUse) {
   ExpectDailyUseTimeMetric(/* sample */ 2);
-  MetricsDaemon::DailyUseReporter(&daemon_, /* tag */ 20, /* count */ 90);
+  MetricsDaemon::ReportDailyUse(&daemon_, /* tag */ 20, /* count */ 90);
 
   ExpectDailyUseTimeMetric(/* sample */ 1);
-  MetricsDaemon::DailyUseReporter(&daemon_, /* tag */ 23, /* count */ 89);
+  MetricsDaemon::ReportDailyUse(&daemon_, /* tag */ 23, /* count */ 89);
 
   // There should be no metrics generated for the calls below.
-  MetricsDaemon::DailyUseReporter(&daemon_, /* tag */ 50, /* count */ 0);
-  MetricsDaemon::DailyUseReporter(&daemon_, /* tag */ 60, /* count */ -5);
+  MetricsDaemon::ReportDailyUse(&daemon_, /* tag */ 50, /* count */ 0);
+  MetricsDaemon::ReportDailyUse(&daemon_, /* tag */ 60, /* count */ -5);
 }
 
-TEST_F(MetricsDaemonTest, KernelCrashIntervalReporter) {
+TEST_F(MetricsDaemonTest, ReportKernelCrashInterval) {
   ExpectMetric(MetricsDaemon::kMetricKernelCrashIntervalName, 50,
-               MetricsDaemon::kMetricKernelCrashIntervalMin,
-               MetricsDaemon::kMetricKernelCrashIntervalMax,
-               MetricsDaemon::kMetricKernelCrashIntervalBuckets);
-  MetricsDaemon::KernelCrashIntervalReporter(&daemon_, 0, 50);
+               MetricsDaemon::kMetricCrashIntervalMin,
+               MetricsDaemon::kMetricCrashIntervalMax,
+               MetricsDaemon::kMetricCrashIntervalBuckets);
+  MetricsDaemon::ReportKernelCrashInterval(&daemon_, 0, 50);
+}
+
+TEST_F(MetricsDaemonTest, ReportUncleanShutdownInterval) {
+  ExpectMetric(MetricsDaemon::kMetricUncleanShutdownIntervalName, 50,
+               MetricsDaemon::kMetricCrashIntervalMin,
+               MetricsDaemon::kMetricCrashIntervalMax,
+               MetricsDaemon::kMetricCrashIntervalBuckets);
+  MetricsDaemon::ReportUncleanShutdownInterval(&daemon_, 0, 50);
 }
 
 TEST_F(MetricsDaemonTest, LookupNetworkState) {
   EXPECT_EQ(MetricsDaemon::kNetworkStateOnline,
             daemon_.LookupNetworkState("online"));
   EXPECT_EQ(MetricsDaemon::kNetworkStateOffline,
             daemon_.LookupNetworkState("offline"));
   EXPECT_EQ(MetricsDaemon::kUnknownNetworkState,
             daemon_.LookupNetworkState("somestate"));
 }
@@ skipping 20 matching lines @@
   DBusMessage* msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
   DBusHandlerResult res =
       MetricsDaemon::MessageFilter(/* connection */ NULL, msg, &daemon_);
   EXPECT_EQ(DBUS_HANDLER_RESULT_NOT_YET_HANDLED, res);
   DeleteDBusMessage(msg);
 
   IgnoreActiveUseUpdate();
   EXPECT_CALL(*user_crash_interval_, Flush())
       .Times(1)
       .RetiresOnSaturation();
+  EXPECT_CALL(*user_crashes_daily_, Update(1))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*any_crashes_daily_, Update(1))
+      .Times(1)
+      .RetiresOnSaturation();
   msg = NewDBusSignalString("/",
                             "org.chromium.CrashReporter",
                             "UserCrash",
                             "");
   res = MetricsDaemon::MessageFilter(/* connection */ NULL, msg, &daemon_);
   EXPECT_EQ(DBUS_HANDLER_RESULT_HANDLED, res);
   DeleteDBusMessage(msg);
 
   msg = NewDBusSignalString("/",
                             "org.chromium.flimflam.Manager",
@@ skipping 113 matching lines @@
   EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_);
   EXPECT_FALSE(daemon_.user_active_);
   EXPECT_EQ(TestTime(7 * kSecondsPerDay + 185), daemon_.user_active_last_);
 }
 
 TEST_F(MetricsDaemonTest, ProcessKernelCrash) {
   IgnoreActiveUseUpdate();
   EXPECT_CALL(*kernel_crash_interval_, Flush())
       .Times(1)
       .RetiresOnSaturation();
+  EXPECT_CALL(*kernel_crashes_daily_, Update(1));
+  EXPECT_CALL(*any_crashes_daily_, Update(1));
   daemon_.ProcessKernelCrash();
 }
 
+TEST_F(MetricsDaemonTest, ProcessUncleanShutdown) {
+  IgnoreActiveUseUpdate();
+  EXPECT_CALL(*unclean_shutdown_interval_, Flush())
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*unclean_shutdowns_daily_, Update(1));
+  EXPECT_CALL(*any_crashes_daily_, Update(1));
+  daemon_.ProcessUncleanShutdown();
+}
+
 TEST_F(MetricsDaemonTest, ProcessUserCrash) {
   IgnoreActiveUseUpdate();
   EXPECT_CALL(*user_crash_interval_, Flush())
       .Times(1)
       .RetiresOnSaturation();
+  EXPECT_CALL(*user_crashes_daily_, Update(1));
+  EXPECT_CALL(*any_crashes_daily_, Update(1));
   daemon_.ProcessUserCrash();
 }
 
 TEST_F(MetricsDaemonTest, SendMetric) {
   ExpectMetric("Dummy.Metric", 3, 1, 100, 50);
   daemon_.SendMetric("Dummy.Metric", /* sample */ 3,
                      /* min */ 1, /* max */ 100, /* buckets */ 50);
 }
 
 TEST_F(MetricsDaemonTest, SessionStateChanged) {
@@ skipping 62 matching lines @@
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(10 * kSecondsPerDay + 300), daemon_.user_active_last_);
 
   ExpectActiveUseUpdate(10, 0);
   daemon_.SetUserActiveState(/* active */ true,
                              TestTime(10 * kSecondsPerDay + 1000));
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(10 * kSecondsPerDay + 1000), daemon_.user_active_last_);
 }
 
-TEST_F(MetricsDaemonTest, UserCrashIntervalReporter) {
+TEST_F(MetricsDaemonTest, ReportUserCrashInterval) {
   ExpectMetric(MetricsDaemon::kMetricUserCrashIntervalName, 50,
-               MetricsDaemon::kMetricUserCrashIntervalMin,
-               MetricsDaemon::kMetricUserCrashIntervalMax,
-               MetricsDaemon::kMetricUserCrashIntervalBuckets);
-  MetricsDaemon::UserCrashIntervalReporter(&daemon_, 0, 50);
+               MetricsDaemon::kMetricCrashIntervalMin,
+               MetricsDaemon::kMetricCrashIntervalMax,
+               MetricsDaemon::kMetricCrashIntervalBuckets);
+  MetricsDaemon::ReportUserCrashInterval(&daemon_, 0, 50);
+}
+
+TEST_F(MetricsDaemonTest, ReportCrashesDailyFrequency) {
+  ExpectMetric("foobar", 50,
+               MetricsDaemon::kMetricCrashesDailyMin,
+               MetricsDaemon::kMetricCrashesDailyMax,
+               MetricsDaemon::kMetricCrashesDailyBuckets);
+  MetricsDaemon::ReportCrashesDailyFrequency("foobar", &daemon_, 50);
 }
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }