A robust base::DeleteFile.

base/files/file_util_unittest.cc

 // Copyright (c) 2012 The Chromium 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <fstream>
 #include <set>
@@ skipping 174 matching lines @@
 
 // file_util winds up using autoreleased objects on the Mac, so this needs
 // to be a PlatformTest
 class FileUtilTest : public PlatformTest {
  protected:
   void SetUp() override {
     PlatformTest::SetUp();
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   }
 
+  // Sets the file to read-only.
+  static void SetReadOnly(const FilePath& path, bool read_only) {
+#if defined(OS_WIN)
+    // On Windows, it involves setting/removing the 'readonly' bit.
+    DWORD attrs = GetFileAttributes(path.value().c_str());
+    ASSERT_NE(INVALID_FILE_ATTRIBUTES, attrs);
+    ASSERT_TRUE(SetFileAttributes(
+        path.value().c_str(), read_only ? (attrs | FILE_ATTRIBUTE_READONLY)
+                                        : (attrs & ~FILE_ATTRIBUTE_READONLY)));
+
+    DWORD expected =
+        read_only
+            ? ((attrs & (FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_DIRECTORY)) |
+               FILE_ATTRIBUTE_READONLY)
+            : (attrs & (FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_DIRECTORY));
+
+    // Ignore FILE_ATTRIBUTE_NOT_CONTENT_INDEXED if present.
+    attrs = GetFileAttributes(path.value().c_str()) &
+            ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
+    ASSERT_EQ(expected, attrs);
+#else
+    // On all other platforms, it involves removing/setting the write bit.
+    mode_t mode = read_only ? S_IRUSR : (S_IRUSR | S_IWUSR);
+    EXPECT_TRUE(SetPosixFilePermissions(
+        path, DirectoryExists(path) ? (mode | S_IXUSR) : mode));
+#endif
+  }
+
+  static bool IsReadOnly(const FilePath& path) {
+#if defined(OS_WIN)
+    DWORD attrs = GetFileAttributes(path.value().c_str());
+    EXPECT_NE(INVALID_FILE_ATTRIBUTES, attrs);
+    return attrs & FILE_ATTRIBUTE_READONLY;
+#else
+    int mode = 0;
+    EXPECT_TRUE(GetPosixFilePermissions(path, &mode));
+    return !(mode & S_IWUSR);
+#endif
+  }
+
   ScopedTempDir temp_dir_;
 };
 
 // Collects all the results from the given file enumerator, and provides an
 // interface to query whether a given file is present.
 class FindResultCollector {
  public:
   explicit FindResultCollector(FileEnumerator* enumerator) {
     FilePath cur_file;
     while (!(cur_file = enumerator->Next()).value().empty()) {
@@ skipping 38 matching lines @@
   EXPECT_TRUE(file.is_open());
   file.getline(contents, arraysize(contents));
   file.close();
   return std::wstring(contents);
 }
 
 TEST_F(FileUtilTest, FileAndDirectorySize) {
   // Create three files of 20, 30 and 3 chars (utf8). ComputeDirectorySize
   // should return 53 bytes.
   FilePath file_01 = temp_dir_.GetPath().Append(FPL("The file 01.txt"));
-  CreateTextFile(file_01, L"12345678901234567890");
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_01, L"12345678901234567890"));
   int64_t size_f1 = 0;
   ASSERT_TRUE(GetFileSize(file_01, &size_f1));
   EXPECT_EQ(20ll, size_f1);
 
   FilePath subdir_path = temp_dir_.GetPath().Append(FPL("Level2"));
   CreateDirectory(subdir_path);
 
   FilePath file_02 = subdir_path.Append(FPL("The file 02.txt"));
-  CreateTextFile(file_02, L"123456789012345678901234567890");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_02, L"123456789012345678901234567890"));
   int64_t size_f2 = 0;
   ASSERT_TRUE(GetFileSize(file_02, &size_f2));
   EXPECT_EQ(30ll, size_f2);
 
   FilePath subsubdir_path = subdir_path.Append(FPL("Level3"));
   CreateDirectory(subsubdir_path);
 
   FilePath file_03 = subsubdir_path.Append(FPL("The file 03.txt"));
-  CreateTextFile(file_03, L"123");
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_03, L"123"));
 
   int64_t computed_size = ComputeDirectorySize(temp_dir_.GetPath());
   EXPECT_EQ(size_f1 + size_f2 + 3, computed_size);
 }
 
 TEST_F(FileUtilTest, NormalizeFilePathBasic) {
   // Create a directory under the test dir.  Because we create it,
   // we know it is not a link.
   FilePath file_a_path = temp_dir_.GetPath().Append(FPL("file_a"));
   FilePath dir_path = temp_dir_.GetPath().Append(FPL("dir"));
   FilePath file_b_path = dir_path.Append(FPL("file_b"));
   CreateDirectory(dir_path);
 
   FilePath normalized_file_a_path, normalized_file_b_path;
   ASSERT_FALSE(PathExists(file_a_path));
   ASSERT_FALSE(NormalizeFilePath(file_a_path, &normalized_file_a_path))
     << "NormalizeFilePath() should fail on nonexistent paths.";
 
-  CreateTextFile(file_a_path, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_a_path, bogus_content));
   ASSERT_TRUE(PathExists(file_a_path));
   ASSERT_TRUE(NormalizeFilePath(file_a_path, &normalized_file_a_path));
 
-  CreateTextFile(file_b_path, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_b_path, bogus_content));
   ASSERT_TRUE(PathExists(file_b_path));
   ASSERT_TRUE(NormalizeFilePath(file_b_path, &normalized_file_b_path));
 
   // Beacuse this test created |dir_path|, we know it is not a link
   // or junction.  So, the real path of the directory holding file a
   // must be the parent of the path holding file b.
   ASSERT_TRUE(normalized_file_a_path.DirName()
       .IsParent(normalized_file_b_path.DirName()));
 }
 
@@ skipping 21 matching lines @@
   ASSERT_FALSE(temp_base_a.empty());
   *temp_base_a.begin() = ToUpperASCII(*temp_base_a.begin());
   base_a = FilePath(temp_base_a);
 #endif
   ASSERT_TRUE(CreateDirectory(base_a));
 
   FilePath sub_a = base_a.Append(FPL("sub_a"));
   ASSERT_TRUE(CreateDirectory(sub_a));
 
   FilePath file_txt = sub_a.Append(FPL("file.txt"));
-  CreateTextFile(file_txt, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_txt, bogus_content));
 
   // Want a directory whose name is long enough to make the path to the file
   // inside just under MAX_PATH chars.  This will be used to test that when
   // a junction expands to a path over MAX_PATH chars in length,
   // NormalizeFilePath() fails without crashing.
   FilePath sub_long_rel(FPL("sub_long"));
   FilePath deep_txt(FPL("deep.txt"));
 
   int target_length = MAX_PATH;
   target_length -= (sub_a.value().length() + 1);  // +1 for the sepperator '\'.
   target_length -= (sub_long_rel.Append(deep_txt).value().length() + 1);
   // Without making the path a bit shorter, CreateDirectory() fails.
   // the resulting path is still long enough to hit the failing case in
   // NormalizePath().
   const int kCreateDirLimit = 4;
   target_length -= kCreateDirLimit;
   FilePath::StringType long_name_str = FPL("long_name_");
   long_name_str.resize(target_length, '_');
 
   FilePath long_name = sub_a.Append(FilePath(long_name_str));
   FilePath deep_file = long_name.Append(sub_long_rel).Append(deep_txt);
   ASSERT_EQ(static_cast<size_t>(MAX_PATH - kCreateDirLimit),
             deep_file.value().length());
 
   FilePath sub_long = deep_file.DirName();
   ASSERT_TRUE(CreateDirectory(sub_long));
-  CreateTextFile(deep_file, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(deep_file, bogus_content));
 
   FilePath base_b = temp_dir_.GetPath().Append(FPL("base_b"));
   ASSERT_TRUE(CreateDirectory(base_b));
 
   FilePath to_sub_a = base_b.Append(FPL("to_sub_a"));
   ASSERT_TRUE(CreateDirectory(to_sub_a));
   FilePath normalized_path;
   {
     ReparsePoint reparse_to_sub_a(to_sub_a, sub_a);
     ASSERT_TRUE(reparse_to_sub_a.IsValid());
@@ skipping 172 matching lines @@
   EXPECT_EQ(DWORD(0), path_buffer_length);
 }
 
 #endif  // defined(OS_WIN)
 
 #if defined(OS_POSIX)
 
 TEST_F(FileUtilTest, CreateAndReadSymlinks) {
   FilePath link_from = temp_dir_.GetPath().Append(FPL("from_file"));
   FilePath link_to = temp_dir_.GetPath().Append(FPL("to_file"));
-  CreateTextFile(link_to, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(link_to, bogus_content));
 
   ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create file symlink.";
 
   // If we created the link properly, we should be able to read the contents
   // through it.
   std::wstring contents = ReadTextFile(link_from);
   EXPECT_EQ(bogus_content, contents);
 
   FilePath result;
@@ skipping 16 matching lines @@
 
 // The following test of NormalizeFilePath() require that we create a symlink.
 // This can not be done on Windows before Vista.  On Vista, creating a symlink
 // requires privilege "SeCreateSymbolicLinkPrivilege".
 // TODO(skerner): Investigate the possibility of giving base_unittests the
 // privileges required to create a symlink.
 TEST_F(FileUtilTest, NormalizeFilePathSymlinks) {
   // Link one file to another.
   FilePath link_from = temp_dir_.GetPath().Append(FPL("from_file"));
   FilePath link_to = temp_dir_.GetPath().Append(FPL("to_file"));
-  CreateTextFile(link_to, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(link_to, bogus_content));
 
   ASSERT_TRUE(CreateSymbolicLink(link_to, link_from))
     << "Failed to create file symlink.";
 
   // Check that NormalizeFilePath sees the link.
   FilePath normalized_path;
   ASSERT_TRUE(NormalizeFilePath(link_from, &normalized_path));
   EXPECT_NE(link_from, link_to);
   EXPECT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
   EXPECT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
@@ skipping 39 matching lines @@
 
   EXPECT_TRUE(DeleteFile(non_existent, false));
   ASSERT_FALSE(PathExists(non_existent));
   EXPECT_TRUE(DeleteFile(non_existent, true));
   ASSERT_FALSE(PathExists(non_existent));
 }
 
 TEST_F(FileUtilTest, DeleteFile) {
   // Create a file
   FilePath file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 1.txt"));
-  CreateTextFile(file_name, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_name, bogus_content));
   ASSERT_TRUE(PathExists(file_name));
 
   // Make sure it's deleted
   EXPECT_TRUE(DeleteFile(file_name, false));
   EXPECT_FALSE(PathExists(file_name));
 
   // Test recursive case, create a new file
   file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 2.txt"));
-  CreateTextFile(file_name, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_name, bogus_content));
   ASSERT_TRUE(PathExists(file_name));
 
   // Make sure it's deleted
   EXPECT_TRUE(DeleteFile(file_name, true));
   EXPECT_FALSE(PathExists(file_name));
 }
 
+TEST_F(FileUtilTest, DeleteReadOnlyFile) {
+  // Create a read-only file.
+  FilePath file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 1.txt"));
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_name, bogus_content));
+  ASSERT_TRUE(PathExists(file_name));
+  ASSERT_NO_FATAL_FAILURE(SetReadOnly(file_name, true));
+  ASSERT_TRUE(IsReadOnly(file_name));
+
+  // Make sure it's deleted.
+  EXPECT_TRUE(DeleteFile(file_name, false));
+  EXPECT_FALSE(PathExists(file_name));
+
+  // Test recursive case: create a new file.
+  file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 2.txt"));
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_name, bogus_content));
+  ASSERT_TRUE(PathExists(file_name));
+  ASSERT_NO_FATAL_FAILURE(SetReadOnly(file_name, true));
+  ASSERT_TRUE(IsReadOnly(file_name));
+
+  // Make sure it's deleted.
+  EXPECT_TRUE(DeleteFile(file_name, true));
+  EXPECT_FALSE(PathExists(file_name));
+}
+
 #if defined(OS_POSIX)
 TEST_F(FileUtilTest, DeleteSymlinkToExistentFile) {
   // Create a file.
   FilePath file_name = temp_dir_.GetPath().Append(FPL("Test DeleteFile 2.txt"));
-  CreateTextFile(file_name, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_name, bogus_content));
   ASSERT_TRUE(PathExists(file_name));
 
   // Create a symlink to the file.
   FilePath file_link = temp_dir_.GetPath().Append("file_link_2");
   ASSERT_TRUE(CreateSymbolicLink(file_name, file_link))
       << "Failed to create symlink.";
 
   // Delete the symbolic link.
   EXPECT_TRUE(DeleteFile(file_link, false));
 
@@ skipping 190 matching lines @@
   ASSERT_TRUE(SetPosixFilePermissions(dir1.Append(kExeFileName),
                                       FILE_PERMISSION_EXECUTE_BY_USER));
 
   EXPECT_TRUE(ExecutableExistsInPath(env.get(), kExeFileName));
   EXPECT_FALSE(ExecutableExistsInPath(env.get(), kRegularFileName));
   EXPECT_FALSE(ExecutableExistsInPath(env.get(), kDneFileName));
 }
 
 #endif  // defined(OS_POSIX)
 
-#if defined(OS_WIN)
-// Tests that the Delete function works for wild cards, especially
-// with the recursion flag.  Also coincidentally tests PathExists.
-// TODO(erikkay): see if anyone's actually using this feature of the API
-TEST_F(FileUtilTest, DeleteWildCard) {
-  // Create a file and a directory
-  FilePath file_name =
-      temp_dir_.GetPath().Append(FPL("Test DeleteWildCard.txt"));
-  CreateTextFile(file_name, bogus_content);
-  ASSERT_TRUE(PathExists(file_name));
-
-  FilePath subdir_path = temp_dir_.GetPath().Append(FPL("DeleteWildCardDir"));
-  CreateDirectory(subdir_path);
-  ASSERT_TRUE(PathExists(subdir_path));
-
-  // Create the wildcard path
-  FilePath directory_contents = temp_dir_.GetPath();
-  directory_contents = directory_contents.Append(FPL("*"));
-
-  // Delete non-recursively and check that only the file is deleted
-  EXPECT_TRUE(DeleteFile(directory_contents, false));
-  EXPECT_FALSE(PathExists(file_name));
-  EXPECT_TRUE(PathExists(subdir_path));
-
-  // Delete recursively and make sure all contents are deleted
-  EXPECT_TRUE(DeleteFile(directory_contents, true));
-  EXPECT_FALSE(PathExists(file_name));
-  EXPECT_FALSE(PathExists(subdir_path));
-}
-
-// TODO(erikkay): see if anyone's actually using this feature of the API
-TEST_F(FileUtilTest, DeleteNonExistantWildCard) {
-  // Create a file and a directory
-  FilePath subdir_path =
-      temp_dir_.GetPath().Append(FPL("DeleteNonExistantWildCard"));
-  CreateDirectory(subdir_path);
-  ASSERT_TRUE(PathExists(subdir_path));
-
-  // Create the wildcard path
-  FilePath directory_contents = subdir_path;
-  directory_contents = directory_contents.Append(FPL("*"));
-
-  // Delete non-recursively and check nothing got deleted
-  EXPECT_TRUE(DeleteFile(directory_contents, false));
-  EXPECT_TRUE(PathExists(subdir_path));
-
-  // Delete recursively and check nothing got deleted
-  EXPECT_TRUE(DeleteFile(directory_contents, true));
-  EXPECT_TRUE(PathExists(subdir_path));
-}
-#endif
-
 // Tests non-recursive Delete() for a directory.
 TEST_F(FileUtilTest, DeleteDirNonRecursive) {
   // Create a subdirectory and put a file and two directories inside.
   FilePath test_subdir =
       temp_dir_.GetPath().Append(FPL("DeleteDirNonRecursive"));
   CreateDirectory(test_subdir);
   ASSERT_TRUE(PathExists(test_subdir));
 
   FilePath file_name = test_subdir.Append(FPL("Test DeleteDir.txt"));
-  CreateTextFile(file_name, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_name, bogus_content));
   ASSERT_TRUE(PathExists(file_name));
 
   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
   CreateDirectory(subdir_path1);
   ASSERT_TRUE(PathExists(subdir_path1));
 
   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
   CreateDirectory(subdir_path2);
   ASSERT_TRUE(PathExists(subdir_path2));
 
   // Delete non-recursively and check that the empty dir got deleted
   EXPECT_TRUE(DeleteFile(subdir_path2, false));
   EXPECT_FALSE(PathExists(subdir_path2));
 
   // Delete non-recursively and check that nothing got deleted
   EXPECT_FALSE(DeleteFile(test_subdir, false));
   EXPECT_TRUE(PathExists(test_subdir));
   EXPECT_TRUE(PathExists(file_name));
   EXPECT_TRUE(PathExists(subdir_path1));
 }
 
 // Tests recursive Delete() for a directory.
 TEST_F(FileUtilTest, DeleteDirRecursive) {
   // Create a subdirectory and put a file and two directories inside.
   FilePath test_subdir = temp_dir_.GetPath().Append(FPL("DeleteDirRecursive"));
   CreateDirectory(test_subdir);
   ASSERT_TRUE(PathExists(test_subdir));
 
   FilePath file_name = test_subdir.Append(FPL("Test DeleteDirRecursive.txt"));
-  CreateTextFile(file_name, bogus_content);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_name, bogus_content));
   ASSERT_TRUE(PathExists(file_name));
 
   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
   CreateDirectory(subdir_path1);
   ASSERT_TRUE(PathExists(subdir_path1));
 
   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
   CreateDirectory(subdir_path2);
   ASSERT_TRUE(PathExists(subdir_path2));
 
   // Delete recursively and check that the empty dir got deleted
   EXPECT_TRUE(DeleteFile(subdir_path2, true));
   EXPECT_FALSE(PathExists(subdir_path2));
 
   // Delete recursively and check that everything got deleted
   EXPECT_TRUE(DeleteFile(test_subdir, true));
   EXPECT_FALSE(PathExists(file_name));
   EXPECT_FALSE(PathExists(subdir_path1));
   EXPECT_FALSE(PathExists(test_subdir));
 }
 
 TEST_F(FileUtilTest, MoveFileNew) {
   // Create a file
   FilePath file_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination.
   FilePath file_name_to = temp_dir_.GetPath().Append(
       FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
   ASSERT_FALSE(PathExists(file_name_to));
 
   EXPECT_TRUE(Move(file_name_from, file_name_to));
 
   // Check everything has been moved.
   EXPECT_FALSE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, MoveFileExists) {
   // Create a file
   FilePath file_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination name.
   FilePath file_name_to = temp_dir_.GetPath().Append(
       FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
-  CreateTextFile(file_name_to, L"Old file content");
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_name_to, L"Old file content"));
   ASSERT_TRUE(PathExists(file_name_to));
 
   EXPECT_TRUE(Move(file_name_from, file_name_to));
 
   // Check everything has been moved.
   EXPECT_FALSE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(file_name_to));
   EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
 }
 
 TEST_F(FileUtilTest, MoveFileDirExists) {
   // Create a file
   FilePath file_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination directory
   FilePath dir_name_to =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
   CreateDirectory(dir_name_to);
   ASSERT_TRUE(PathExists(dir_name_to));
 
   EXPECT_FALSE(Move(file_name_from, dir_name_to));
 }
 
 
 TEST_F(FileUtilTest, MoveNew) {
   // Create a directory
   FilePath dir_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath txt_file_name(FILE_PATH_LITERAL("Move_Test_File.txt"));
   FilePath file_name_from = dir_name_from.Append(txt_file_name);
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Move the directory.
   FilePath dir_name_to =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
 
   ASSERT_FALSE(PathExists(dir_name_to));
 
@@ skipping 20 matching lines @@
 TEST_F(FileUtilTest, MoveExist) {
   // Create a directory
   FilePath dir_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Move the directory
   FilePath dir_name_exists =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
 
   FilePath dir_name_to =
       dir_name_exists.Append(FILE_PATH_LITERAL("Move_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
@@ skipping 14 matching lines @@
 TEST_F(FileUtilTest, CopyDirectoryRecursivelyNew) {
   // Create a directory.
   FilePath dir_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
   CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory recursively.
   FilePath dir_name_to =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   FilePath subdir_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
   FilePath file_name2_to =
@@ skipping 17 matching lines @@
 TEST_F(FileUtilTest, CopyDirectoryRecursivelyExists) {
   // Create a directory.
   FilePath dir_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
   CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory recursively.
   FilePath dir_name_exists =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
 
   FilePath dir_name_to =
       dir_name_exists.Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
@@ skipping 22 matching lines @@
 TEST_F(FileUtilTest, CopyDirectoryNew) {
   // Create a directory.
   FilePath dir_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
   CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory not recursively.
   FilePath dir_name_to =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   FilePath subdir_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
 
@@ skipping 14 matching lines @@
 TEST_F(FileUtilTest, CopyDirectoryExists) {
   // Create a directory.
   FilePath dir_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Create a subdirectory.
   FilePath subdir_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
   CreateDirectory(subdir_name_from);
   ASSERT_TRUE(PathExists(subdir_name_from));
 
   // Create a file under the subdirectory.
   FilePath file_name2_from =
       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name2_from));
 
   // Copy the directory not recursively.
   FilePath dir_name_to =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   FilePath subdir_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
 
@@ skipping 10 matching lines @@
   EXPECT_TRUE(PathExists(file_name2_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
   EXPECT_FALSE(PathExists(subdir_name_to));
 }
 
 TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToNew) {
   // Create a file
   FilePath file_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination name
   FilePath file_name_to = temp_dir_.GetPath().Append(
       FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
   ASSERT_FALSE(PathExists(file_name_to));
 
   EXPECT_TRUE(CopyDirectory(file_name_from, file_name_to, true));
 
   // Check the has been copied
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExisting) {
   // Create a file
   FilePath file_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination name
   FilePath file_name_to = temp_dir_.GetPath().Append(
       FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
-  CreateTextFile(file_name_to, L"Old file content");
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_name_to, L"Old file content"));
   ASSERT_TRUE(PathExists(file_name_to));
 
   EXPECT_TRUE(CopyDirectory(file_name_from, file_name_to, true));
 
   // Check the has been copied
   EXPECT_TRUE(PathExists(file_name_to));
   EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExistingDirectory) {
   // Create a file
   FilePath file_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // The destination
   FilePath dir_name_to =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Destination"));
   CreateDirectory(dir_name_to);
   ASSERT_TRUE(PathExists(dir_name_to));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
 
   EXPECT_TRUE(CopyDirectory(file_name_from, dir_name_to, true));
 
   // Check the has been copied
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
 TEST_F(FileUtilTest, CopyDirectoryWithTrailingSeparators) {
   // Create a directory.
   FilePath dir_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory.
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Copy the directory recursively.
   FilePath dir_name_to =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
 
   // Create from path with trailing separators.
 #if defined(OS_WIN)
   FilePath from_path =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir\\\\\\"));
 #elif defined(OS_POSIX)
   FilePath from_path =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir///"));
 #endif
 
   EXPECT_TRUE(CopyDirectory(from_path, dir_name_to, true));
 
   // Check everything has been copied.
   EXPECT_TRUE(PathExists(dir_name_from));
   EXPECT_TRUE(PathExists(file_name_from));
   EXPECT_TRUE(PathExists(dir_name_to));
   EXPECT_TRUE(PathExists(file_name_to));
 }
 
-// Sets the source file to read-only.
-void SetReadOnly(const FilePath& path, bool read_only) {
-#if defined(OS_WIN)
-  // On Windows, it involves setting/removing the 'readonly' bit.
-  DWORD attrs = GetFileAttributes(path.value().c_str());
-  ASSERT_NE(INVALID_FILE_ATTRIBUTES, attrs);
-  ASSERT_TRUE(SetFileAttributes(
-      path.value().c_str(),
-      read_only ? (attrs | FILE_ATTRIBUTE_READONLY) :
-          (attrs & ~FILE_ATTRIBUTE_READONLY)));
-
-  DWORD expected = read_only ?
-      ((attrs & (FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_DIRECTORY)) |
-          FILE_ATTRIBUTE_READONLY) :
-      (attrs & (FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_DIRECTORY));
-
-  // Ignore FILE_ATTRIBUTE_NOT_CONTENT_INDEXED if present.
-  attrs = GetFileAttributes(path.value().c_str()) &
-          ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
-  ASSERT_EQ(expected, attrs);
-#else
-  // On all other platforms, it involves removing/setting the write bit.
-  mode_t mode = read_only ? S_IRUSR : (S_IRUSR | S_IWUSR);
-  EXPECT_TRUE(SetPosixFilePermissions(
-      path, DirectoryExists(path) ? (mode | S_IXUSR) : mode));
-#endif
-}
-
-bool IsReadOnly(const FilePath& path) {
-#if defined(OS_WIN)
-  DWORD attrs = GetFileAttributes(path.value().c_str());
-  EXPECT_NE(INVALID_FILE_ATTRIBUTES, attrs);
-  return attrs & FILE_ATTRIBUTE_READONLY;
-#else
-  int mode = 0;
-  EXPECT_TRUE(GetPosixFilePermissions(path, &mode));
-  return !(mode & S_IWUSR);
-#endif
-}
-
 TEST_F(FileUtilTest, CopyDirectoryACL) {
   // Create source directories.
   FilePath src = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("src"));
   FilePath src_subdir = src.Append(FILE_PATH_LITERAL("subdir"));
   CreateDirectory(src_subdir);
   ASSERT_TRUE(PathExists(src_subdir));
 
   // Create a file under the directory.
   FilePath src_file = src.Append(FILE_PATH_LITERAL("src.txt"));
-  CreateTextFile(src_file, L"Gooooooooooooooooooooogle");
-  SetReadOnly(src_file, true);
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(src_file, L"Gooooooooooooooooooooogle"));
+  ASSERT_NO_FATAL_FAILURE(SetReadOnly(src_file, true));
   ASSERT_TRUE(IsReadOnly(src_file));
 
   // Make directory read-only.
-  SetReadOnly(src_subdir, true);
+  ASSERT_NO_FATAL_FAILURE(SetReadOnly(src_subdir, true));
   ASSERT_TRUE(IsReadOnly(src_subdir));
 
   // Copy the directory recursively.
   FilePath dst = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("dst"));
   FilePath dst_file = dst.Append(FILE_PATH_LITERAL("src.txt"));
   EXPECT_TRUE(CopyDirectory(src, dst, true));
 
   FilePath dst_subdir = dst.Append(FILE_PATH_LITERAL("subdir"));
   ASSERT_FALSE(IsReadOnly(dst_subdir));
   ASSERT_FALSE(IsReadOnly(dst_file));
 
   // Give write permissions to allow deletion.
-  SetReadOnly(src_subdir, false);
+  ASSERT_NO_FATAL_FAILURE(SetReadOnly(src_subdir, false));
   ASSERT_FALSE(IsReadOnly(src_subdir));
 }
 
 TEST_F(FileUtilTest, CopyFile) {
   // Create a directory
   FilePath dir_name_from =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
   const std::wstring file_contents(L"Gooooooooooooooooooooogle");
-  CreateTextFile(file_name_from, file_contents);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file_name_from, file_contents));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Copy the file.
   FilePath dest_file = dir_name_from.Append(FILE_PATH_LITERAL("DestFile.txt"));
   ASSERT_TRUE(CopyFile(file_name_from, dest_file));
 
   // Try to copy the file to another location using '..' in the path.
   FilePath dest_file2(dir_name_from);
   dest_file2 = dest_file2.AppendASCII("..");
   dest_file2 = dest_file2.AppendASCII("DestFile.txt");
@@ skipping 11 matching lines @@
   EXPECT_FALSE(PathExists(dest_file2_test));
   EXPECT_FALSE(PathExists(dest_file2));
 }
 
 TEST_F(FileUtilTest, CopyFileACL) {
   // While FileUtilTest.CopyFile asserts the content is correctly copied over,
   // this test case asserts the access control bits are meeting expectations in
   // CopyFile().
   FilePath src = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("src.txt"));
   const std::wstring file_contents(L"Gooooooooooooooooooooogle");
-  CreateTextFile(src, file_contents);
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(src, file_contents));
 
   // Set the source file to read-only.
   ASSERT_FALSE(IsReadOnly(src));
-  SetReadOnly(src, true);
+  ASSERT_NO_FATAL_FAILURE(SetReadOnly(src, true));
   ASSERT_TRUE(IsReadOnly(src));
 
   // Copy the file.
   FilePath dst = temp_dir_.GetPath().Append(FILE_PATH_LITERAL("dst.txt"));
   ASSERT_TRUE(CopyFile(src, dst));
   EXPECT_EQ(file_contents, ReadTextFile(dst));
 
   ASSERT_FALSE(IsReadOnly(dst));
 }
 
@@ skipping 97 matching lines @@
 TEST_F(FileUtilTest, CopyAndDeleteDirectoryTest) {
   // Create a directory
   FilePath dir_name_from = temp_dir_.GetPath().Append(
       FILE_PATH_LITERAL("CopyAndDelete_From_Subdir"));
   CreateDirectory(dir_name_from);
   ASSERT_TRUE(PathExists(dir_name_from));
 
   // Create a file under the directory
   FilePath file_name_from =
       dir_name_from.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
-  CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
+  ASSERT_NO_FATAL_FAILURE(
+      CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle"));
   ASSERT_TRUE(PathExists(file_name_from));
 
   // Move the directory by using CopyAndDeleteDirectory
   FilePath dir_name_to =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("CopyAndDelete_To_Subdir"));
   FilePath file_name_to =
       dir_name_to.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
 
   ASSERT_FALSE(PathExists(dir_name_to));
 
@@ skipping 137 matching lines @@
 
   EXPECT_FALSE(PathExists(test_path));
   EXPECT_TRUE(CreateDirectory(test_path));
   EXPECT_TRUE(PathExists(test_path));
   // CreateDirectory returns true if the DirectoryExists returns true.
   EXPECT_TRUE(CreateDirectory(test_path));
 
   // Doesn't work to create it on top of a non-dir
   test_path = test_path.Append(FILE_PATH_LITERAL("foobar.txt"));
   EXPECT_FALSE(PathExists(test_path));
-  CreateTextFile(test_path, L"test file");
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(test_path, L"test file"));
   EXPECT_TRUE(PathExists(test_path));
   EXPECT_FALSE(CreateDirectory(test_path));
 
   EXPECT_TRUE(DeleteFile(test_root, true));
   EXPECT_FALSE(PathExists(test_root));
   EXPECT_FALSE(PathExists(test_path));
 
   // Verify assumptions made by the Windows implementation:
   // 1. The current directory always exists.
   // 2. The root directory always exists.
@@ skipping 25 matching lines @@
   FilePath test_root =
       temp_dir_.GetPath().Append(FILE_PATH_LITERAL("detect_directory_test"));
   EXPECT_FALSE(PathExists(test_root));
   EXPECT_TRUE(CreateDirectory(test_root));
   EXPECT_TRUE(PathExists(test_root));
   EXPECT_TRUE(DirectoryExists(test_root));
   // Check a file
   FilePath test_path =
       test_root.Append(FILE_PATH_LITERAL("foobar.txt"));
   EXPECT_FALSE(PathExists(test_path));
-  CreateTextFile(test_path, L"test file");
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(test_path, L"test file"));
   EXPECT_TRUE(PathExists(test_path));
   EXPECT_FALSE(DirectoryExists(test_path));
   EXPECT_TRUE(DeleteFile(test_path, false));
 
   EXPECT_TRUE(DeleteFile(test_root, true));
 }
 
 TEST_F(FileUtilTest, FileEnumeratorTest) {
   // Test an empty directory.
   FileEnumerator f0(temp_dir_.GetPath(), true, FILES_AND_DIRECTORIES);
@@ skipping 11 matching lines @@
   // create the directories
   FilePath dir1 = temp_dir_.GetPath().Append(FPL("dir1"));
   EXPECT_TRUE(CreateDirectory(dir1));
   FilePath dir2 = temp_dir_.GetPath().Append(FPL("dir2"));
   EXPECT_TRUE(CreateDirectory(dir2));
   FilePath dir2inner = dir2.Append(FPL("inner"));
   EXPECT_TRUE(CreateDirectory(dir2inner));
 
   // create the files
   FilePath dir2file = dir2.Append(FPL("dir2file.txt"));
-  CreateTextFile(dir2file, std::wstring());
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(dir2file, std::wstring()));
   FilePath dir2innerfile = dir2inner.Append(FPL("innerfile.txt"));
-  CreateTextFile(dir2innerfile, std::wstring());
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(dir2innerfile, std::wstring()));
   FilePath file1 = temp_dir_.GetPath().Append(FPL("file1.txt"));
-  CreateTextFile(file1, std::wstring());
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file1, std::wstring()));
   FilePath file2_rel = dir2.Append(FilePath::kParentDirectory)
       .Append(FPL("file2.txt"));
-  CreateTextFile(file2_rel, std::wstring());
+  ASSERT_NO_FATAL_FAILURE(CreateTextFile(file2_rel, std::wstring()));
   FilePath file2_abs = temp_dir_.GetPath().Append(FPL("file2.txt"));
 
   // Only enumerate files.
   FileEnumerator f1(temp_dir_.GetPath(), true, FileEnumerator::FILES);
   FindResultCollector c1(&f1);
   EXPECT_TRUE(c1.HasFile(file1));
   EXPECT_TRUE(c1.HasFile(file2_abs));
   EXPECT_TRUE(c1.HasFile(dir2file));
   EXPECT_TRUE(c1.HasFile(dir2innerfile));
   EXPECT_EQ(4, c1.size());
@@ skipping 306 matching lines @@
     //  |-> sub_dir_
     //       |-> text_file_
 
     base_dir_ = temp_dir_.GetPath().AppendASCII("base_dir");
     ASSERT_TRUE(CreateDirectory(base_dir_));
 
     sub_dir_ = base_dir_.AppendASCII("sub_dir");
     ASSERT_TRUE(CreateDirectory(sub_dir_));
 
     text_file_ = sub_dir_.AppendASCII("file.txt");
-    CreateTextFile(text_file_, L"This text file has some text in it.");
+    ASSERT_NO_FATAL_FAILURE(
+        CreateTextFile(text_file_, L"This text file has some text in it."));
 
     // Get the user and group files are created with from |base_dir_|.
     struct stat stat_buf;
     ASSERT_EQ(0, stat(base_dir_.value().c_str(), &stat_buf));
     uid_ = stat_buf.st_uid;
     ok_gids_.insert(stat_buf.st_gid);
     bad_gids_.insert(stat_buf.st_gid + 1);
 
     ASSERT_EQ(uid_, getuid());  // This process should be the owner.
 
@@ skipping 323 matching lines @@
   // Trying to close it should crash. This is important for security.
   EXPECT_DEATH(CloseWithScopedFD(fds[1]), "");
 #endif
 }
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace
 
 }  // namespace base