Add FileWriteMode::kCreateOrFail

client/crash_report_database_test.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "client/crash_report_database.h"
 
-#include <sys/stat.h>
-
 #include "build/build_config.h"
 #include "client/settings.h"
 #include "gtest/gtest.h"
 #include "test/errors.h"
+#include "test/file.h"
 #include "test/scoped_temp_dir.h"
 #include "util/file/file_io.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
-bool FileExistsAtPath(const base::FilePath& path) {
-#if defined(OS_POSIX)
-  struct stat st;
-  return lstat(path.value().c_str(), &st) == 0;
-#elif defined(OS_WIN)
-  struct _stat st;
-  return _wstat(path.value().c_str(), &st) == 0;
-#else
-#error "Not implemented"
-#endif
-}
-
 class CrashReportDatabaseTest : public testing::Test {
  public:
   CrashReportDatabaseTest() {
   }
 
  protected:
   // testing::Test:
   void SetUp() override {
     db_ = CrashReportDatabase::Initialize(path());
     ASSERT_TRUE(db_);
@@ skipping 15 matching lines @@
     const char kTest[] = "test";
     ASSERT_TRUE(LoggingWriteFile(new_report->handle, kTest, sizeof(kTest)));
 
     UUID uuid;
     EXPECT_EQ(CrashReportDatabase::kNoError,
               db_->FinishedWritingCrashReport(new_report, &uuid));
 
     EXPECT_EQ(CrashReportDatabase::kNoError,
               db_->LookUpCrashReport(uuid, report));
     ExpectPreparedCrashReport(*report);
-    ASSERT_TRUE(FileExistsAtPath(report->file_path));
+    ASSERT_TRUE(FileExists(report->file_path));
   }
 
   void UploadReport(const UUID& uuid, bool successful, const std::string& id) {
 #if !defined(OS_WIN)
     // Enable when ported to Windows.
     // https://code.google.com/p/crashpad/issues/detail?id=13
     Settings* const settings = db_->GetSettings();
     ASSERT_TRUE(settings);
     time_t times[2];
     ASSERT_TRUE(settings->GetLastUploadAttemptTime(&times[0]));
 #endif
 
     const CrashReportDatabase::Report* report = nullptr;
     ASSERT_EQ(CrashReportDatabase::kNoError,
               db_->GetReportForUploading(uuid, &report));
     EXPECT_NE(UUID(), report->uuid);
     EXPECT_FALSE(report->file_path.empty());
-    EXPECT_TRUE(FileExistsAtPath(report->file_path))
+    EXPECT_TRUE(FileExists(report->file_path))
         << report->file_path.value();
     EXPECT_GT(report->creation_time, 0);
     EXPECT_EQ(CrashReportDatabase::kNoError,
               db_->RecordUploadAttempt(report, successful, id));
 
 #if !defined(OS_WIN)
     // Enable when ported to Windows.
     // https://code.google.com/p/crashpad/issues/detail?id=13
     ASSERT_TRUE(settings->GetLastUploadAttemptTime(&times[1]));
     EXPECT_NE(times[1], 0);
     EXPECT_GE(times[1], times[0]);
 #endif
   }
 
   void ExpectPreparedCrashReport(const CrashReportDatabase::Report& report) {
     EXPECT_NE(UUID(), report.uuid);
     EXPECT_FALSE(report.file_path.empty());
-    EXPECT_TRUE(FileExistsAtPath(report.file_path)) << report.file_path.value();
+    EXPECT_TRUE(FileExists(report.file_path)) << report.file_path.value();
     EXPECT_TRUE(report.id.empty());
     EXPECT_GT(report.creation_time, 0);
     EXPECT_FALSE(report.uploaded);
     EXPECT_EQ(0, report.last_upload_attempt_time);
     EXPECT_EQ(0, report.upload_attempts);
   }
 
   void RelocateDatabase() {
     ResetDatabase();
     temp_dir_.Rename();
@@ skipping 49 matching lines @@
   reports.clear();
   EXPECT_EQ(CrashReportDatabase::kNoError, db->GetCompletedReports(&reports));
   EXPECT_TRUE(reports.empty());
 }
 
 TEST_F(CrashReportDatabaseTest, NewCrashReport) {
   CrashReportDatabase::NewReport* new_report;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->PrepareNewCrashReport(&new_report));
   UUID expect_uuid = new_report->uuid;
-  EXPECT_TRUE(FileExistsAtPath(new_report->path)) << new_report->path.value();
+  EXPECT_TRUE(FileExists(new_report->path)) << new_report->path.value();
   UUID uuid;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->FinishedWritingCrashReport(new_report, &uuid));
   EXPECT_EQ(expect_uuid, uuid);
 
   CrashReportDatabase::Report report;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->LookUpCrashReport(uuid, &report));
   ExpectPreparedCrashReport(report);
 
   std::vector<CrashReportDatabase::Report> reports;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->GetPendingReports(&reports));
   ASSERT_EQ(1u, reports.size());
   EXPECT_EQ(report.uuid, reports[0].uuid);
 
   reports.clear();
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->GetCompletedReports(&reports));
   EXPECT_TRUE(reports.empty());
 }
 
 TEST_F(CrashReportDatabaseTest, ErrorWritingCrashReport) {
   CrashReportDatabase::NewReport* new_report = nullptr;
   ASSERT_EQ(CrashReportDatabase::kNoError,
             db()->PrepareNewCrashReport(&new_report));
   base::FilePath new_report_path = new_report->path;
-  EXPECT_TRUE(FileExistsAtPath(new_report_path)) << new_report_path.value();
+  EXPECT_TRUE(FileExists(new_report_path)) << new_report_path.value();
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->ErrorWritingCrashReport(new_report));
-  EXPECT_FALSE(FileExistsAtPath(new_report_path)) << new_report_path.value();
+  EXPECT_FALSE(FileExists(new_report_path)) << new_report_path.value();
 }
 
 TEST_F(CrashReportDatabaseTest, LookUpCrashReport) {
   UUID uuid;
 
   {
     CrashReportDatabase::Report report;
     CreateCrashReport(&report);
     uuid = report.uuid;
   }
@@ skipping 256 matching lines @@
   EXPECT_FALSE(upload_report_2);
 
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->RecordUploadAttempt(upload_report, true, std::string()));
 }
 
 TEST_F(CrashReportDatabaseTest, MoveDatabase) {
   CrashReportDatabase::NewReport* new_report;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->PrepareNewCrashReport(&new_report));
-  EXPECT_TRUE(FileExistsAtPath(new_report->path)) << new_report->path.value();
+  EXPECT_TRUE(FileExists(new_report->path)) << new_report->path.value();
   UUID uuid;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->FinishedWritingCrashReport(new_report, &uuid));
 
   RelocateDatabase();
 
   CrashReportDatabase::Report report;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->LookUpCrashReport(uuid, &report));
   ExpectPreparedCrashReport(report);
-  EXPECT_TRUE(FileExistsAtPath(report.file_path)) << report.file_path.value();
+  EXPECT_TRUE(FileExists(report.file_path)) << report.file_path.value();
 }
 
 TEST_F(CrashReportDatabaseTest, ReportRemoved) {
   CrashReportDatabase::NewReport* new_report;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->PrepareNewCrashReport(&new_report));
-  EXPECT_TRUE(FileExistsAtPath(new_report->path)) << new_report->path.value();
+  EXPECT_TRUE(FileExists(new_report->path)) << new_report->path.value();
   UUID uuid;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->FinishedWritingCrashReport(new_report, &uuid));
 
   CrashReportDatabase::Report report;
   EXPECT_EQ(CrashReportDatabase::kNoError,
             db()->LookUpCrashReport(uuid, &report));
 
 #if defined(OS_WIN)
   EXPECT_EQ(0, _wunlink(report.file_path.value().c_str()));
 #else
   EXPECT_EQ(0, unlink(report.file_path.value().c_str()))
       << ErrnoMessage("unlink");
 #endif
 
   EXPECT_EQ(CrashReportDatabase::kReportNotFound,
             db()->LookUpCrashReport(uuid, &report));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad