crash-reporter: Use standard logging and new libchromeos Process code

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 "chromeos/syslog_logging.h"
+#include "chromeos/test_helpers.h"
 #include "crash-reporter/user_collector.h"
-#include "crash-reporter/test_helpers.h"
 #include "gflags/gflags.h"
 #include "gtest/gtest.h"
 
 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;
 }
 
 class UserCollectorTest : public ::testing::Test {
   void SetUp() {
     s_crashes = 0;
     collector_.Initialize(CountCrash,
                           kFilePath,
                           IsMetrics,
-                          &logging_,
                           false);
     file_util::Delete(FilePath("test"), true);
     mkdir("test", 0777);
     collector_.set_core_pattern_file("test/core_pattern");
     collector_.set_core_pipe_limit_file("test/core_pipe_limit");
     pid_ = getpid();
+    syslog_logging::ClearAccumulatedLog();
   }
  protected:
   void ExpectFileEquals(const char *golden,
                         const char *file_path) {
     std::string contents;
     EXPECT_TRUE(file_util::ReadFileToString(FilePath(file_path),
                                             &contents));
     EXPECT_EQ(golden, contents);
   }
 
-  SystemLoggingMock logging_;
   UserCollector collector_;
   pid_t pid_;
 };
 
 TEST_F(UserCollectorTest, EnableOK) {
   ASSERT_TRUE(collector_.Enable());
   ExpectFileEquals("|/my/path --user=%p:%s:%e", "test/core_pattern");
   ExpectFileEquals("4", "test/core_pipe_limit");
   ASSERT_EQ(s_crashes, 0);
-  ASSERT_NE(logging_.log().find("Enabling user crash handling"),
-            std::string::npos);
+  EXPECT_TRUE(syslog_logging::Contains("Enabling user crash handling"));
 }
 
 TEST_F(UserCollectorTest, EnableNoPatternFileAccess) {
   collector_.set_core_pattern_file("/does_not_exist");
   ASSERT_FALSE(collector_.Enable());
   ASSERT_EQ(s_crashes, 0);
-  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);
+  EXPECT_TRUE(syslog_logging::Contains("Enabling user crash handling"));
+  EXPECT_TRUE(syslog_logging::Contains("Unable to write /does_not_exist"));
 }
 
 TEST_F(UserCollectorTest, EnableNoPipeLimitFileAccess) {
   collector_.set_core_pipe_limit_file("/does_not_exist");
   ASSERT_FALSE(collector_.Enable());
   ASSERT_EQ(s_crashes, 0);
   // Core pattern should not be written if we cannot access the pipe limit
   // or otherwise we may set a pattern that results in infinite recursion.
   ASSERT_FALSE(file_util::PathExists(FilePath("test/core_pattern")));
-  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);
+  EXPECT_TRUE(syslog_logging::Contains("Enabling user crash handling"));
+  EXPECT_TRUE(syslog_logging::Contains("Unable to write /does_not_exist"));
 }
 
 TEST_F(UserCollectorTest, DisableOK) {
   ASSERT_TRUE(collector_.Disable());
   ExpectFileEquals("core", "test/core_pattern");
   ASSERT_EQ(s_crashes, 0);
-  ASSERT_NE(logging_.log().find("Disabling user crash handling"),
-            std::string::npos);
+  EXPECT_TRUE(syslog_logging::Contains("Disabling user crash handling"));
 }
 
 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 user crash handling"),
-            std::string::npos);
-  ASSERT_NE(logging_.log().find("Unable to write /does_not_exist"),
-            std::string::npos);
+  EXPECT_TRUE(syslog_logging::Contains("Disabling user crash handling"));
+  EXPECT_TRUE(syslog_logging::Contains("Unable to write /does_not_exist"));
 }
 
 TEST_F(UserCollectorTest, ParseCrashAttributes) {
   pid_t pid;
   int signal;
   std::string exec_name;
   EXPECT_TRUE(collector_.ParseCrashAttributes("123456:11:foobar",
                                               &pid, &signal, &exec_name));
   EXPECT_EQ(123456, pid);
   EXPECT_EQ(11, signal);
@@ skipping 12 matching lines @@
   EXPECT_FALSE(collector_.ParseCrashAttributes("123456:1 :foobar",
                                               &pid, &signal, &exec_name));
 
   EXPECT_FALSE(collector_.ParseCrashAttributes("123456::foobar",
                                               &pid, &signal, &exec_name));
 }
 
 TEST_F(UserCollectorTest, HandleCrashWithoutMetrics) {
   s_metrics = false;
   collector_.HandleCrash("20:10:ignored", "foobar");
-  ASSERT_NE(std::string::npos,
-            logging_.log().find(
-                "Received crash notification for foobar[20] sig 10"));
+  EXPECT_TRUE(syslog_logging::Contains(
+      "Received crash notification for foobar[20] sig 10"));
   ASSERT_EQ(s_crashes, 0);
 }
 
 TEST_F(UserCollectorTest, HandleNonChromeCrashWithMetrics) {
   s_metrics = true;
   collector_.HandleCrash("5:2:ignored", "chromeos-wm");
-  ASSERT_NE(std::string::npos,
-            logging_.log().find(
-                "Received crash notification for chromeos-wm[5] sig 2"));
+  EXPECT_TRUE(syslog_logging::Contains(
+      "Received crash notification for chromeos-wm[5] sig 2"));
   ASSERT_EQ(s_crashes, 1);
 }
 
 TEST_F(UserCollectorTest, HandleChromeCrashWithMetrics) {
   s_metrics = true;
   collector_.HandleCrash("5:2:ignored", "chrome");
-  ASSERT_NE(std::string::npos,
-            logging_.log().find(
-                "Received crash notification for chrome[5] sig 2"));
-  ASSERT_NE(std::string::npos,
-            logging_.log().find("(ignoring - chrome crash)"));
+  EXPECT_TRUE(syslog_logging::Contains(
+      "Received crash notification for chrome[5] sig 2"));
+  EXPECT_TRUE(syslog_logging::Contains("(ignoring - chrome crash)"));
   ASSERT_EQ(s_crashes, 0);
 }
 
 TEST_F(UserCollectorTest, HandleSuppliedChromeCrashWithMetrics) {
   s_metrics = true;
   collector_.HandleCrash("0:2:chrome", NULL);
-  ASSERT_NE(std::string::npos,
-            logging_.log().find(
-                "Received crash notification for supplied_chrome[0] sig 2"));
-  ASSERT_NE(std::string::npos,
-            logging_.log().find("(ignoring - chrome crash)"));
+  EXPECT_TRUE(syslog_logging::Contains(
+      "Received crash notification for supplied_chrome[0] sig 2"));
+  EXPECT_TRUE(syslog_logging::Contains("(ignoring - chrome crash)"));
   ASSERT_EQ(s_crashes, 0);
 }
 
 TEST_F(UserCollectorTest, GetProcessPath) {
   FilePath path = collector_.GetProcessPath(100);
   ASSERT_EQ("/proc/100", path.value());
 }
 
 TEST_F(UserCollectorTest, GetSymlinkTarget) {
   FilePath result;
   ASSERT_FALSE(collector_.GetSymlinkTarget(FilePath("/does_not_exist"),
                                            &result));
-  ASSERT_NE(std::string::npos,
-            logging_.log().find(
-                "Readlink failed on /does_not_exist with 2"));
+  ASSERT_TRUE(syslog_logging::Contains(
+      "Readlink failed on /does_not_exist with 2"));
   std::string long_link;
   for (int i = 0; i < 50; ++i)
     long_link += "0123456789";
   long_link += "/gold";
 
   for (size_t len = 1; len <= long_link.size(); ++len) {
     std::string this_link;
     static const char kLink[] = "test/this_link";
     this_link.assign(long_link.c_str(), len);
     ASSERT_EQ(len, this_link.size());
     unlink(kLink);
     ASSERT_EQ(0, symlink(this_link.c_str(), kLink));
     ASSERT_TRUE(collector_.GetSymlinkTarget(FilePath(kLink), &result));
     ASSERT_EQ(this_link, result.value());
   }
 }
 
 TEST_F(UserCollectorTest, GetExecutableBaseNameFromPid) {
   std::string base_name;
   EXPECT_FALSE(collector_.GetExecutableBaseNameFromPid(0, &base_name));
-  EXPECT_NE(std::string::npos,
-            logging_.log().find(
-                "Readlink failed on /proc/0/exe with 2"));
-  EXPECT_NE(std::string::npos,
-            logging_.log().find(
-                "GetSymlinkTarget failed - Path "
-                "/proc/0 DirectoryExists: 0"));
-  EXPECT_NE(std::string::npos,
-            logging_.log().find(
-                "stat /proc/0/exe failed: -1 2"));
+  EXPECT_TRUE(syslog_logging::Contains(
+      "Readlink failed on /proc/0/exe with 2"));
+  EXPECT_TRUE(syslog_logging::Contains(
+      "GetSymlinkTarget failed - Path /proc/0 DirectoryExists: 0"));
+  EXPECT_TRUE(syslog_logging::Contains("stat /proc/0/exe failed: -1 2"));
 
-  logging_.clear();
+  syslog_logging::ClearAccumulatedLog();
   pid_t my_pid = getpid();
   EXPECT_TRUE(collector_.GetExecutableBaseNameFromPid(my_pid, &base_name));
-  EXPECT_EQ(std::string::npos,
-            logging_.log().find(
-                "Readlink failed"));
+  EXPECT_FALSE(syslog_logging::Contains("Readlink failed"));
   EXPECT_EQ("user_collector_test", base_name);
 }
 
 TEST_F(UserCollectorTest, GetIdFromStatus) {
   int id = 1;
   EXPECT_FALSE(collector_.GetIdFromStatus(UserCollector::kUserId,
                                           UserCollector::kIdEffective,
                                           "nothing here",
                                           &id));
   EXPECT_EQ(id, 1);
@@ skipping 65 matching lines @@
   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, 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);
+  EXPECT_TRUE(syslog_logging::Contains("Could not create /bad/path"));
 }
 
 TEST_F(UserCollectorTest, CopyOffProcFilesBadPid) {
   FilePath container_path("test/container");
   ASSERT_FALSE(collector_.CopyOffProcFiles(0, container_path));
-  ASSERT_NE(logging_.log().find(
-      "Path /proc/0 does not exist"),
-            std::string::npos);
+  EXPECT_TRUE(syslog_logging::Contains("Path /proc/0 does not exist"));
 }
 
 TEST_F(UserCollectorTest, CopyOffProcFilesOK) {
   FilePath container_path("test/container");
   ASSERT_TRUE(collector_.CopyOffProcFiles(pid_, container_path));
-  ASSERT_EQ(logging_.log().find(
-      "Could not copy"), std::string::npos);
+  EXPECT_FALSE(syslog_logging::Contains("Could not copy"));
   static struct {
     const char *name;
     bool exists;
   } expectations[] = {
     { "auxv", true },
     { "cmdline", true },
     { "environ", true },
     { "maps", true },
     { "mem", false },
     { "mounts", false },
     { "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)));
   }
 }
 
 int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
+  SetUpTests(&argc, argv, false);
   return RUN_ALL_TESTS();
 }