Move PathIsWritable, DirectoryExists, ContentsEqual, and TextContentsEqual to the base namespace.

base/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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #include <shlobj.h>
@@ skipping 17 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_handle.h"
 #endif
 
 // This macro helps avoid wrapped lines in the test structs.
 #define FPL(x) FILE_PATH_LITERAL(x)
 
+using base::DirectoryExists;
 using base::FileEnumerator;
 using base::FilePath;
+using base::PathIsWritable;
+using base::TextContentsEqual;
 
 namespace {
 
 // To test that file_util::Normalize FilePath() deals with NTFS reparse points
 // correctly, we need functions to create and delete reparse points.
 #if defined(OS_WIN)
 typedef struct _REPARSE_DATA_BUFFER {
   ULONG  ReparseTag;
   USHORT  ReparseDataLength;
   USHORT  Reserved;
@@ skipping 805 matching lines @@
 
   // Write file.
   EXPECT_EQ(static_cast<int>(kData.length()),
             file_util::WriteFile(file_name, kData.data(), kData.length()));
   EXPECT_TRUE(base::PathExists(file_name));
 
   // Make sure the file is writable.
   int mode = 0;
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
   EXPECT_TRUE(mode & file_util::FILE_PERMISSION_WRITE_BY_USER);
-  EXPECT_TRUE(file_util::PathIsWritable(file_name));
+  EXPECT_TRUE(PathIsWritable(file_name));
 
   // Get rid of the write permission.
   EXPECT_TRUE(file_util::SetPosixFilePermissions(file_name, 0u));
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
   EXPECT_FALSE(mode & file_util::FILE_PERMISSION_WRITE_BY_USER);
   // Make sure the file can't be write.
   EXPECT_EQ(-1,
             file_util::WriteFile(file_name, kData.data(), kData.length()));
-  EXPECT_FALSE(file_util::PathIsWritable(file_name));
+  EXPECT_FALSE(PathIsWritable(file_name));
 
   // Give read permission.
   EXPECT_TRUE(file_util::SetPosixFilePermissions(
       file_name,
       file_util::FILE_PERMISSION_WRITE_BY_USER));
   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
   EXPECT_TRUE(mode & file_util::FILE_PERMISSION_WRITE_BY_USER);
   // Make sure the file can be write.
   EXPECT_EQ(static_cast<int>(kData.length()),
             file_util::WriteFile(file_name, kData.data(), kData.length()));
-  EXPECT_TRUE(file_util::PathIsWritable(file_name));
+  EXPECT_TRUE(PathIsWritable(file_name));
 
   // Delete the file.
   EXPECT_TRUE(base::Delete(file_name, false));
   EXPECT_FALSE(base::PathExists(file_name));
 }
 
 TEST_F(FileUtilTest, ChangeDirectoryPermissionsAndEnumerate) {
   // Create a directory path.
   FilePath subdir_path =
       temp_dir_.path().Append(FPL("PermissionTest1"));
@@ skipping 654 matching lines @@
       data_dir.Append(FILE_PATH_LITERAL("empty2.txt"));
   FilePath shortened_file =
       data_dir.Append(FILE_PATH_LITERAL("shortened.txt"));
   FilePath binary_file =
       data_dir.Append(FILE_PATH_LITERAL("binary_file.bin"));
   FilePath binary_file_same =
       data_dir.Append(FILE_PATH_LITERAL("binary_file_same.bin"));
   FilePath binary_file_diff =
       data_dir.Append(FILE_PATH_LITERAL("binary_file_diff.bin"));
 
-  EXPECT_TRUE(file_util::ContentsEqual(original_file, original_file));
-  EXPECT_TRUE(file_util::ContentsEqual(original_file, same_file));
-  EXPECT_FALSE(file_util::ContentsEqual(original_file, same_length_file));
-  EXPECT_FALSE(file_util::ContentsEqual(original_file, different_file));
-  EXPECT_FALSE(file_util::ContentsEqual(
-      FilePath(FILE_PATH_LITERAL("bogusname")),
-      FilePath(FILE_PATH_LITERAL("bogusname"))));
-  EXPECT_FALSE(file_util::ContentsEqual(original_file, different_first_file));
-  EXPECT_FALSE(file_util::ContentsEqual(original_file, different_last_file));
-  EXPECT_TRUE(file_util::ContentsEqual(empty1_file, empty2_file));
-  EXPECT_FALSE(file_util::ContentsEqual(original_file, shortened_file));
-  EXPECT_FALSE(file_util::ContentsEqual(shortened_file, original_file));
-  EXPECT_TRUE(file_util::ContentsEqual(binary_file, binary_file_same));
-  EXPECT_FALSE(file_util::ContentsEqual(binary_file, binary_file_diff));
+  EXPECT_TRUE(ContentsEqual(original_file, original_file));
+  EXPECT_TRUE(ContentsEqual(original_file, same_file));
+  EXPECT_FALSE(ContentsEqual(original_file, same_length_file));
+  EXPECT_FALSE(ContentsEqual(original_file, different_file));
+  EXPECT_FALSE(ContentsEqual(FilePath(FILE_PATH_LITERAL("bogusname")),
+                             FilePath(FILE_PATH_LITERAL("bogusname"))));
+  EXPECT_FALSE(ContentsEqual(original_file, different_first_file));
+  EXPECT_FALSE(ContentsEqual(original_file, different_last_file));
+  EXPECT_TRUE(ContentsEqual(empty1_file, empty2_file));
+  EXPECT_FALSE(ContentsEqual(original_file, shortened_file));
+  EXPECT_FALSE(ContentsEqual(shortened_file, original_file));
+  EXPECT_TRUE(ContentsEqual(binary_file, binary_file_same));
+  EXPECT_FALSE(ContentsEqual(binary_file, binary_file_diff));
 }
 
 TEST_F(ReadOnlyFileUtilTest, TextContentsEqual) {
   FilePath data_dir;
   ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir));
   data_dir = data_dir.AppendASCII("file_util");
   ASSERT_TRUE(base::PathExists(data_dir));
 
   FilePath original_file =
       data_dir.Append(FILE_PATH_LITERAL("original.txt"));
@@ skipping 15 matching lines @@
       data_dir.Append(FILE_PATH_LITERAL("first2.txt"));
   FilePath empty1_file =
       data_dir.Append(FILE_PATH_LITERAL("empty1.txt"));
   FilePath empty2_file =
       data_dir.Append(FILE_PATH_LITERAL("empty2.txt"));
   FilePath blank_line_file =
       data_dir.Append(FILE_PATH_LITERAL("blank_line.txt"));
   FilePath blank_line_crlf_file =
       data_dir.Append(FILE_PATH_LITERAL("blank_line_crlf.txt"));
 
-  EXPECT_TRUE(file_util::TextContentsEqual(original_file, same_file));
-  EXPECT_TRUE(file_util::TextContentsEqual(original_file, crlf_file));
-  EXPECT_FALSE(file_util::TextContentsEqual(original_file, shortened_file));
-  EXPECT_FALSE(file_util::TextContentsEqual(original_file, different_file));
-  EXPECT_FALSE(file_util::TextContentsEqual(original_file,
-                                            different_first_file));
-  EXPECT_FALSE(file_util::TextContentsEqual(original_file,
-                                            different_last_file));
-  EXPECT_FALSE(file_util::TextContentsEqual(first1_file, first2_file));
-  EXPECT_TRUE(file_util::TextContentsEqual(empty1_file, empty2_file));
-  EXPECT_FALSE(file_util::TextContentsEqual(original_file, empty1_file));
-  EXPECT_TRUE(file_util::TextContentsEqual(blank_line_file,
-                                           blank_line_crlf_file));
+  EXPECT_TRUE(TextContentsEqual(original_file, same_file));
+  EXPECT_TRUE(TextContentsEqual(original_file, crlf_file));
+  EXPECT_FALSE(TextContentsEqual(original_file, shortened_file));
+  EXPECT_FALSE(TextContentsEqual(original_file, different_file));
+  EXPECT_FALSE(TextContentsEqual(original_file, different_first_file));
+  EXPECT_FALSE(TextContentsEqual(original_file, different_last_file));
+  EXPECT_FALSE(TextContentsEqual(first1_file, first2_file));
+  EXPECT_TRUE(TextContentsEqual(empty1_file, empty2_file));
+  EXPECT_FALSE(TextContentsEqual(original_file, empty1_file));
+  EXPECT_TRUE(TextContentsEqual(blank_line_file, blank_line_crlf_file));
 }
 
 // We don't need equivalent functionality outside of Windows.
 #if defined(OS_WIN)
 TEST_F(FileUtilTest, CopyAndDeleteDirectoryTest) {
   // Create a directory
   FilePath dir_name_from =
       temp_dir_.path().Append(FILE_PATH_LITERAL("CopyAndDelete_From_Subdir"));
   file_util::CreateDirectory(dir_name_from);
   ASSERT_TRUE(base::PathExists(dir_name_from));
@@ skipping 49 matching lines @@
     ::_tputenv_s(kTmpKey, _T(""));
   }
 }
 #endif  // OS_WIN
 
 TEST_F(FileUtilTest, CreateTemporaryFileTest) {
   FilePath temp_files[3];
   for (int i = 0; i < 3; i++) {
     ASSERT_TRUE(file_util::CreateTemporaryFile(&(temp_files[i])));
     EXPECT_TRUE(base::PathExists(temp_files[i]));
-    EXPECT_FALSE(file_util::DirectoryExists(temp_files[i]));
+    EXPECT_FALSE(DirectoryExists(temp_files[i]));
   }
   for (int i = 0; i < 3; i++)
     EXPECT_FALSE(temp_files[i] == temp_files[(i+1)%3]);
   for (int i = 0; i < 3; i++)
     EXPECT_TRUE(base::Delete(temp_files[i], false));
 }
 
 TEST_F(FileUtilTest, CreateAndOpenTemporaryFileTest) {
   FilePath names[3];
   FILE* fps[3];
@@ skipping 33 matching lines @@
                   FILE_PATH_LITERAL("CreateNewTemporaryDirInDirTest"),
                   &new_dir));
   EXPECT_TRUE(base::PathExists(new_dir));
   EXPECT_TRUE(temp_dir_.path().IsParent(new_dir));
   EXPECT_TRUE(base::Delete(new_dir, false));
 }
 
 TEST_F(FileUtilTest, GetShmemTempDirTest) {
   FilePath dir;
   EXPECT_TRUE(file_util::GetShmemTempDir(&dir, false));
-  EXPECT_TRUE(file_util::DirectoryExists(dir));
+  EXPECT_TRUE(DirectoryExists(dir));
 }
 
 TEST_F(FileUtilTest, CreateDirectoryTest) {
   FilePath test_root =
       temp_dir_.path().Append(FILE_PATH_LITERAL("create_directory_test"));
 #if defined(OS_WIN)
   FilePath test_path =
       test_root.Append(FILE_PATH_LITERAL("dir\\tree\\likely\\doesnt\\exist\\"));
 #elif defined(OS_POSIX)
   FilePath test_path =
@@ skipping 13 matching lines @@
   EXPECT_TRUE(base::PathExists(test_path));
   EXPECT_FALSE(file_util::CreateDirectory(test_path));
 
   EXPECT_TRUE(base::Delete(test_root, true));
   EXPECT_FALSE(base::PathExists(test_root));
   EXPECT_FALSE(base::PathExists(test_path));
 
   // Verify assumptions made by the Windows implementation:
   // 1. The current directory always exists.
   // 2. The root directory always exists.
-  ASSERT_TRUE(file_util::DirectoryExists(
-      FilePath(FilePath::kCurrentDirectory)));
+  ASSERT_TRUE(DirectoryExists(FilePath(FilePath::kCurrentDirectory)));
   FilePath top_level = test_root;
   while (top_level != top_level.DirName()) {
     top_level = top_level.DirName();
   }
-  ASSERT_TRUE(file_util::DirectoryExists(top_level));
+  ASSERT_TRUE(DirectoryExists(top_level));
 
   // Given these assumptions hold, it should be safe to
   // test that "creating" these directories succeeds.
   EXPECT_TRUE(file_util::CreateDirectory(
       FilePath(FilePath::kCurrentDirectory)));
   EXPECT_TRUE(file_util::CreateDirectory(top_level));
 
 #if defined(OS_WIN)
   FilePath invalid_drive(FILE_PATH_LITERAL("o:\\"));
   FilePath invalid_path =
       invalid_drive.Append(FILE_PATH_LITERAL("some\\inaccessible\\dir"));
   if (!base::PathExists(invalid_drive)) {
     EXPECT_FALSE(file_util::CreateDirectory(invalid_path));
   }
 #endif
 }
 
 TEST_F(FileUtilTest, DetectDirectoryTest) {
   // Check a directory
   FilePath test_root =
       temp_dir_.path().Append(FILE_PATH_LITERAL("detect_directory_test"));
   EXPECT_FALSE(base::PathExists(test_root));
   EXPECT_TRUE(file_util::CreateDirectory(test_root));
   EXPECT_TRUE(base::PathExists(test_root));
-  EXPECT_TRUE(file_util::DirectoryExists(test_root));
+  EXPECT_TRUE(DirectoryExists(test_root));
   // Check a file
   FilePath test_path =
       test_root.Append(FILE_PATH_LITERAL("foobar.txt"));
   EXPECT_FALSE(base::PathExists(test_path));
   CreateTextFile(test_path, L"test file");
   EXPECT_TRUE(base::PathExists(test_path));
-  EXPECT_FALSE(file_util::DirectoryExists(test_path));
+  EXPECT_FALSE(DirectoryExists(test_path));
   EXPECT_TRUE(base::Delete(test_path, false));
 
   EXPECT_TRUE(base::Delete(test_root, true));
 }
 
 TEST_F(FileUtilTest, FileEnumeratorTest) {
   // Test an empty directory.
   FileEnumerator f0(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
   EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
   EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
@@ skipping 546 matching lines @@
       file_util::VerifyPathControlledByUser(
           base_dir_, text_file_, uid_, ok_gids_));
   EXPECT_TRUE(
       file_util::VerifyPathControlledByUser(
           sub_dir_, text_file_, uid_, ok_gids_));
 }
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace