metrics: Add guest mode detection to metrics library and client

metrics_library_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 <cstring>
 
 #include <base/file_util.h>
 #include <gtest/gtest.h>
 
 #include "c_metrics_library.h"
 #include "metrics_library.h"
 
 static const FilePath kTestUMAEventsFile("test-uma-events");
-
 static const char kTestConsent[] = "test-consent";
+static const char kTestMounts[] = "test-mounts";
 
 static void SetMetricsEnabled(bool enabled) {
   if (enabled)
     ASSERT_EQ(1, file_util::WriteFile(FilePath(kTestConsent) , "0", 1));
   else
     file_util::Delete(FilePath(kTestConsent), false);
 }
 
 class MetricsLibraryTest : public testing::Test {
  protected:
   virtual void SetUp() {
     EXPECT_EQ(NULL, lib_.uma_events_file_);
     lib_.Init();
     EXPECT_TRUE(NULL != lib_.uma_events_file_);
     lib_.uma_events_file_ = kTestUMAEventsFile.value().c_str();
     SetMetricsEnabled(true);
     // Defeat metrics enabled caching between tests.
     lib_.cached_enabled_time_ = 0;
     lib_.consent_file_ = kTestConsent;
   }
 
   virtual void TearDown() {
+    file_util::Delete(FilePath(kTestConsent), false);
+    file_util::Delete(FilePath(kTestMounts), false);
     file_util::Delete(kTestUMAEventsFile, false);
   }
 
   void VerifyEnabledCacheHit(bool to_value);
   void VerifyEnabledCacheEviction(bool to_value);
 
   MetricsLibrary lib_;
 };
 
+TEST_F(MetricsLibraryTest, IsDeviceMounted) {
+  static const char kTestContents[] =
+      "0123456789abcde 0123456789abcde\nguestfs foo bar\n";
+  char buffer[1024];
+  int block_sizes[] = { 1, 2, 3, 4, 5, 6, 8, 12, 14, 16, 32, 1024 };
+  bool result;
+  EXPECT_FALSE(lib_.IsDeviceMounted("guestfs",
+                                    "nonexistent",
+                                    buffer,
+                                    1,
+                                    &result));
+  ASSERT_TRUE(file_util::WriteFile(FilePath(kTestMounts),
+                                   kTestContents,
+                                   strlen(kTestContents)));
+  EXPECT_FALSE(lib_.IsDeviceMounted("guestfs",
+                                    kTestMounts,
+                                    buffer,
+                                    0,
+                                    &result));
+  for (size_t i = 0; i < arraysize(block_sizes); ++i) {
+    EXPECT_TRUE(lib_.IsDeviceMounted("0123456789abcde",
+                                     kTestMounts,
+                                     buffer,
+                                     block_sizes[i],
+                                     &result));
+    EXPECT_TRUE(result);
+    EXPECT_TRUE(lib_.IsDeviceMounted("guestfs",
+                                     kTestMounts,
+                                     buffer,
+                                     block_sizes[i],
+                                     &result));
+    EXPECT_TRUE(result);
+    EXPECT_TRUE(lib_.IsDeviceMounted("0123456",
+                                     kTestMounts,
+                                     buffer,
+                                     block_sizes[i],
+                                     &result));
+    EXPECT_FALSE(result);
+    EXPECT_TRUE(lib_.IsDeviceMounted("9abcde",
+                                     kTestMounts,
+                                     buffer,
+                                     block_sizes[i],
+                                     &result));
+    EXPECT_FALSE(result);
+    EXPECT_TRUE(lib_.IsDeviceMounted("foo",
+                                     kTestMounts,
+                                     buffer,
+                                     block_sizes[i],
+                                     &result));
+    EXPECT_FALSE(result);
+    EXPECT_TRUE(lib_.IsDeviceMounted("bar",
+                                     kTestMounts,
+                                     buffer,
+                                     block_sizes[i],
+                                     &result));
+    EXPECT_FALSE(result);
+  }
+}
+
 TEST_F(MetricsLibraryTest, AreMetricsEnabledFalse) {
   SetMetricsEnabled(false);
   EXPECT_FALSE(lib_.AreMetricsEnabled());
 }
 
 TEST_F(MetricsLibraryTest, AreMetricsEnabledTrue) {
   EXPECT_TRUE(lib_.AreMetricsEnabled());
 }
 
 void MetricsLibraryTest::VerifyEnabledCacheHit(bool to_value) {
@@ skipping 147 matching lines @@
 
   char exp[kLen];
   sprintf(exp, "%c%c%c%chistogram%cTest.Metric 2 1 100 50", kLen, 0, 0, 0, 0);
   EXPECT_EQ(0, memcmp(exp, buf, kLen));
 }
 
 int main(int argc, char** argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }