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

crash_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 "base/string_util.h"
+#include "chromeos/syslog_logging.h"
+#include "chromeos/test_helpers.h"
 #include "crash-reporter/crash_collector.h"
-#include "crash-reporter/system_logging_mock.h"
-#include "crash-reporter/test_helpers.h"
 #include "gflags/gflags.h"
 #include "gtest/gtest.h"
 
 // This test assumes the following standard binaries are installed.
 static const char kBinBash[] = "/bin/bash";
 static const char kBinCp[] = "/bin/cp";
 static const char kBinEcho[] = "/bin/echo";
 static const char kBinFalse[] = "/bin/false";
 
 void CountCrash() {
   ADD_FAILURE();
 }
 
 bool IsMetrics() {
   ADD_FAILURE();
   return false;
 }
 
 class CrashCollectorTest : public ::testing::Test {
  public:
   void SetUp() {
     collector_.Initialize(CountCrash,
-                          IsMetrics,
-                          &logging_);
+                          IsMetrics);
     test_dir_ = FilePath("test");
     file_util::CreateDirectory(test_dir_);
+    syslog_logging::ClearAccumulatedLog();
   }
 
   void TearDown() {
     file_util::Delete(test_dir_, true);
   }
 
   bool CheckHasCapacity();
 
  protected:
-  SystemLoggingMock logging_;
   CrashCollector collector_;
   FilePath test_dir_;
 };
 
 TEST_F(CrashCollectorTest, Initialize) {
   ASSERT_TRUE(CountCrash == collector_.count_crash_function_);
   ASSERT_TRUE(IsMetrics == collector_.is_feedback_allowed_function_);
-  ASSERT_TRUE(&logging_ == collector_.logger_);
 }
 
 TEST_F(CrashCollectorTest, WriteNewFile) {
   FilePath test_file = test_dir_.Append("test_new");
   const char kBuffer[] = "buffer";
   EXPECT_EQ(strlen(kBuffer),
             collector_.WriteNewFile(test_file,
                                     kBuffer,
                                     strlen(kBuffer)));
   EXPECT_LT(collector_.WriteNewFile(test_file,
@@ skipping 81 matching lines @@
   EXPECT_EQ("/home/chronos/user/crash/chrome.20100101.1200.1234.dmp",
             collector_.GetCrashPath(FilePath("/home/chronos/user/crash"),
                                     "chrome.20100101.1200.1234",
                                     "dmp").value());
 }
 
 
 bool CrashCollectorTest::CheckHasCapacity() {
   static const char kFullMessage[] = "Crash directory test already full";
   bool has_capacity = collector_.CheckHasCapacity(test_dir_);
-  bool has_message = (logging_.log().find(kFullMessage) != std::string::npos);
+  bool has_message = syslog_logging::Contains(kFullMessage);
   EXPECT_EQ(has_message, !has_capacity);
   return has_capacity;
 }
 
 TEST_F(CrashCollectorTest, CheckHasCapacityUsual) {
   // Test kMaxCrashDirectorySize - 1 non-meta files can be added.
   for (int i = 0; i < CrashCollector::kMaxCrashDirectorySize - 1; ++i) {
     file_util::WriteFile(test_dir_.Append(StringPrintf("file%d.core", i)),
                          "", 0);
     EXPECT_TRUE(CheckHasCapacity());
@@ skipping 123 matching lines @@
   // Test target of symlink is not overwritten.
   payload_file = test_dir_.Append("payload2-file");
   ASSERT_TRUE(
       file_util::WriteFile(payload_file,
                            kPayload, strlen(kPayload)));
   FilePath meta_symlink_path = test_dir_.Append("symlink.meta");
   ASSERT_EQ(0,
             symlink(kMetaFileBasename,
                     meta_symlink_path.value().c_str()));
   ASSERT_TRUE(file_util::PathExists(meta_symlink_path));
-  logging_.clear();
+  syslog_logging::ClearAccumulatedLog();
   collector_.WriteCrashMetaData(meta_symlink_path,
                                 "kernel",
                                 payload_file.value());
-  // Target metadata contents sould have stayed the same.
+  // Target metadata contents should have stayed the same.
   contents.clear();
   EXPECT_TRUE(file_util::ReadFileToString(meta_file, &contents));
   EXPECT_EQ(kExpectedMeta, contents);
-  EXPECT_NE(std::string::npos, logging_.log().find("Unable to write"));
+  EXPECT_TRUE(syslog_logging::Contains("Unable to write"));
 
   // Test target of dangling symlink is not created.
   file_util::Delete(meta_file, false);
   ASSERT_FALSE(file_util::PathExists(meta_file));
-  logging_.clear();
+  syslog_logging::ClearAccumulatedLog();
   collector_.WriteCrashMetaData(meta_symlink_path, "kernel",
                                 payload_file.value());
   EXPECT_FALSE(file_util::PathExists(meta_file));
-  EXPECT_NE(std::string::npos, logging_.log().find("Unable to write"));
+  EXPECT_TRUE(syslog_logging::Contains("Unable to write"));
 }
 
 TEST_F(CrashCollectorTest, GetLogContents) {
   FilePath config_file = test_dir_.Append("crash_config");
   FilePath output_file = test_dir_.Append("crash_log");
   const char kConfigContents[] =
       "foobar:echo hello there | sed -e \"s/there/world/\"";
   ASSERT_TRUE(
       file_util::WriteFile(config_file,
                            kConfigContents, strlen(kConfigContents)));
   file_util::Delete(FilePath(output_file), false);
   EXPECT_FALSE(collector_.GetLogContents(config_file,
                                          "barfoo",
                                          output_file));
   EXPECT_FALSE(file_util::PathExists(output_file));
   file_util::Delete(FilePath(output_file), false);
   EXPECT_TRUE(collector_.GetLogContents(config_file,
                                         "foobar",
                                         output_file));
   ASSERT_TRUE(file_util::PathExists(output_file));
   std::string contents;
   EXPECT_TRUE(file_util::ReadFileToString(output_file, &contents));
   EXPECT_EQ("hello world\n", contents);
 }
 
-class ForkExecAndPipeTest : public CrashCollectorTest {
- public:
-  void SetUp() {
-    CrashCollectorTest::SetUp();
-    output_file_ = "test/fork_out";
-    file_util::Delete(FilePath(output_file_), false);
-  }
-
-  void TearDown() {
-    CrashCollectorTest::TearDown();
-  }
-
- protected:
-  std::vector<const char *> args_;
-  const char *output_file_;
-};
-
-TEST_F(ForkExecAndPipeTest, Basic) {
-  args_.push_back(kBinEcho);
-  args_.push_back("hello world");
-  EXPECT_EQ(0, collector_.ForkExecAndPipe(args_, output_file_));
-  ExpectFileEquals("hello world\n", output_file_);
-  EXPECT_EQ("", logging_.log());
-}
-
-TEST_F(ForkExecAndPipeTest, NonZeroReturnValue) {
-  args_.push_back(kBinFalse);
-  EXPECT_EQ(1, collector_.ForkExecAndPipe(args_, output_file_));
-  ExpectFileEquals("", output_file_);
-  EXPECT_EQ("", logging_.log());
-}
-
-TEST_F(ForkExecAndPipeTest, BadOutputFile) {
-  EXPECT_EQ(127, collector_.ForkExecAndPipe(args_, "/bad/path"));
-}
-
-TEST_F(ForkExecAndPipeTest, ExistingOutputFile) {
-  args_.push_back(kBinEcho);
-  args_.push_back("hello world");
-  EXPECT_FALSE(file_util::PathExists(FilePath(output_file_)));
-  EXPECT_EQ(0, collector_.ForkExecAndPipe(args_, output_file_));
-  EXPECT_TRUE(file_util::PathExists(FilePath(output_file_)));
-  EXPECT_EQ(127, collector_.ForkExecAndPipe(args_, output_file_));
-}
-
-TEST_F(ForkExecAndPipeTest, BadExecutable) {
-  args_.push_back("false");
-  EXPECT_EQ(127, collector_.ForkExecAndPipe(args_, output_file_));
-}
-
-TEST_F(ForkExecAndPipeTest, StderrCaptured) {
-  std::string contents;
-  args_.push_back(kBinCp);
-  EXPECT_EQ(1, collector_.ForkExecAndPipe(args_, output_file_));
-  EXPECT_TRUE(file_util::ReadFileToString(FilePath(output_file_),
-                                                   &contents));
-  EXPECT_NE(std::string::npos, contents.find("missing file operand"));
-  EXPECT_EQ("", logging_.log());
-}
-
-TEST_F(ForkExecAndPipeTest, NULLParam) {
-  args_.push_back(NULL);
-  EXPECT_EQ(-1, collector_.ForkExecAndPipe(args_, output_file_));
-  EXPECT_NE(std::string::npos,
-            logging_.log().find("Bad parameter"));
-}
-
-TEST_F(ForkExecAndPipeTest, NoParams) {
-  EXPECT_EQ(127, collector_.ForkExecAndPipe(args_, output_file_));
-}
-
-TEST_F(ForkExecAndPipeTest, SegFaultHandling) {
-  args_.push_back(kBinBash);
-  args_.push_back("-c");
-  args_.push_back("kill -SEGV $$");
-  EXPECT_EQ(-1, collector_.ForkExecAndPipe(args_, output_file_));
-  EXPECT_NE(std::string::npos,
-            logging_.log().find("Process did not exit normally"));
-}
-
 int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
+  SetUpTests(&argc, argv, false);
   return RUN_ALL_TESTS();
 }