Collect and send kernel crash diagnostics

user_collector_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 <unistd.h>
 
 #include "base/file_util.h"
 #include "crash-reporter/system_logging_mock.h"
 #include "crash-reporter/user_collector.h"
 #include "gflags/gflags.h"
 #include "gtest/gtest.h"
 
-int s_crashes = 0;
-bool s_metrics = false;
+static int s_crashes = 0;
+static bool s_metrics = false;
 
 static const char kFilePath[] = "/my/path";
 
 void CountCrash() {
   ++s_crashes;
 }
 
 bool IsMetrics() {
   return s_metrics;
 }
@@ skipping 18 matching lines @@
   pid_t pid_;
 };
 
 TEST_F(UserCollectorTest, EnableOK) {
   std::string contents;
   ASSERT_TRUE(collector_.Enable());
   ASSERT_TRUE(file_util::ReadFileToString(FilePath("test/core_pattern"),
                                                    &contents));
   ASSERT_EQ("|/my/path --signal=%s --pid=%p", contents);
   ASSERT_EQ(s_crashes, 0);
-  ASSERT_NE(logging_.log().find("Enabling crash handling"), std::string::npos);
+  ASSERT_NE(logging_.log().find("Enabling user crash handling"),
+            std::string::npos);
 }
 
 TEST_F(UserCollectorTest, EnableNoFileAccess) {
   collector_.set_core_pattern_file("/does_not_exist");
   ASSERT_FALSE(collector_.Enable());
   ASSERT_EQ(s_crashes, 0);
-  ASSERT_NE(logging_.log().find("Enabling crash handling"), std::string::npos);
+  ASSERT_NE(logging_.log().find("Enabling user crash handling"),
+            std::string::npos);
   ASSERT_NE(logging_.log().find("Unable to write /does_not_exist"),
             std::string::npos);
 }
 
 TEST_F(UserCollectorTest, DisableOK) {
   std::string contents;
   ASSERT_TRUE(collector_.Disable());
   ASSERT_TRUE(file_util::ReadFileToString(FilePath("test/core_pattern"),
                                           &contents));
   ASSERT_EQ("core", contents);
   ASSERT_EQ(s_crashes, 0);
-  ASSERT_NE(logging_.log().find("Disabling crash handling"),
+  ASSERT_NE(logging_.log().find("Disabling user crash handling"),
             std::string::npos);
 }
 
 TEST_F(UserCollectorTest, DisableNoFileAccess) {
   collector_.set_core_pattern_file("/does_not_exist");
   ASSERT_FALSE(collector_.Disable());
   ASSERT_EQ(s_crashes, 0);
-  ASSERT_NE(logging_.log().find("Disabling crash handling"), std::string::npos);
+  ASSERT_NE(logging_.log().find("Disabling user crash handling"),
+            std::string::npos);
   ASSERT_NE(logging_.log().find("Unable to write /does_not_exist"),
             std::string::npos);
 }
 
 TEST_F(UserCollectorTest, HandleCrashWithoutMetrics) {
   s_metrics = false;
   collector_.HandleCrash(10, 20, "foobar");
   ASSERT_NE(logging_.log().find(
       "Received crash notification for foobar[20] sig 10"),
       std::string::npos);
@@ skipping 108 matching lines @@
 }
 
 TEST_F(UserCollectorTest, GetUserInfoFromName) {
   gid_t gid = 100;
   uid_t uid = 100;
   EXPECT_TRUE(collector_.GetUserInfoFromName("root", &uid, &gid));
   EXPECT_EQ(0, uid);
   EXPECT_EQ(0, gid);
 }
 
-TEST_F(UserCollectorTest, GetCrashDirectoryInfo) {
-  FilePath path;
-  const int kRootUid = 0;
-  const int kRootGid = 0;
-  const int kNtpUid = 5;
-  const int kChronosUid = 1000;
-  const int kChronosGid = 1001;
-  const mode_t kExpectedSystemMode = 01755;
-  const mode_t kExpectedUserMode = 0755;
-
-  mode_t directory_mode;
-  uid_t directory_owner;
-  gid_t directory_group;
-
-  path = collector_.GetCrashDirectoryInfo(kRootUid,
-                                          kChronosUid,
-                                          kChronosGid,
-                                          &directory_mode,
-                                          &directory_owner,
-                                          &directory_group);
-  EXPECT_EQ("/var/spool/crash", path.value());
-  EXPECT_EQ(kExpectedSystemMode, directory_mode);
-  EXPECT_EQ(kRootUid, directory_owner);
-  EXPECT_EQ(kRootGid, directory_group);
-
-  path = collector_.GetCrashDirectoryInfo(kNtpUid,
-                                          kChronosUid,
-                                          kChronosGid,
-                                          &directory_mode,
-                                          &directory_owner,
-                                          &directory_group);
-  EXPECT_EQ("/var/spool/crash", path.value());
-  EXPECT_EQ(kExpectedSystemMode, directory_mode);
-  EXPECT_EQ(kRootUid, directory_owner);
-  EXPECT_EQ(kRootGid, directory_group);
-
-  path = collector_.GetCrashDirectoryInfo(kChronosUid,
-                                          kChronosUid,
-                                          kChronosGid,
-                                          &directory_mode,
-                                          &directory_owner,
-                                          &directory_group);
-  EXPECT_EQ("/home/chronos/user/crash", path.value());
-  EXPECT_EQ(kExpectedUserMode, directory_mode);
-  EXPECT_EQ(kChronosUid, directory_owner);
-  EXPECT_EQ(kChronosGid, directory_group);
-}
-
 TEST_F(UserCollectorTest, CopyOffProcFilesBadPath) {
   // Try a path that is not writable.
   ASSERT_FALSE(collector_.CopyOffProcFiles(pid_, FilePath("/bad/path")));
   ASSERT_NE(logging_.log().find(
       "Could not create /bad/path"),
             std::string::npos);
 }
 
 TEST_F(UserCollectorTest, CopyOffProcFilesBadPid) {
   FilePath container_path("test/container");
@@ skipping 21 matching lines @@
     { "sched", false },
     { "status", true }
   };
   for (unsigned i = 0; i < sizeof(expectations)/sizeof(expectations[0]); ++i) {
     EXPECT_EQ(expectations[i].exists,
               file_util::PathExists(
                   container_path.Append(expectations[i].name)));
   }
 }
 
-TEST_F(UserCollectorTest, FormatDumpBasename) {
-  struct tm tm = {0};
-  tm.tm_sec = 15;
-  tm.tm_min = 50;
-  tm.tm_hour = 13;
-  tm.tm_mday = 23;
-  tm.tm_mon = 4;
-  tm.tm_year = 110;
-  tm.tm_isdst = -1;
-  std::string basename =
-      collector_.FormatDumpBasename("foo", mktime(&tm), 100);
-  ASSERT_EQ("foo.20100523.135015.100", basename);
-}
-
 int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }