Collect some disk statistics.

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 <utime.h>
 
 #include <string>
 #include <vector>
 
 #include <base/file_util.h>
@@ skipping 14 matching lines @@
 using std::vector;
 using ::testing::_;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 static const int kSecondsPerDay = 24 * 60 * 60;
 
 static const char kTestDir[] = "test";
 static const char kLastFile[] = "test/last";
 static const char kCurrentFile[] = "test/current";
+static const char kFakeDiskStatsPath[] = "fake-disk-stats";
+
+#define READ_SECTORS_0 80000

[petkov, 2011/02/12 05:34:45]

no #define per style :/ you may need to use StringPrintf or something...

[Luigi Semenzato, 2011/02/14 18:43:43]

Yes.  Too bad that #defines are the only way to statically convert a number to a
string in C.

+#define READ_SECTORS_1 100000
+
+#define WRITE_SECTORS_0 3000
+#define WRITE_SECTORS_1 4000
+
+#define string(x) string_(x)
+#define string_(x) #x
+
+static const char* kFakeDiskStats[] = {
+  "    1793     1788    " string(READ_SECTORS_0) "   105580   "
+  "    196      175     " string(WRITE_SECTORS_0) "    30290    "
+  "    0    44060   135850\n",
+  "    1793     1788    " string(READ_SECTORS_1) "   105580   "
+  "    196      175     " string(WRITE_SECTORS_1) "    30290    "
+  "    0    44060   135850\n",
+};
+
+static const int kFakeReadSectors[] = { READ_SECTORS_0, READ_SECTORS_1, };
+static const int kFakeWriteSectors[] = { WRITE_SECTORS_0, WRITE_SECTORS_1, };
 
 // This class allows a TimeTicks object to be initialized with seconds
 // (rather than microseconds) through the protected TimeTicks(int64)
 // constructor.
 class TestTicks : public TimeTicks {
  public:
   TestTicks(int64 seconds)
       : TimeTicks(seconds * Time::kMicrosecondsPerSecond) {}
 };
 
 // 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_);
+    CreateFakeDiskStatsFile(kFakeDiskStatsPath, kFakeDiskStats[0]);
+    daemon_.Init(true, &metrics_lib_, kFakeDiskStatsPath);
 
     // Check configuration of a few histograms.
     FrequencyCounter* frequency_counter =
         daemon_.frequency_counters_[MetricsDaemon::kMetricAnyCrashesDailyName];
     const TaggedCounterReporter* reporter = GetReporter(frequency_counter);
     EXPECT_EQ(MetricsDaemon::kMetricAnyCrashesDailyName,
               reporter->histogram_name());
     EXPECT_EQ(chromeos_metrics::kSecondsPerDay,
               frequency_counter->cycle_duration());
     EXPECT_EQ(MetricsDaemon::kMetricCrashFrequencyMin, reporter->min());
@@ skipping 45 matching lines @@
 
     EXPECT_FALSE(daemon_.user_active_);
     EXPECT_TRUE(daemon_.user_active_last_.is_null());
     EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_);
     EXPECT_EQ(MetricsDaemon::kUnknownSessionState, daemon_.session_state_);
 
     file_util::Delete(FilePath(kTestDir), true);
     file_util::CreateDirectory(FilePath(kTestDir));
   }
 
   virtual void TearDown() {}

[petkov, 2011/02/12 05:34:45]

maybe delete the fake stats file?

[Luigi Semenzato, 2011/02/14 18:43:43]

Except that it's useful for debugging.  Is it generally recommended/acceptable
for tests to leave state around?

[petkov, 2011/02/14 19:28:32]

Don't know but from what I've seen, unit tests try to clean up after themselves.

 
   const TaggedCounterReporter*
   GetReporter(FrequencyCounter* frequency_counter) const {
     return static_cast<const TaggedCounterReporter*>(
         &frequency_counter->tagged_counter());
   }
 
   void ExpectFrequencyFlushCalls() {
     MetricsDaemon::FrequencyCounters::iterator i;
     for (i = daemon_.frequency_counters_.begin();
@@ skipping 81 matching lines @@
     }
     return msg;
   }
 
   // Deallocates the DBus message |msg| previously allocated through
   // dbus_message_new*.
   void DeleteDBusMessage(DBusMessage* msg) {
     dbus_message_unref(msg);
   }
 
-  // Get the frequency counter for the given name.
+  // Gets the frequency counter for the given name.
   FrequencyCounterMock& GetFrequencyMock(const char* histogram_name) {
     return *static_cast<FrequencyCounterMock*>(
         daemon_.frequency_counters_[histogram_name]);
   }
 
+  // Creates or overwrites an input file containing fake disk stats.
+  void CreateFakeDiskStatsFile(const char* diskstats_path,
+                               const char* fake_stats) {
+    if (unlink(diskstats_path) < 0) {
+      EXPECT_EQ(errno, ENOENT);
+    }
+    FILE* f = fopen(diskstats_path, "w");
+    EXPECT_EQ(1, fwrite(fake_stats, strlen(fake_stats), 1, f));
+    EXPECT_EQ(0, fclose(f));
+  }
+
+
   // The MetricsDaemon under test.
   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.
@@ skipping 285 matching lines @@
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(10 * kSecondsPerDay + 1000), daemon_.user_active_last_);
 }
 
 TEST_F(MetricsDaemonTest, GetHistogramPath) {
   EXPECT_EQ("/var/log/metrics/Logging.AnyCrashesDaily",
             daemon_.GetHistogramPath(
                 MetricsDaemon::kMetricAnyCrashesDailyName).value());
 }
 
+TEST_F(MetricsDaemonTest, ReportDiskStats) {
+  long int read_sectors_now, write_sectors_now;
+
+  CreateFakeDiskStatsFile(kFakeDiskStatsPath, kFakeDiskStats[1]);
+  daemon_.DiskStatsReadStats(&read_sectors_now, &write_sectors_now);
+  EXPECT_EQ(read_sectors_now, kFakeReadSectors[1]);
+  EXPECT_EQ(write_sectors_now, kFakeWriteSectors[1]);
+
+  MetricsDaemon::DiskStatsState ds_state = daemon_.diskstats_state_;
+  EXPECT_CALL(metrics_lib_, SendToUMA(_, _, _, _, _))

[petkov, 2011/02/12 05:34:45]

You could check for the actual values that get sent, right?

[Luigi Semenzato, 2011/02/14 18:43:43]

Can I?  I don't know how that EXPECT_CALL framework works.  In this case there
are two calls to SendToUMA.  Can I have two EXPECT_CALLs, each with the expected
argument values?

[petkov, 2011/02/14 19:28:32]

Yes, you can. Also, right now you're not testing any of the parsing code,
really.

+      .Times(2);
+  daemon_.DiskStatsCallback();
+  EXPECT_TRUE(ds_state != daemon_.diskstats_state_);
+}
+
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }