crash-reporter: Capture and send recent update_engine logs when it crashes

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 "crash-reporter/crash_collector.h"
 #include "crash-reporter/system_logging_mock.h"
@@ skipping 253 matching lines @@
   }
   // Test dot files are treated as individual files.
   for (int i = 0; i < CrashCollector::kMaxCrashDirectorySize - 2; ++i) {
     file_util::WriteFile(test_dir_.Append(StringPrintf(".file%d", i)), "", 0);
     EXPECT_TRUE(CheckHasCapacity());
   }
   file_util::WriteFile(test_dir_.Append("normal.meta"), "", 0);
   EXPECT_FALSE(CheckHasCapacity());
 }
 
+TEST_F(CrashCollectorTest, IsCommentLine) {
+  EXPECT_FALSE(CrashCollector::IsCommentLine(""));
+  EXPECT_TRUE(CrashCollector::IsCommentLine("#"));
+  EXPECT_TRUE(CrashCollector::IsCommentLine("#real comment"));
+  EXPECT_TRUE(CrashCollector::IsCommentLine(" # real comment"));
+  EXPECT_FALSE(CrashCollector::IsCommentLine("not comment"));
+  EXPECT_FALSE(CrashCollector::IsCommentLine(" not comment"));
+}
+
 TEST_F(CrashCollectorTest, ReadKeyValueFile) {
   const char *contents = ("a=b\n"
                           "\n"
                           " c=d \n");
   FilePath path(test_dir_.Append("keyval"));
   std::map<std::string, std::string> dictionary;
   std::map<std::string, std::string>::iterator i;
 
   file_util::WriteFile(path, contents, strlen(contents));
 
   EXPECT_TRUE(collector_.ReadKeyValueFile(path, '=', &dictionary));
   i = dictionary.find("a");
   EXPECT_TRUE(i != dictionary.end() && i->second == "b");
   i = dictionary.find("c");
   EXPECT_TRUE(i != dictionary.end() && i->second == "d");
 
   dictionary.clear();
 
   contents = ("a=b c d\n"
               "e\n"
               " f g = h\n"
               "i=j\n"
               "=k\n"
+              "#comment=0\n"
               "l=\n");
   file_util::WriteFile(path, contents, strlen(contents));
 
   EXPECT_FALSE(collector_.ReadKeyValueFile(path, '=', &dictionary));
+  EXPECT_EQ(5, dictionary.size());
+
   i = dictionary.find("a");
   EXPECT_TRUE(i != dictionary.end() && i->second == "b c d");
   i = dictionary.find("e");
   EXPECT_TRUE(i == dictionary.end());
   i = dictionary.find("f g");
   EXPECT_TRUE(i != dictionary.end() && i->second == "h");
   i = dictionary.find("i");
   EXPECT_TRUE(i != dictionary.end() && i->second == "j");
   i = dictionary.find("");
   EXPECT_TRUE(i != dictionary.end() && i->second == "k");
@@ skipping 51 matching lines @@
   // Test target of dangling symlink is not created.
   file_util::Delete(meta_file, false);
   ASSERT_FALSE(file_util::PathExists(meta_file));
   logging_.clear();
   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"));
 }
 
+TEST_F(CrashCollectorTest, GetLogContents) {
+  FilePath config_file = test_dir_.Append("crash_config");
+  FilePath output_file = test_dir_.Append("crash_log");
+  const char kConfigContents[] =
+      "foobar:sh -c 'echo hello there | sed -e \"s/there/world/\"'";

[petkov, 2010/12/13 19:27:57]

do you intentionally use "sh -c" here given that the code executes the command
through sh?

[kmixter1, 2010/12/14 03:39:49]

No, not sure why I was doing that.  Changed it.

+  ASSERT_TRUE(
+      file_util::WriteFile(config_file,
+                           kConfigContents, strlen(kConfigContents)));
+  EXPECT_FALSE(collector_.GetLogContents(config_file,
+                                         "barfoo",
+                                         output_file));
+  EXPECT_FALSE(file_util::PathExists(output_file));
+  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);
+}
+
 int main(int argc, char **argv) {
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }