Add FileWriteMode::kCreateOrFail

util/file/file_io_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 "util/file/file_io.h"
 
 #include "base/atomicops.h"
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "gtest/gtest.h"
 #include "test/errors.h"
+#include "test/file.h"
 #include "test/scoped_temp_dir.h"
+#include "util/misc/implicit_cast.h"
 #include "util/thread/thread.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
+TEST(FileIO, OpenFileForWrite) {
+  ScopedTempDir temp_dir;
+  base::FilePath file_path_1 =
+      temp_dir.path().Append(FILE_PATH_LITERAL("file_1"));
+  ASSERT_FALSE(FileExists(file_path_1));
+
+  ScopedFileHandle file_handle(
+      LoggingOpenFileForWrite(file_path_1,
+                              FileWriteMode::kReuseOrFail,
+                              FilePermissions::kWorldReadable));
+  EXPECT_EQ(kInvalidFileHandle, file_handle);
+  EXPECT_FALSE(FileExists(file_path_1));
+
+  file_handle.reset(LoggingOpenFileForWrite(file_path_1,
+                                            FileWriteMode::kCreateOrFail,
+                                            FilePermissions::kWorldReadable));
+  EXPECT_NE(kInvalidFileHandle, file_handle);
+  EXPECT_TRUE(FileExists(file_path_1));
+  EXPECT_EQ(0, FileSize(file_path_1));
+
+  file_handle.reset(LoggingOpenFileForWrite(file_path_1,
+                                            FileWriteMode::kCreateOrFail,
+                                            FilePermissions::kWorldReadable));
+  EXPECT_EQ(kInvalidFileHandle, file_handle);
+  EXPECT_TRUE(FileExists(file_path_1));
+  EXPECT_EQ(0, FileSize(file_path_1));
+
+  file_handle.reset(LoggingOpenFileForWrite(file_path_1,
+                                            FileWriteMode::kReuseOrFail,
+                                            FilePermissions::kWorldReadable));
+  EXPECT_NE(kInvalidFileHandle, file_handle);
+  EXPECT_TRUE(FileExists(file_path_1));
+  EXPECT_EQ(0, FileSize(file_path_1));
+
+  file_handle.reset(LoggingOpenFileForWrite(file_path_1,
+                                            FileWriteMode::kReuseOrCreate,
+                                            FilePermissions::kWorldReadable));
+  EXPECT_NE(kInvalidFileHandle, file_handle);
+  EXPECT_TRUE(FileExists(file_path_1));
+  EXPECT_EQ(0, FileSize(file_path_1));
+
+  file_handle.reset(LoggingOpenFileForWrite(file_path_1,

[scottmg, 2015/10/06 23:22:02]

What does doing this a second time test?

+                                            FileWriteMode::kReuseOrCreate,
+                                            FilePermissions::kWorldReadable));
+  EXPECT_NE(kInvalidFileHandle, file_handle);
+  EXPECT_TRUE(FileExists(file_path_1));
+  EXPECT_EQ(0, FileSize(file_path_1));
+
+  base::FilePath file_path_2 =
+      temp_dir.path().Append(FILE_PATH_LITERAL("file_2"));
+  ASSERT_FALSE(FileExists(file_path_2));
+
+  file_handle.reset(LoggingOpenFileForWrite(file_path_2,
+                                            FileWriteMode::kReuseOrCreate,
+                                            FilePermissions::kWorldReadable));
+  EXPECT_NE(kInvalidFileHandle, file_handle);
+  EXPECT_TRUE(FileExists(file_path_2));
+  EXPECT_EQ(0, FileSize(file_path_2));
+
+  const char data = '%';
+  EXPECT_TRUE(LoggingWriteFile(file_handle.get(), &data, sizeof(data)));
+
+  // Close file_handle to ensure that the write is flushed to disk.
+  file_handle.reset();
+  EXPECT_EQ(implicit_cast<FileOffset>(sizeof(data)), FileSize(file_path_2));
+
+  file_handle.reset(LoggingOpenFileForWrite(file_path_2,
+                                            FileWriteMode::kTruncateOrCreate,
+                                            FilePermissions::kWorldReadable));
+  EXPECT_NE(kInvalidFileHandle, file_handle);
+  EXPECT_TRUE(FileExists(file_path_2));
+  EXPECT_EQ(0, FileSize(file_path_2));
+
+  base::FilePath file_path_3 =
+      temp_dir.path().Append(FILE_PATH_LITERAL("file_3"));
+  ASSERT_FALSE(FileExists(file_path_3));
+
+  file_handle.reset(LoggingOpenFileForWrite(file_path_3,
+                                            FileWriteMode::kTruncateOrCreate,
+                                            FilePermissions::kWorldReadable));
+  EXPECT_NE(kInvalidFileHandle, file_handle);
+  EXPECT_TRUE(FileExists(file_path_3));
+  EXPECT_EQ(0, FileSize(file_path_3));
+}
+
 enum class ReadOrWrite : bool {
   kRead,
   kWrite,
 };
 
 void FileShareModeTest(ReadOrWrite first, ReadOrWrite second) {
   ScopedTempDir temp_dir;
   base::FilePath shared_file =
       temp_dir.path().Append(FILE_PATH_LITERAL("shared_file"));
   {
@@ skipping 159 matching lines @@
   LockingTest(FileLocking::kExclusive, FileLocking::kShared);
 }
 
 TEST(FileIO, SharedVsExclusives) {
   LockingTest(FileLocking::kShared, FileLocking::kExclusive);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad