Log active use time between kernel crashes.

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::TaggedCounterMock;
 using ::testing::_;
@@ skipping 20 matching lines @@
 // Overloaded for test failure printing purposes.
 static std::ostream& operator<<(std::ostream& o, const Time& time) {
   o << time.ToInternalValue() << "us";
   return o;
 };
 
 class MetricsDaemonTest : public testing::Test {
  protected:
   virtual void SetUp() {
     EXPECT_EQ(NULL, daemon_.daily_use_.get());
+    EXPECT_EQ(NULL, daemon_.kernel_crash_interval_.get());
     EXPECT_EQ(NULL, daemon_.user_crash_interval_.get());
     daemon_.Init(true, &metrics_lib_);
 
     // Tests constructor initialization. Switches to mock counters.
     EXPECT_TRUE(NULL != daemon_.daily_use_.get());
+    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_);
 
     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() {}
 
   // Adds active use aggregation counters update expectations that the
   // specified tag/count update will be generated.
   void ExpectActiveUseUpdate(int daily_tag, int count) {
     EXPECT_CALL(*daily_use_, Update(daily_tag, count))
         .Times(1)
         .RetiresOnSaturation();
+    EXPECT_CALL(*kernel_crash_interval_, Update(0, count))
+        .Times(1)
+        .RetiresOnSaturation();
     EXPECT_CALL(*user_crash_interval_, Update(0, count))
         .Times(1)
         .RetiresOnSaturation();
   }
 
   // Adds active use aggregation counters update expectations that
   // ignore the update arguments.
   void IgnoreActiveUseUpdate() {
     EXPECT_CALL(*daily_use_, Update(_, _))
         .Times(1)
         .RetiresOnSaturation();
+    EXPECT_CALL(*kernel_crash_interval_, Update(_, _))
+        .Times(1)
+        .RetiresOnSaturation();
     EXPECT_CALL(*user_crash_interval_, Update(_, _))
         .Times(1)
         .RetiresOnSaturation();
   }
 
   // Adds a metrics library mock expectation that the specified metric
   // will be generated.
   void ExpectMetric(const std::string& name, int sample,
                     int min, int max, int buckets) {
     EXPECT_CALL(metrics_lib_, SendToUMA(name, sample, min, max, buckets))
@@ skipping 57 matching lines @@
   MetricsDaemon daemon_;
 
   // 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_;
 };
 
+TEST_F(MetricsDaemonTest, CheckKernelCrash) {
+  static const char kKernelCrashDetected[] = "test-kernel-crash-detected";
+  daemon_.CheckKernelCrash(kKernelCrashDetected);
+
+  FilePath crash_detected(kKernelCrashDetected);
+  file_util::WriteFile(crash_detected, "", 0);
+  IgnoreActiveUseUpdate();
+  EXPECT_CALL(*kernel_crash_interval_, Flush())
+      .Times(1)
+      .RetiresOnSaturation();
+  daemon_.CheckKernelCrash(kKernelCrashDetected);
+  file_util::Delete(crash_detected, false);
+}
+
 TEST_F(MetricsDaemonTest, DailyUseReporter) {
   ExpectDailyUseTimeMetric(/* sample */ 2);
   MetricsDaemon::DailyUseReporter(&daemon_, /* tag */ 20, /* count */ 90);
 
   ExpectDailyUseTimeMetric(/* sample */ 1);
   MetricsDaemon::DailyUseReporter(&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);
 }
 
+TEST_F(MetricsDaemonTest, KernelCrashIntervalReporter) {
+  ExpectMetric(MetricsDaemon::kMetricKernelCrashIntervalName, 50,
+               MetricsDaemon::kMetricKernelCrashIntervalMin,
+               MetricsDaemon::kMetricKernelCrashIntervalMax,
+               MetricsDaemon::kMetricKernelCrashIntervalBuckets);
+  MetricsDaemon::KernelCrashIntervalReporter(&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"));
 }
 
 TEST_F(MetricsDaemonTest, LookupPowerState) {
@@ skipping 146 matching lines @@
   EXPECT_FALSE(daemon_.user_active_);
   EXPECT_EQ(TestTime(7 * kSecondsPerDay + 45), daemon_.user_active_last_);
 
   ExpectActiveUseUpdate(7, 0);
   daemon_.PowerStateChanged("otherstate", TestTime(7 * kSecondsPerDay + 185));
   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();
+  daemon_.ProcessKernelCrash();
+}
+
 TEST_F(MetricsDaemonTest, ProcessUserCrash) {
   IgnoreActiveUseUpdate();
   EXPECT_CALL(*user_crash_interval_, Flush())
       .Times(1)
       .RetiresOnSaturation();
   daemon_.ProcessUserCrash();
 }
 
 TEST_F(MetricsDaemonTest, SendMetric) {
   ExpectMetric("Dummy.Metric", 3, 1, 100, 50);
@@ skipping 79 matching lines @@
                MetricsDaemon::kMetricUserCrashIntervalMin,
                MetricsDaemon::kMetricUserCrashIntervalMax,
                MetricsDaemon::kMetricUserCrashIntervalBuckets);
   MetricsDaemon::UserCrashIntervalReporter(&daemon_, 0, 50);
 }
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }