Adding crash utilities to chromecast/crash.

chromecast/crash/minidump_writer_unittest.cc

+
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/memory/scoped_ptr.h"
+#include "chromecast/crash/minidump_generator.h"
+#include "chromecast/crash/minidump_writer.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace chromecast {
+namespace {
+
+const char kMinidumpPath[] = "/this/is/a/fake/path";
+
+class FakeMinidumpGenerator : public MinidumpGenerator {
+ public:
+  FakeMinidumpGenerator() {}
+  ~FakeMinidumpGenerator() override {}
+
+  // MinidumpGenerator implementation:
+  bool Generate(const std::string& minidump_path) override { return true; }
+};
+
+}  // namespace
+
+class MinidumpWriterTest : public testing::Test {

[gunsch, 2015/06/09 18:46:19]

note: prefer not using test fixtures when possible. You only have one test case
here, so it could simplify the test to simply inline all of this.

[slan, 2015/06/10 01:49:13]

Done.

+ public:
+  MinidumpWriterTest()
+      : writer_(
+            new MinidumpWriter(&generator_, kMinidumpPath, MinidumpParams())) {}
+  ~MinidumpWriterTest() override {}
+
+  // testing::Test implementation:
+  void SetUp() override {}
+
+  void TearDown() override {}
+
+  // Accessors and mutators for for testing.
+  void SetLockfile(const std::string& lockfile) {
+    writer_->lockfile_path_ = lockfile;
+  }
+  void SetMaxDumps(int max_dumps) { writer_->max_dumps_ = max_dumps; }
+  void SetMaxRecentDumps(int max_recent_dumps) {
+    writer_->max_recent_dumps_ = max_recent_dumps;
+  }
+
+  bool CanWriteDump() { return writer_->CanWriteDump(); }
+
+ private:
+  FakeMinidumpGenerator generator_;
+  scoped_ptr<MinidumpWriter> writer_;
+
+  DISALLOW_COPY_AND_ASSIGN(MinidumpWriterTest);
+};
+
+TEST_F(MinidumpWriterTest, CanWriteDump_WithEmptyLogFile) {
+  base::FilePath path;
+  ASSERT_TRUE(base::CreateTemporaryFile(&path));
+  SetLockfile(path.value());
+  SetMaxDumps(2);
+  SetMaxRecentDumps(10);
+
+  // Should be able to write dump with empty file.
+  ASSERT_TRUE(CanWriteDump());
+
+  // Add an entry to the lockfile. Should still be able to write dump.
+  DumpInfo info("p|2015-01-01 01:02:03|/dump/path||");
+  ASSERT_TRUE(info.valid());
+  base::AppendToFile(path, info.entry().c_str(), info.entry().size());
+  ASSERT_TRUE(CanWriteDump());
+
+  // Cannot write dump if next dump would exceed maximum.
+  DumpInfo info2("p|2015-01-01 01:02:04|/dump/path||");
+  ASSERT_TRUE(info2.valid());
+  base::AppendToFile(path, info2.entry().c_str(), info2.entry().size());
+  ASSERT_FALSE(CanWriteDump());
+
+  // Cannot write dump if next dump would exceed maximum.
+  DumpInfo info3("p|2015-01-01 01:02:05|/dump/path||");
+  ASSERT_TRUE(info3.valid());
+  base::AppendToFile(path, info3.entry().c_str(), info3.entry().size());
+  ASSERT_FALSE(CanWriteDump());
+}
+
+}  // namespace chromecast