base/file_util_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "build/build_config.h"
   6
   7 #if defined(OS_WIN)
   8 #include <windows.h>
   9 #include <shellapi.h>
  10 #include <shlobj.h>
  11 #include <tchar.h>
  12 #include <winioctl.h>
  13 #endif
  14
  15 #include <algorithm>
  16 #include <fstream>
  17 #include <set>
  18
  19 #include "base/base_paths.h"
  20 #include "base/file_util.h"
  21 #include "base/files/file_enumerator.h"
  22 #include "base/files/file_path.h"
  23 #include "base/files/scoped_temp_dir.h"
  24 #include "base/path_service.h"
  25 #include "base/strings/utf_string_conversions.h"
  26 #include "base/test/test_file_util.h"
  27 #include "base/threading/platform_thread.h"
  28 #include "testing/gtest/include/gtest/gtest.h"
  29 #include "testing/platform_test.h"
  30
  31 #if defined(OS_WIN)
  32 #include "base/win/scoped_handle.h"
  33 #endif
  34
  35 // This macro helps avoid wrapped lines in the test structs.
  36 #define FPL(x) FILE_PATH_LITERAL(x)
  37
  38 using base::FileEnumerator;
  39 using base::FilePath;
  40
  41 namespace {
  42
  43 // To test that file_util::Normalize FilePath() deals with NTFS reparse points
  44 // correctly, we need functions to create and delete reparse points.
  45 #if defined(OS_WIN)
  46 typedef struct _REPARSE_DATA_BUFFER {
  47   ULONG  ReparseTag;
  48   USHORT  ReparseDataLength;
  49   USHORT  Reserved;
  50   union {
  51     struct {
  52       USHORT SubstituteNameOffset;
  53       USHORT SubstituteNameLength;
  54       USHORT PrintNameOffset;
  55       USHORT PrintNameLength;
  56       ULONG Flags;
  57       WCHAR PathBuffer[1];
  58     } SymbolicLinkReparseBuffer;
  59     struct {
  60       USHORT SubstituteNameOffset;
  61       USHORT SubstituteNameLength;
  62       USHORT PrintNameOffset;
  63       USHORT PrintNameLength;
  64       WCHAR PathBuffer[1];
  65     } MountPointReparseBuffer;
  66     struct {
  67       UCHAR DataBuffer[1];
  68     } GenericReparseBuffer;
  69   };
  70 } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
  71
  72 // Sets a reparse point. |source| will now point to |target|. Returns true if
  73 // the call succeeds, false otherwise.
  74 bool SetReparsePoint(HANDLE source, const FilePath& target_path) {
  75   std::wstring kPathPrefix = L"\\??\\";
  76   std::wstring target_str;
  77   // The juction will not work if the target path does not start with \??\ .
  78   if (kPathPrefix != target_path.value().substr(0, kPathPrefix.size()))
  79     target_str += kPathPrefix;
  80   target_str += target_path.value();
  81   const wchar_t* target = target_str.c_str();
  82   USHORT size_target = static_cast<USHORT>(wcslen(target)) * sizeof(target[0]);
  83   char buffer[2000] = {0};
  84   DWORD returned;
  85
  86   REPARSE_DATA_BUFFER* data = reinterpret_cast<REPARSE_DATA_BUFFER*>(buffer);
  87
  88   data->ReparseTag = 0xa0000003;
  89   memcpy(data->MountPointReparseBuffer.PathBuffer, target, size_target + 2);
  90
  91   data->MountPointReparseBuffer.SubstituteNameLength = size_target;
  92   data->MountPointReparseBuffer.PrintNameOffset = size_target + 2;
  93   data->ReparseDataLength = size_target + 4 + 8;
  94
  95   int data_size = data->ReparseDataLength + 8;
  96
  97   if (!DeviceIoControl(source, FSCTL_SET_REPARSE_POINT, &buffer, data_size,
  98                        NULL, 0, &returned, NULL)) {
  99     return false;
 100   }
 101   return true;
 102 }
 103
 104 // Delete the reparse point referenced by |source|. Returns true if the call
 105 // succeeds, false otherwise.
 106 bool DeleteReparsePoint(HANDLE source) {
 107   DWORD returned;
 108   REPARSE_DATA_BUFFER data = {0};
 109   data.ReparseTag = 0xa0000003;
 110   if (!DeviceIoControl(source, FSCTL_DELETE_REPARSE_POINT, &data, 8, NULL, 0,
 111                        &returned, NULL)) {
 112     return false;
 113   }
 114   return true;
 115 }
 116 #endif
 117
 118 #if defined(OS_POSIX)
 119 // Provide a simple way to change the permissions bits on |path| in tests.
 120 // ASSERT failures will return, but not stop the test.  Caller should wrap
 121 // calls to this function in ASSERT_NO_FATAL_FAILURE().
 122 void ChangePosixFilePermissions(const FilePath& path,
 123                                 int mode_bits_to_set,
 124                                 int mode_bits_to_clear) {
 125   ASSERT_FALSE(mode_bits_to_set & mode_bits_to_clear)
 126       << "Can't set and clear the same bits.";
 127
 128   int mode = 0;
 129   ASSERT_TRUE(file_util::GetPosixFilePermissions(path, &mode));
 130   mode |= mode_bits_to_set;
 131   mode &= ~mode_bits_to_clear;
 132   ASSERT_TRUE(file_util::SetPosixFilePermissions(path, mode));
 133 }
 134 #endif  // defined(OS_POSIX)
 135
 136 const wchar_t bogus_content[] = L"I'm cannon fodder.";
 137
 138 const int FILES_AND_DIRECTORIES =
 139     FileEnumerator::FILES | FileEnumerator::DIRECTORIES;
 140
 141 // file_util winds up using autoreleased objects on the Mac, so this needs
 142 // to be a PlatformTest
 143 class FileUtilTest : public PlatformTest {
 144  protected:
 145   virtual void SetUp() OVERRIDE {
 146     PlatformTest::SetUp();
 147     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 148   }
 149
 150   base::ScopedTempDir temp_dir_;
 151 };
 152
 153 // Collects all the results from the given file enumerator, and provides an
 154 // interface to query whether a given file is present.
 155 class FindResultCollector {
 156  public:
 157   explicit FindResultCollector(FileEnumerator& enumerator) {
 158     FilePath cur_file;
 159     while (!(cur_file = enumerator.Next()).value().empty()) {
 160       FilePath::StringType path = cur_file.value();
 161       // The file should not be returned twice.
 162       EXPECT_TRUE(files_.end() == files_.find(path))
 163           << "Same file returned twice";
 164
 165       // Save for later.
 166       files_.insert(path);
 167     }
 168   }
 169
 170   // Returns true if the enumerator found the file.
 171   bool HasFile(const FilePath& file) const {
 172     return files_.find(file.value()) != files_.end();
 173   }
 174
 175   int size() {
 176     return static_cast<int>(files_.size());
 177   }
 178
 179  private:
 180   std::set<FilePath::StringType> files_;
 181 };
 182
 183 // Simple function to dump some text into a new file.
 184 void CreateTextFile(const FilePath& filename,
 185                     const std::wstring& contents) {
 186   std::wofstream file;
 187   file.open(filename.value().c_str());
 188   ASSERT_TRUE(file.is_open());
 189   file << contents;
 190   file.close();
 191 }
 192
 193 // Simple function to take out some text from a file.
 194 std::wstring ReadTextFile(const FilePath& filename) {
 195   wchar_t contents[64];
 196   std::wifstream file;
 197   file.open(filename.value().c_str());
 198   EXPECT_TRUE(file.is_open());
 199   file.getline(contents, arraysize(contents));
 200   file.close();
 201   return std::wstring(contents);
 202 }
 203
 204 #if defined(OS_WIN)
 205 uint64 FileTimeAsUint64(const FILETIME& ft) {
 206   ULARGE_INTEGER u;
 207   u.LowPart = ft.dwLowDateTime;
 208   u.HighPart = ft.dwHighDateTime;
 209   return u.QuadPart;
 210 }
 211 #endif
 212
 213 const struct append_case {
 214   const wchar_t* path;
 215   const wchar_t* ending;
 216   const wchar_t* result;
 217 } append_cases[] = {
 218 #if defined(OS_WIN)
 219   {L"c:\\colon\\backslash", L"path", L"c:\\colon\\backslash\\path"},
 220   {L"c:\\colon\\backslash\\", L"path", L"c:\\colon\\backslash\\path"},
 221   {L"c:\\colon\\backslash\\\\", L"path", L"c:\\colon\\backslash\\\\path"},
 222   {L"c:\\colon\\backslash\\", L"", L"c:\\colon\\backslash\\"},
 223   {L"c:\\colon\\backslash", L"", L"c:\\colon\\backslash\\"},
 224   {L"", L"path", L"\\path"},
 225   {L"", L"", L"\\"},
 226 #elif defined(OS_POSIX)
 227   {L"/foo/bar", L"path", L"/foo/bar/path"},
 228   {L"/foo/bar/", L"path", L"/foo/bar/path"},
 229   {L"/foo/bar//", L"path", L"/foo/bar//path"},
 230   {L"/foo/bar/", L"", L"/foo/bar/"},
 231   {L"/foo/bar", L"", L"/foo/bar/"},
 232   {L"", L"path", L"/path"},
 233   {L"", L"", L"/"},
 234 #endif
 235 };
 236
 237 static const struct filename_case {
 238   const wchar_t* path;
 239   const wchar_t* filename;
 240 } filename_cases[] = {
 241 #if defined(OS_WIN)
 242   {L"c:\\colon\\backslash", L"backslash"},
 243   {L"c:\\colon\\backslash\\", L""},
 244   {L"\\\\filename.exe", L"filename.exe"},
 245   {L"filename.exe", L"filename.exe"},
 246   {L"", L""},
 247   {L"\\\\\\", L""},
 248   {L"c:/colon/backslash", L"backslash"},
 249   {L"c:/colon/backslash/", L""},
 250   {L"//////", L""},
 251   {L"///filename.exe", L"filename.exe"},
 252 #elif defined(OS_POSIX)
 253   {L"/foo/bar", L"bar"},
 254   {L"/foo/bar/", L""},
 255   {L"/filename.exe", L"filename.exe"},
 256   {L"filename.exe", L"filename.exe"},
 257   {L"", L""},
 258   {L"/", L""},
 259 #endif
 260 };
 261
 262 // Test finding the file type from a path name
 263 static const struct extension_case {
 264   const wchar_t* path;
 265   const wchar_t* extension;
 266 } extension_cases[] = {
 267 #if defined(OS_WIN)
 268   {L"C:\\colon\\backslash\\filename.extension", L"extension"},
 269   {L"C:\\colon\\backslash\\filename.", L""},
 270   {L"C:\\colon\\backslash\\filename", L""},
 271   {L"C:\\colon\\backslash\\", L""},
 272   {L"C:\\colon\\backslash.\\", L""},
 273   {L"C:\\colon\\backslash\filename.extension.extension2", L"extension2"},
 274 #elif defined(OS_POSIX)
 275   {L"/foo/bar/filename.extension", L"extension"},
 276   {L"/foo/bar/filename.", L""},
 277   {L"/foo/bar/filename", L""},
 278   {L"/foo/bar/", L""},
 279   {L"/foo/bar./", L""},
 280   {L"/foo/bar/filename.extension.extension2", L"extension2"},
 281   {L".", L""},
 282   {L"..", L""},
 283   {L"./foo", L""},
 284   {L"./foo.extension", L"extension"},
 285   {L"/foo.extension1/bar.extension2", L"extension2"},
 286 #endif
 287 };
 288
 289 // Test finding the directory component of a path
 290 static const struct dir_case {
 291   const wchar_t* full_path;
 292   const wchar_t* directory;
 293 } dir_cases[] = {
 294 #if defined(OS_WIN)
 295   {L"C:\\WINDOWS\\system32\\gdi32.dll", L"C:\\WINDOWS\\system32"},
 296   {L"C:\\WINDOWS\\system32\\not_exist_thx_1138", L"C:\\WINDOWS\\system32"},
 297   {L"C:\\WINDOWS\\system32\\", L"C:\\WINDOWS\\system32"},
 298   {L"C:\\WINDOWS\\system32\\\\", L"C:\\WINDOWS\\system32"},
 299   {L"C:\\WINDOWS\\system32", L"C:\\WINDOWS"},
 300   {L"C:\\WINDOWS\\system32.\\", L"C:\\WINDOWS\\system32."},
 301   {L"C:\\", L"C:\\"},
 302 #elif defined(OS_POSIX)
 303   {L"/foo/bar/gdi32.dll", L"/foo/bar"},
 304   {L"/foo/bar/not_exist_thx_1138", L"/foo/bar"},
 305   {L"/foo/bar/", L"/foo/bar"},
 306   {L"/foo/bar//", L"/foo/bar"},
 307   {L"/foo/bar", L"/foo"},
 308   {L"/foo/bar./", L"/foo/bar."},
 309   {L"/", L"/"},
 310   {L".", L"."},
 311   {L"..", L"."},  // yes, ".." technically lives in "."
 312 #endif
 313 };
 314
 315 TEST_F(FileUtilTest, FileAndDirectorySize) {
 316   // Create three files of 20, 30 and 3 chars (utf8). ComputeDirectorySize
 317   // should return 53 bytes.
 318   FilePath file_01 = temp_dir_.path().Append(FPL("The file 01.txt"));
 319   CreateTextFile(file_01, L"12345678901234567890");
 320   int64 size_f1 = 0;
 321   ASSERT_TRUE(file_util::GetFileSize(file_01, &size_f1));
 322   EXPECT_EQ(20ll, size_f1);
 323
 324   FilePath subdir_path = temp_dir_.path().Append(FPL("Level2"));
 325   file_util::CreateDirectory(subdir_path);
 326
 327   FilePath file_02 = subdir_path.Append(FPL("The file 02.txt"));
 328   CreateTextFile(file_02, L"123456789012345678901234567890");
 329   int64 size_f2 = 0;
 330   ASSERT_TRUE(file_util::GetFileSize(file_02, &size_f2));
 331   EXPECT_EQ(30ll, size_f2);
 332
 333   FilePath subsubdir_path = subdir_path.Append(FPL("Level3"));
 334   file_util::CreateDirectory(subsubdir_path);
 335
 336   FilePath file_03 = subsubdir_path.Append(FPL("The file 03.txt"));
 337   CreateTextFile(file_03, L"123");
 338
 339   int64 computed_size = file_util::ComputeDirectorySize(temp_dir_.path());
 340   EXPECT_EQ(size_f1 + size_f2 + 3, computed_size);
 341 }
 342
 343 TEST_F(FileUtilTest, NormalizeFilePathBasic) {
 344   // Create a directory under the test dir.  Because we create it,
 345   // we know it is not a link.
 346   FilePath file_a_path = temp_dir_.path().Append(FPL("file_a"));
 347   FilePath dir_path = temp_dir_.path().Append(FPL("dir"));
 348   FilePath file_b_path = dir_path.Append(FPL("file_b"));
 349   file_util::CreateDirectory(dir_path);
 350
 351   FilePath normalized_file_a_path, normalized_file_b_path;
 352   ASSERT_FALSE(file_util::PathExists(file_a_path));
 353   ASSERT_FALSE(file_util::NormalizeFilePath(file_a_path,
 354                                             &normalized_file_a_path))
 355     << "NormalizeFilePath() should fail on nonexistent paths.";
 356
 357   CreateTextFile(file_a_path, bogus_content);
 358   ASSERT_TRUE(file_util::PathExists(file_a_path));
 359   ASSERT_TRUE(file_util::NormalizeFilePath(file_a_path,
 360                                            &normalized_file_a_path));
 361
 362   CreateTextFile(file_b_path, bogus_content);
 363   ASSERT_TRUE(file_util::PathExists(file_b_path));
 364   ASSERT_TRUE(file_util::NormalizeFilePath(file_b_path,
 365                                            &normalized_file_b_path));
 366
 367   // Beacuse this test created |dir_path|, we know it is not a link
 368   // or junction.  So, the real path of the directory holding file a
 369   // must be the parent of the path holding file b.
 370   ASSERT_TRUE(normalized_file_a_path.DirName()
 371       .IsParent(normalized_file_b_path.DirName()));
 372 }
 373
 374 #if defined(OS_WIN)
 375
 376 TEST_F(FileUtilTest, NormalizeFilePathReparsePoints) {
 377   // Build the following directory structure:
 378   //
 379   // temp_dir
 380   // |-> base_a
 381   // |   |-> sub_a
 382   // |       |-> file.txt
 383   // |       |-> long_name___... (Very long name.)
 384   // |           |-> sub_long
 385   // |              |-> deep.txt
 386   // |-> base_b
 387   //     |-> to_sub_a (reparse point to temp_dir\base_a\sub_a)
 388   //     |-> to_base_b (reparse point to temp_dir\base_b)
 389   //     |-> to_sub_long (reparse point to temp_dir\sub_a\long_name_\sub_long)
 390
 391   FilePath base_a = temp_dir_.path().Append(FPL("base_a"));
 392   ASSERT_TRUE(file_util::CreateDirectory(base_a));
 393
 394   FilePath sub_a = base_a.Append(FPL("sub_a"));
 395   ASSERT_TRUE(file_util::CreateDirectory(sub_a));
 396
 397   FilePath file_txt = sub_a.Append(FPL("file.txt"));
 398   CreateTextFile(file_txt, bogus_content);
 399
 400   // Want a directory whose name is long enough to make the path to the file
 401   // inside just under MAX_PATH chars.  This will be used to test that when
 402   // a junction expands to a path over MAX_PATH chars in length,
 403   // NormalizeFilePath() fails without crashing.
 404   FilePath sub_long_rel(FPL("sub_long"));
 405   FilePath deep_txt(FPL("deep.txt"));
 406
 407   int target_length = MAX_PATH;
 408   target_length -= (sub_a.value().length() + 1);  // +1 for the sepperator '\'.
 409   target_length -= (sub_long_rel.Append(deep_txt).value().length() + 1);
 410   // Without making the path a bit shorter, CreateDirectory() fails.
 411   // the resulting path is still long enough to hit the failing case in
 412   // NormalizePath().
 413   const int kCreateDirLimit = 4;
 414   target_length -= kCreateDirLimit;
 415   FilePath::StringType long_name_str = FPL("long_name_");
 416   long_name_str.resize(target_length, '_');
 417
 418   FilePath long_name = sub_a.Append(FilePath(long_name_str));
 419   FilePath deep_file = long_name.Append(sub_long_rel).Append(deep_txt);
 420   ASSERT_EQ(MAX_PATH - kCreateDirLimit, deep_file.value().length());
 421
 422   FilePath sub_long = deep_file.DirName();
 423   ASSERT_TRUE(file_util::CreateDirectory(sub_long));
 424   CreateTextFile(deep_file, bogus_content);
 425
 426   FilePath base_b = temp_dir_.path().Append(FPL("base_b"));
 427   ASSERT_TRUE(file_util::CreateDirectory(base_b));
 428
 429   FilePath to_sub_a = base_b.Append(FPL("to_sub_a"));
 430   ASSERT_TRUE(file_util::CreateDirectory(to_sub_a));
 431   base::win::ScopedHandle reparse_to_sub_a(
 432       ::CreateFile(to_sub_a.value().c_str(),
 433                    FILE_ALL_ACCESS,
 434                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 435                    NULL,
 436                    OPEN_EXISTING,
 437                    FILE_FLAG_BACKUP_SEMANTICS,  // Needed to open a directory.
 438                    NULL));
 439   ASSERT_TRUE(reparse_to_sub_a.IsValid());
 440   ASSERT_TRUE(SetReparsePoint(reparse_to_sub_a, sub_a));
 441
 442   FilePath to_base_b = base_b.Append(FPL("to_base_b"));
 443   ASSERT_TRUE(file_util::CreateDirectory(to_base_b));
 444   base::win::ScopedHandle reparse_to_base_b(
 445       ::CreateFile(to_base_b.value().c_str(),
 446                    FILE_ALL_ACCESS,
 447                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 448                    NULL,
 449                    OPEN_EXISTING,
 450                    FILE_FLAG_BACKUP_SEMANTICS,  // Needed to open a directory.
 451                    NULL));
 452   ASSERT_TRUE(reparse_to_base_b.IsValid());
 453   ASSERT_TRUE(SetReparsePoint(reparse_to_base_b, base_b));
 454
 455   FilePath to_sub_long = base_b.Append(FPL("to_sub_long"));
 456   ASSERT_TRUE(file_util::CreateDirectory(to_sub_long));
 457   base::win::ScopedHandle reparse_to_sub_long(
 458       ::CreateFile(to_sub_long.value().c_str(),
 459                    FILE_ALL_ACCESS,
 460                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 461                    NULL,
 462                    OPEN_EXISTING,
 463                    FILE_FLAG_BACKUP_SEMANTICS,  // Needed to open a directory.
 464                    NULL));
 465   ASSERT_TRUE(reparse_to_sub_long.IsValid());
 466   ASSERT_TRUE(SetReparsePoint(reparse_to_sub_long, sub_long));
 467
 468   // Normalize a junction free path: base_a\sub_a\file.txt .
 469   FilePath normalized_path;
 470   ASSERT_TRUE(file_util::NormalizeFilePath(file_txt, &normalized_path));
 471   ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
 472
 473   // Check that the path base_b\to_sub_a\file.txt can be normalized to exclude
 474   // the junction to_sub_a.
 475   ASSERT_TRUE(file_util::NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
 476                                            &normalized_path));
 477   ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
 478
 479   // Check that the path base_b\to_base_b\to_base_b\to_sub_a\file.txt can be
 480   // normalized to exclude junctions to_base_b and to_sub_a .
 481   ASSERT_TRUE(file_util::NormalizeFilePath(base_b.Append(FPL("to_base_b"))
 482                                                  .Append(FPL("to_base_b"))
 483                                                  .Append(FPL("to_sub_a"))
 484                                                  .Append(FPL("file.txt")),
 485                                            &normalized_path));
 486   ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
 487
 488   // A long enough path will cause NormalizeFilePath() to fail.  Make a long
 489   // path using to_base_b many times, and check that paths long enough to fail
 490   // do not cause a crash.
 491   FilePath long_path = base_b;
 492   const int kLengthLimit = MAX_PATH + 200;
 493   while (long_path.value().length() <= kLengthLimit) {
 494     long_path = long_path.Append(FPL("to_base_b"));
 495   }
 496   long_path = long_path.Append(FPL("to_sub_a"))
 497                        .Append(FPL("file.txt"));
 498
 499   ASSERT_FALSE(file_util::NormalizeFilePath(long_path, &normalized_path));
 500
 501   // Normalizing the junction to deep.txt should fail, because the expanded
 502   // path to deep.txt is longer than MAX_PATH.
 503   ASSERT_FALSE(file_util::NormalizeFilePath(to_sub_long.Append(deep_txt),
 504                                             &normalized_path));
 505
 506   // Delete the reparse points, and see that NormalizeFilePath() fails
 507   // to traverse them.
 508   ASSERT_TRUE(DeleteReparsePoint(reparse_to_sub_a));
 509   ASSERT_TRUE(DeleteReparsePoint(reparse_to_base_b));
 510   ASSERT_TRUE(DeleteReparsePoint(reparse_to_sub_long));
 511
 512   ASSERT_FALSE(file_util::NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
 513                                             &normalized_path));
 514 }
 515
 516 TEST_F(FileUtilTest, DevicePathToDriveLetter) {
 517   // Get a drive letter.
 518   std::wstring real_drive_letter = temp_dir_.path().value().substr(0, 2);
 519   if (!isalpha(real_drive_letter[0]) || ':' != real_drive_letter[1]) {
 520     LOG(ERROR) << "Can't get a drive letter to test with.";
 521     return;
 522   }
 523
 524   // Get the NT style path to that drive.
 525   wchar_t device_path[MAX_PATH] = {'\0'};
 526   ASSERT_TRUE(
 527       ::QueryDosDevice(real_drive_letter.c_str(), device_path, MAX_PATH));
 528   FilePath actual_device_path(device_path);
 529   FilePath win32_path;
 530
 531   // Run DevicePathToDriveLetterPath() on the NT style path we got from
 532   // QueryDosDevice().  Expect the drive letter we started with.
 533   ASSERT_TRUE(file_util::DevicePathToDriveLetterPath(actual_device_path,
 534                                                      &win32_path));
 535   ASSERT_EQ(real_drive_letter, win32_path.value());
 536
 537   // Add some directories to the path.  Expect those extra path componenets
 538   // to be preserved.
 539   FilePath kRelativePath(FPL("dir1\\dir2\\file.txt"));
 540   ASSERT_TRUE(file_util::DevicePathToDriveLetterPath(
 541       actual_device_path.Append(kRelativePath),
 542       &win32_path));
 543   EXPECT_EQ(FilePath(real_drive_letter + L"\\").Append(kRelativePath).value(),
 544             win32_path.value());
 545
 546   // Deform the real path so that it is invalid by removing the last four
 547   // characters.  The way windows names devices that are hard disks
 548   // (\Device\HardDiskVolume${NUMBER}) guarantees that the string is longer
 549   // than three characters.  The only way the truncated string could be a
 550   // real drive is if more than 10^3 disks are mounted:
 551   // \Device\HardDiskVolume10000 would be truncated to \Device\HardDiskVolume1
 552   // Check that DevicePathToDriveLetterPath fails.
 553   int path_length = actual_device_path.value().length();
 554   int new_length = path_length - 4;
 555   ASSERT_LT(0, new_length);
 556   FilePath prefix_of_real_device_path(
 557       actual_device_path.value().substr(0, new_length));
 558   ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(
 559       prefix_of_real_device_path,
 560       &win32_path));
 561
 562   ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(
 563       prefix_of_real_device_path.Append(kRelativePath),
 564       &win32_path));
 565
 566   // Deform the real path so that it is invalid by adding some characters. For
 567   // example, if C: maps to \Device\HardDiskVolume8, then we simulate a
 568   // request for the drive letter whose native path is
 569   // \Device\HardDiskVolume812345 .  We assume such a device does not exist,
 570   // because drives are numbered in order and mounting 112345 hard disks will
 571   // never happen.
 572   const FilePath::StringType kExtraChars = FPL("12345");
 573
 574   FilePath real_device_path_plus_numbers(
 575       actual_device_path.value() + kExtraChars);
 576
 577   ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(
 578       real_device_path_plus_numbers,
 579       &win32_path));
 580
 581   ASSERT_FALSE(file_util::DevicePathToDriveLetterPath(
 582       real_device_path_plus_numbers.Append(kRelativePath),
 583       &win32_path));
 584 }
 585
 586 TEST_F(FileUtilTest, GetPlatformFileInfoForDirectory) {
 587   FilePath empty_dir = temp_dir_.path().Append(FPL("gpfi_test"));
 588   ASSERT_TRUE(file_util::CreateDirectory(empty_dir));
 589   base::win::ScopedHandle dir(
 590       ::CreateFile(empty_dir.value().c_str(),
 591                    FILE_ALL_ACCESS,
 592                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 593                    NULL,
 594                    OPEN_EXISTING,
 595                    FILE_FLAG_BACKUP_SEMANTICS,  // Needed to open a directory.
 596                    NULL));
 597   ASSERT_TRUE(dir.IsValid());
 598   base::PlatformFileInfo info;
 599   EXPECT_TRUE(base::GetPlatformFileInfo(dir.Get(), &info));
 600   EXPECT_TRUE(info.is_directory);
 601   EXPECT_FALSE(info.is_symbolic_link);
 602   EXPECT_EQ(0, info.size);
 603 }
 604
 605 TEST_F(FileUtilTest, CreateTemporaryFileInDirLongPathTest) {
 606   // Test that CreateTemporaryFileInDir() creates a path and returns a long path
 607   // if it is available. This test requires that:
 608   // - the filesystem at |temp_dir_| supports long filenames.
 609   // - the account has FILE_LIST_DIRECTORY permission for all ancestor
 610   //   directories of |temp_dir_|.
 611   const FilePath::CharType kLongDirName[] = FPL("A long path");
 612   const FilePath::CharType kTestSubDirName[] = FPL("test");
 613   FilePath long_test_dir = temp_dir_.path().Append(kLongDirName);
 614   ASSERT_TRUE(file_util::CreateDirectory(long_test_dir));
 615
 616   // kLongDirName is not a 8.3 component. So GetShortName() should give us a
 617   // different short name.
 618   WCHAR path_buffer[MAX_PATH];
 619   DWORD path_buffer_length = GetShortPathName(long_test_dir.value().c_str(),
 620                                               path_buffer, MAX_PATH);
 621   ASSERT_LT(path_buffer_length, DWORD(MAX_PATH));
 622   ASSERT_NE(DWORD(0), path_buffer_length);
 623   FilePath short_test_dir(path_buffer);
 624   ASSERT_STRNE(kLongDirName, short_test_dir.BaseName().value().c_str());
 625
 626   FilePath temp_file;
 627   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(short_test_dir, &temp_file));
 628   EXPECT_STREQ(kLongDirName, temp_file.DirName().BaseName().value().c_str());
 629   EXPECT_TRUE(file_util::PathExists(temp_file));
 630
 631   // Create a subdirectory of |long_test_dir| and make |long_test_dir|
 632   // unreadable. We should still be able to create a temp file in the
 633   // subdirectory, but we won't be able to determine the long path for it. This
 634   // mimics the environment that some users run where their user profiles reside
 635   // in a location where the don't have full access to the higher level
 636   // directories. (Note that this assumption is true for NTFS, but not for some
 637   // network file systems. E.g. AFS).
 638   FilePath access_test_dir = long_test_dir.Append(kTestSubDirName);
 639   ASSERT_TRUE(file_util::CreateDirectory(access_test_dir));
 640   file_util::PermissionRestorer long_test_dir_restorer(long_test_dir);
 641   ASSERT_TRUE(file_util::MakeFileUnreadable(long_test_dir));
 642
 643   // Use the short form of the directory to create a temporary filename.
 644   ASSERT_TRUE(file_util::CreateTemporaryFileInDir(
 645       short_test_dir.Append(kTestSubDirName), &temp_file));
 646   EXPECT_TRUE(file_util::PathExists(temp_file));
 647   EXPECT_TRUE(short_test_dir.IsParent(temp_file.DirName()));
 648
 649   // Check that the long path can't be determined for |temp_file|.
 650   path_buffer_length = GetLongPathName(temp_file.value().c_str(),
 651                                        path_buffer, MAX_PATH);
 652   EXPECT_EQ(DWORD(0), path_buffer_length);
 653 }
 654
 655 #endif  // defined(OS_WIN)
 656
 657 #if defined(OS_POSIX)
 658
 659 TEST_F(FileUtilTest, CreateAndReadSymlinks) {
 660   FilePath link_from = temp_dir_.path().Append(FPL("from_file"));
 661   FilePath link_to = temp_dir_.path().Append(FPL("to_file"));
 662   CreateTextFile(link_to, bogus_content);
 663
 664   ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
 665     << "Failed to create file symlink.";
 666
 667   // If we created the link properly, we should be able to read the
 668   // contents through it.
 669   std::wstring contents = ReadTextFile(link_from);
 670   ASSERT_EQ(contents, bogus_content);
 671
 672   FilePath result;
 673   ASSERT_TRUE(file_util::ReadSymbolicLink(link_from, &result));
 674   ASSERT_EQ(link_to.value(), result.value());
 675
 676   // Link to a directory.
 677   link_from = temp_dir_.path().Append(FPL("from_dir"));
 678   link_to = temp_dir_.path().Append(FPL("to_dir"));
 679   file_util::CreateDirectory(link_to);
 680
 681   ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
 682     << "Failed to create directory symlink.";
 683
 684   // Test failures.
 685   ASSERT_FALSE(file_util::CreateSymbolicLink(link_to, link_to));
 686   ASSERT_FALSE(file_util::ReadSymbolicLink(link_to, &result));
 687   FilePath missing = temp_dir_.path().Append(FPL("missing"));
 688   ASSERT_FALSE(file_util::ReadSymbolicLink(missing, &result));
 689 }
 690
 691 // The following test of NormalizeFilePath() require that we create a symlink.
 692 // This can not be done on Windows before Vista.  On Vista, creating a symlink
 693 // requires privilege "SeCreateSymbolicLinkPrivilege".
 694 // TODO(skerner): Investigate the possibility of giving base_unittests the
 695 // privileges required to create a symlink.
 696 TEST_F(FileUtilTest, NormalizeFilePathSymlinks) {
 697   FilePath normalized_path;
 698
 699   // Link one file to another.
 700   FilePath link_from = temp_dir_.path().Append(FPL("from_file"));
 701   FilePath link_to = temp_dir_.path().Append(FPL("to_file"));
 702   CreateTextFile(link_to, bogus_content);
 703
 704   ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
 705     << "Failed to create file symlink.";
 706
 707   // Check that NormalizeFilePath sees the link.
 708   ASSERT_TRUE(file_util::NormalizeFilePath(link_from, &normalized_path));
 709   ASSERT_TRUE(link_to != link_from);
 710   ASSERT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
 711   ASSERT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
 712
 713   // Link to a directory.
 714   link_from = temp_dir_.path().Append(FPL("from_dir"));
 715   link_to = temp_dir_.path().Append(FPL("to_dir"));
 716   file_util::CreateDirectory(link_to);
 717
 718   ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
 719     << "Failed to create directory symlink.";
 720
 721   ASSERT_FALSE(file_util::NormalizeFilePath(link_from, &normalized_path))
 722     << "Links to directories should return false.";
 723
 724   // Test that a loop in the links causes NormalizeFilePath() to return false.
 725   link_from = temp_dir_.path().Append(FPL("link_a"));
 726   link_to = temp_dir_.path().Append(FPL("link_b"));
 727   ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
 728     << "Failed to create loop symlink a.";
 729   ASSERT_TRUE(file_util::CreateSymbolicLink(link_from, link_to))
 730     << "Failed to create loop symlink b.";
 731
 732   // Infinite loop!
 733   ASSERT_FALSE(file_util::NormalizeFilePath(link_from, &normalized_path));
 734 }
 735 #endif  // defined(OS_POSIX)
 736
 737 TEST_F(FileUtilTest, DeleteNonExistent) {
 738   FilePath non_existent = temp_dir_.path().AppendASCII("bogus_file_dne.foobar");
 739   ASSERT_FALSE(file_util::PathExists(non_existent));
 740
 741   EXPECT_TRUE(file_util::Delete(non_existent, false));
 742   ASSERT_FALSE(file_util::PathExists(non_existent));
 743   EXPECT_TRUE(file_util::Delete(non_existent, true));
 744   ASSERT_FALSE(file_util::PathExists(non_existent));
 745 }
 746
 747 TEST_F(FileUtilTest, DeleteFile) {
 748   // Create a file
 749   FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteFile 1.txt"));
 750   CreateTextFile(file_name, bogus_content);
 751   ASSERT_TRUE(file_util::PathExists(file_name));
 752
 753   // Make sure it's deleted
 754   EXPECT_TRUE(file_util::Delete(file_name, false));
 755   EXPECT_FALSE(file_util::PathExists(file_name));
 756
 757   // Test recursive case, create a new file
 758   file_name = temp_dir_.path().Append(FPL("Test DeleteFile 2.txt"));
 759   CreateTextFile(file_name, bogus_content);
 760   ASSERT_TRUE(file_util::PathExists(file_name));
 761
 762   // Make sure it's deleted
 763   EXPECT_TRUE(file_util::Delete(file_name, true));
 764   EXPECT_FALSE(file_util::PathExists(file_name));
 765 }
 766
 767 #if defined(OS_POSIX)
 768 TEST_F(FileUtilTest, DeleteSymlinkToExistentFile) {
 769   // Create a file.
 770   FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteFile 2.txt"));
 771   CreateTextFile(file_name, bogus_content);
 772   ASSERT_TRUE(file_util::PathExists(file_name));
 773
 774   // Create a symlink to the file.
 775   FilePath file_link = temp_dir_.path().Append("file_link_2");
 776   ASSERT_TRUE(file_util::CreateSymbolicLink(file_name, file_link))
 777       << "Failed to create symlink.";
 778
 779   // Delete the symbolic link.
 780   EXPECT_TRUE(file_util::Delete(file_link, false));
 781
 782   // Make sure original file is not deleted.
 783   EXPECT_FALSE(file_util::PathExists(file_link));
 784   EXPECT_TRUE(file_util::PathExists(file_name));
 785 }
 786
 787 TEST_F(FileUtilTest, DeleteSymlinkToNonExistentFile) {
 788   // Create a non-existent file path.
 789   FilePath non_existent = temp_dir_.path().Append(FPL("Test DeleteFile 3.txt"));
 790   EXPECT_FALSE(file_util::PathExists(non_existent));
 791
 792   // Create a symlink to the non-existent file.
 793   FilePath file_link = temp_dir_.path().Append("file_link_3");
 794   ASSERT_TRUE(file_util::CreateSymbolicLink(non_existent, file_link))
 795       << "Failed to create symlink.";
 796
 797   // Make sure the symbolic link is exist.
 798   EXPECT_TRUE(file_util::IsLink(file_link));
 799   EXPECT_FALSE(file_util::PathExists(file_link));
 800
 801   // Delete the symbolic link.
 802   EXPECT_TRUE(file_util::Delete(file_link, false));
 803
 804   // Make sure the symbolic link is deleted.
 805   EXPECT_FALSE(file_util::IsLink(file_link));
 806 }
 807
 808 TEST_F(FileUtilTest, ChangeFilePermissionsAndRead) {
 809   // Create a file path.
 810   FilePath file_name = temp_dir_.path().Append(FPL("Test Readable File.txt"));
 811   EXPECT_FALSE(file_util::PathExists(file_name));
 812
 813   const std::string kData("hello");
 814
 815   int buffer_size = kData.length();
 816   char* buffer = new char[buffer_size];
 817
 818   // Write file.
 819   EXPECT_EQ(static_cast<int>(kData.length()),
 820             file_util::WriteFile(file_name, kData.data(), kData.length()));
 821   EXPECT_TRUE(file_util::PathExists(file_name));
 822
 823   // Make sure the file is readable.
 824   int32 mode = 0;
 825   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
 826   EXPECT_TRUE(mode & file_util::FILE_PERMISSION_READ_BY_USER);
 827
 828   // Get rid of the read permission.
 829   EXPECT_TRUE(file_util::SetPosixFilePermissions(file_name, 0u));
 830   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
 831   EXPECT_FALSE(mode & file_util::FILE_PERMISSION_READ_BY_USER);
 832   // Make sure the file can't be read.
 833   EXPECT_EQ(-1, file_util::ReadFile(file_name, buffer, buffer_size));
 834
 835   // Give the read permission.
 836   EXPECT_TRUE(file_util::SetPosixFilePermissions(
 837       file_name,
 838       file_util::FILE_PERMISSION_READ_BY_USER));
 839   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
 840   EXPECT_TRUE(mode & file_util::FILE_PERMISSION_READ_BY_USER);
 841   // Make sure the file can be read.
 842   EXPECT_EQ(static_cast<int>(kData.length()),
 843             file_util::ReadFile(file_name, buffer, buffer_size));
 844
 845   // Delete the file.
 846   EXPECT_TRUE(file_util::Delete(file_name, false));
 847   EXPECT_FALSE(file_util::PathExists(file_name));
 848
 849   delete[] buffer;
 850 }
 851
 852 TEST_F(FileUtilTest, ChangeFilePermissionsAndWrite) {
 853   // Create a file path.
 854   FilePath file_name = temp_dir_.path().Append(FPL("Test Readable File.txt"));
 855   EXPECT_FALSE(file_util::PathExists(file_name));
 856
 857   const std::string kData("hello");
 858
 859   // Write file.
 860   EXPECT_EQ(static_cast<int>(kData.length()),
 861             file_util::WriteFile(file_name, kData.data(), kData.length()));
 862   EXPECT_TRUE(file_util::PathExists(file_name));
 863
 864   // Make sure the file is writable.
 865   int mode = 0;
 866   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
 867   EXPECT_TRUE(mode & file_util::FILE_PERMISSION_WRITE_BY_USER);
 868   EXPECT_TRUE(file_util::PathIsWritable(file_name));
 869
 870   // Get rid of the write permission.
 871   EXPECT_TRUE(file_util::SetPosixFilePermissions(file_name, 0u));
 872   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
 873   EXPECT_FALSE(mode & file_util::FILE_PERMISSION_WRITE_BY_USER);
 874   // Make sure the file can't be write.
 875   EXPECT_EQ(-1,
 876             file_util::WriteFile(file_name, kData.data(), kData.length()));
 877   EXPECT_FALSE(file_util::PathIsWritable(file_name));
 878
 879   // Give read permission.
 880   EXPECT_TRUE(file_util::SetPosixFilePermissions(
 881       file_name,
 882       file_util::FILE_PERMISSION_WRITE_BY_USER));
 883   EXPECT_TRUE(file_util::GetPosixFilePermissions(file_name, &mode));
 884   EXPECT_TRUE(mode & file_util::FILE_PERMISSION_WRITE_BY_USER);
 885   // Make sure the file can be write.
 886   EXPECT_EQ(static_cast<int>(kData.length()),
 887             file_util::WriteFile(file_name, kData.data(), kData.length()));
 888   EXPECT_TRUE(file_util::PathIsWritable(file_name));
 889
 890   // Delete the file.
 891   EXPECT_TRUE(file_util::Delete(file_name, false));
 892   EXPECT_FALSE(file_util::PathExists(file_name));
 893 }
 894
 895 TEST_F(FileUtilTest, ChangeDirectoryPermissionsAndEnumerate) {
 896   // Create a directory path.
 897   FilePath subdir_path =
 898       temp_dir_.path().Append(FPL("PermissionTest1"));
 899   file_util::CreateDirectory(subdir_path);
 900   ASSERT_TRUE(file_util::PathExists(subdir_path));
 901
 902   // Create a dummy file to enumerate.
 903   FilePath file_name = subdir_path.Append(FPL("Test Readable File.txt"));
 904   EXPECT_FALSE(file_util::PathExists(file_name));
 905   const std::string kData("hello");
 906   EXPECT_EQ(static_cast<int>(kData.length()),
 907             file_util::WriteFile(file_name, kData.data(), kData.length()));
 908   EXPECT_TRUE(file_util::PathExists(file_name));
 909
 910   // Make sure the directory has the all permissions.
 911   int mode = 0;
 912   EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
 913   EXPECT_EQ(file_util::FILE_PERMISSION_USER_MASK,
 914             mode & file_util::FILE_PERMISSION_USER_MASK);
 915
 916   // Get rid of the permissions from the directory.
 917   EXPECT_TRUE(file_util::SetPosixFilePermissions(subdir_path, 0u));
 918   EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
 919   EXPECT_FALSE(mode & file_util::FILE_PERMISSION_USER_MASK);
 920
 921   // Make sure the file in the directory can't be enumerated.
 922   FileEnumerator f1(subdir_path, true, FileEnumerator::FILES);
 923   EXPECT_TRUE(file_util::PathExists(subdir_path));
 924   FindResultCollector c1(f1);
 925   EXPECT_EQ(c1.size(), 0);
 926   EXPECT_FALSE(file_util::GetPosixFilePermissions(file_name, &mode));
 927
 928   // Give the permissions to the directory.
 929   EXPECT_TRUE(file_util::SetPosixFilePermissions(
 930       subdir_path,
 931       file_util::FILE_PERMISSION_USER_MASK));
 932   EXPECT_TRUE(file_util::GetPosixFilePermissions(subdir_path, &mode));
 933   EXPECT_EQ(file_util::FILE_PERMISSION_USER_MASK,
 934             mode & file_util::FILE_PERMISSION_USER_MASK);
 935
 936   // Make sure the file in the directory can be enumerated.
 937   FileEnumerator f2(subdir_path, true, FileEnumerator::FILES);
 938   FindResultCollector c2(f2);
 939   EXPECT_TRUE(c2.HasFile(file_name));
 940   EXPECT_EQ(c2.size(), 1);
 941
 942   // Delete the file.
 943   EXPECT_TRUE(file_util::Delete(subdir_path, true));
 944   EXPECT_FALSE(file_util::PathExists(subdir_path));
 945 }
 946
 947 #endif  // defined(OS_POSIX)
 948
 949 #if defined(OS_WIN)
 950 // Tests that the Delete function works for wild cards, especially
 951 // with the recursion flag.  Also coincidentally tests PathExists.
 952 // TODO(erikkay): see if anyone's actually using this feature of the API
 953 TEST_F(FileUtilTest, DeleteWildCard) {
 954   // Create a file and a directory
 955   FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteWildCard.txt"));
 956   CreateTextFile(file_name, bogus_content);
 957   ASSERT_TRUE(file_util::PathExists(file_name));
 958
 959   FilePath subdir_path = temp_dir_.path().Append(FPL("DeleteWildCardDir"));
 960   file_util::CreateDirectory(subdir_path);
 961   ASSERT_TRUE(file_util::PathExists(subdir_path));
 962
 963   // Create the wildcard path
 964   FilePath directory_contents = temp_dir_.path();
 965   directory_contents = directory_contents.Append(FPL("*"));
 966
 967   // Delete non-recursively and check that only the file is deleted
 968   EXPECT_TRUE(file_util::Delete(directory_contents, false));
 969   EXPECT_FALSE(file_util::PathExists(file_name));
 970   EXPECT_TRUE(file_util::PathExists(subdir_path));
 971
 972   // Delete recursively and make sure all contents are deleted
 973   EXPECT_TRUE(file_util::Delete(directory_contents, true));
 974   EXPECT_FALSE(file_util::PathExists(file_name));
 975   EXPECT_FALSE(file_util::PathExists(subdir_path));
 976 }
 977
 978 // TODO(erikkay): see if anyone's actually using this feature of the API
 979 TEST_F(FileUtilTest, DeleteNonExistantWildCard) {
 980   // Create a file and a directory
 981   FilePath subdir_path =
 982       temp_dir_.path().Append(FPL("DeleteNonExistantWildCard"));
 983   file_util::CreateDirectory(subdir_path);
 984   ASSERT_TRUE(file_util::PathExists(subdir_path));
 985
 986   // Create the wildcard path
 987   FilePath directory_contents = subdir_path;
 988   directory_contents = directory_contents.Append(FPL("*"));
 989
 990   // Delete non-recursively and check nothing got deleted
 991   EXPECT_TRUE(file_util::Delete(directory_contents, false));
 992   EXPECT_TRUE(file_util::PathExists(subdir_path));
 993
 994   // Delete recursively and check nothing got deleted
 995   EXPECT_TRUE(file_util::Delete(directory_contents, true));
 996   EXPECT_TRUE(file_util::PathExists(subdir_path));
 997 }
 998 #endif
 999
1000 // Tests non-recursive Delete() for a directory.
1001 TEST_F(FileUtilTest, DeleteDirNonRecursive) {
1002   // Create a subdirectory and put a file and two directories inside.
1003   FilePath test_subdir = temp_dir_.path().Append(FPL("DeleteDirNonRecursive"));
1004   file_util::CreateDirectory(test_subdir);
1005   ASSERT_TRUE(file_util::PathExists(test_subdir));
1006
1007   FilePath file_name = test_subdir.Append(FPL("Test DeleteDir.txt"));
1008   CreateTextFile(file_name, bogus_content);
1009   ASSERT_TRUE(file_util::PathExists(file_name));
1010
1011   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
1012   file_util::CreateDirectory(subdir_path1);
1013   ASSERT_TRUE(file_util::PathExists(subdir_path1));
1014
1015   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
1016   file_util::CreateDirectory(subdir_path2);
1017   ASSERT_TRUE(file_util::PathExists(subdir_path2));
1018
1019   // Delete non-recursively and check that the empty dir got deleted
1020   EXPECT_TRUE(file_util::Delete(subdir_path2, false));
1021   EXPECT_FALSE(file_util::PathExists(subdir_path2));
1022
1023   // Delete non-recursively and check that nothing got deleted
1024   EXPECT_FALSE(file_util::Delete(test_subdir, false));
1025   EXPECT_TRUE(file_util::PathExists(test_subdir));
1026   EXPECT_TRUE(file_util::PathExists(file_name));
1027   EXPECT_TRUE(file_util::PathExists(subdir_path1));
1028 }
1029
1030 // Tests recursive Delete() for a directory.
1031 TEST_F(FileUtilTest, DeleteDirRecursive) {
1032   // Create a subdirectory and put a file and two directories inside.
1033   FilePath test_subdir = temp_dir_.path().Append(FPL("DeleteDirRecursive"));
1034   file_util::CreateDirectory(test_subdir);
1035   ASSERT_TRUE(file_util::PathExists(test_subdir));
1036
1037   FilePath file_name = test_subdir.Append(FPL("Test DeleteDirRecursive.txt"));
1038   CreateTextFile(file_name, bogus_content);
1039   ASSERT_TRUE(file_util::PathExists(file_name));
1040
1041   FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
1042   file_util::CreateDirectory(subdir_path1);
1043   ASSERT_TRUE(file_util::PathExists(subdir_path1));
1044
1045   FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
1046   file_util::CreateDirectory(subdir_path2);
1047   ASSERT_TRUE(file_util::PathExists(subdir_path2));
1048
1049   // Delete recursively and check that the empty dir got deleted
1050   EXPECT_TRUE(file_util::Delete(subdir_path2, true));
1051   EXPECT_FALSE(file_util::PathExists(subdir_path2));
1052
1053   // Delete recursively and check that everything got deleted
1054   EXPECT_TRUE(file_util::Delete(test_subdir, true));
1055   EXPECT_FALSE(file_util::PathExists(file_name));
1056   EXPECT_FALSE(file_util::PathExists(subdir_path1));
1057   EXPECT_FALSE(file_util::PathExists(test_subdir));
1058 }
1059
1060 TEST_F(FileUtilTest, MoveFileNew) {
1061   // Create a file
1062   FilePath file_name_from =
1063       temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
1064   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1065   ASSERT_TRUE(file_util::PathExists(file_name_from));
1066
1067   // The destination.
1068   FilePath file_name_to = temp_dir_.path().Append(
1069       FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
1070   ASSERT_FALSE(file_util::PathExists(file_name_to));
1071
1072   EXPECT_TRUE(file_util::Move(file_name_from, file_name_to));
1073
1074   // Check everything has been moved.
1075   EXPECT_FALSE(file_util::PathExists(file_name_from));
1076   EXPECT_TRUE(file_util::PathExists(file_name_to));
1077 }
1078
1079 TEST_F(FileUtilTest, MoveFileExists) {
1080   // Create a file
1081   FilePath file_name_from =
1082       temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
1083   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1084   ASSERT_TRUE(file_util::PathExists(file_name_from));
1085
1086   // The destination name.
1087   FilePath file_name_to = temp_dir_.path().Append(
1088       FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
1089   CreateTextFile(file_name_to, L"Old file content");
1090   ASSERT_TRUE(file_util::PathExists(file_name_to));
1091
1092   EXPECT_TRUE(file_util::Move(file_name_from, file_name_to));
1093
1094   // Check everything has been moved.
1095   EXPECT_FALSE(file_util::PathExists(file_name_from));
1096   EXPECT_TRUE(file_util::PathExists(file_name_to));
1097   EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
1098 }
1099
1100 TEST_F(FileUtilTest, MoveFileDirExists) {
1101   // Create a file
1102   FilePath file_name_from =
1103       temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
1104   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1105   ASSERT_TRUE(file_util::PathExists(file_name_from));
1106
1107   // The destination directory
1108   FilePath dir_name_to =
1109       temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
1110   file_util::CreateDirectory(dir_name_to);
1111   ASSERT_TRUE(file_util::PathExists(dir_name_to));
1112
1113   EXPECT_FALSE(file_util::Move(file_name_from, dir_name_to));
1114 }
1115
1116
1117 TEST_F(FileUtilTest, MoveNew) {
1118   // Create a directory
1119   FilePath dir_name_from =
1120       temp_dir_.path().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
1121   file_util::CreateDirectory(dir_name_from);
1122   ASSERT_TRUE(file_util::PathExists(dir_name_from));
1123
1124   // Create a file under the directory
1125   FilePath txt_file_name(FILE_PATH_LITERAL("Move_Test_File.txt"));
1126   FilePath file_name_from = dir_name_from.Append(txt_file_name);
1127   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1128   ASSERT_TRUE(file_util::PathExists(file_name_from));
1129
1130   // Move the directory.
1131   FilePath dir_name_to =
1132       temp_dir_.path().Append(FILE_PATH_LITERAL("Move_To_Subdir"));
1133   FilePath file_name_to =
1134       dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
1135
1136   ASSERT_FALSE(file_util::PathExists(dir_name_to));
1137
1138   EXPECT_TRUE(file_util::Move(dir_name_from, dir_name_to));
1139
1140   // Check everything has been moved.
1141   EXPECT_FALSE(file_util::PathExists(dir_name_from));
1142   EXPECT_FALSE(file_util::PathExists(file_name_from));
1143   EXPECT_TRUE(file_util::PathExists(dir_name_to));
1144   EXPECT_TRUE(file_util::PathExists(file_name_to));
1145
1146   // Test path traversal.
1147   file_name_from = dir_name_to.Append(txt_file_name);
1148   file_name_to = dir_name_to.Append(FILE_PATH_LITERAL(".."));
1149   file_name_to = file_name_to.Append(txt_file_name);
1150   EXPECT_FALSE(file_util::Move(file_name_from, file_name_to));
1151   EXPECT_TRUE(file_util::PathExists(file_name_from));
1152   EXPECT_FALSE(file_util::PathExists(file_name_to));
1153   EXPECT_TRUE(file_util::MoveUnsafe(file_name_from, file_name_to));
1154   EXPECT_FALSE(file_util::PathExists(file_name_from));
1155   EXPECT_TRUE(file_util::PathExists(file_name_to));
1156 }
1157
1158 TEST_F(FileUtilTest, MoveExist) {
1159   // Create a directory
1160   FilePath dir_name_from =
1161       temp_dir_.path().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
1162   file_util::CreateDirectory(dir_name_from);
1163   ASSERT_TRUE(file_util::PathExists(dir_name_from));
1164
1165   // Create a file under the directory
1166   FilePath file_name_from =
1167       dir_name_from.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
1168   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1169   ASSERT_TRUE(file_util::PathExists(file_name_from));
1170
1171   // Move the directory
1172   FilePath dir_name_exists =
1173       temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
1174
1175   FilePath dir_name_to =
1176       dir_name_exists.Append(FILE_PATH_LITERAL("Move_To_Subdir"));
1177   FilePath file_name_to =
1178       dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
1179
1180   // Create the destination directory.
1181   file_util::CreateDirectory(dir_name_exists);
1182   ASSERT_TRUE(file_util::PathExists(dir_name_exists));
1183
1184   EXPECT_TRUE(file_util::Move(dir_name_from, dir_name_to));
1185
1186   // Check everything has been moved.
1187   EXPECT_FALSE(file_util::PathExists(dir_name_from));
1188   EXPECT_FALSE(file_util::PathExists(file_name_from));
1189   EXPECT_TRUE(file_util::PathExists(dir_name_to));
1190   EXPECT_TRUE(file_util::PathExists(file_name_to));
1191 }
1192
1193 TEST_F(FileUtilTest, CopyDirectoryRecursivelyNew) {
1194   // Create a directory.
1195   FilePath dir_name_from =
1196       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
1197   file_util::CreateDirectory(dir_name_from);
1198   ASSERT_TRUE(file_util::PathExists(dir_name_from));
1199
1200   // Create a file under the directory.
1201   FilePath file_name_from =
1202       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1203   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1204   ASSERT_TRUE(file_util::PathExists(file_name_from));
1205
1206   // Create a subdirectory.
1207   FilePath subdir_name_from =
1208       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
1209   file_util::CreateDirectory(subdir_name_from);
1210   ASSERT_TRUE(file_util::PathExists(subdir_name_from));
1211
1212   // Create a file under the subdirectory.
1213   FilePath file_name2_from =
1214       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1215   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
1216   ASSERT_TRUE(file_util::PathExists(file_name2_from));
1217
1218   // Copy the directory recursively.
1219   FilePath dir_name_to =
1220       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
1221   FilePath file_name_to =
1222       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1223   FilePath subdir_name_to =
1224       dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
1225   FilePath file_name2_to =
1226       subdir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1227
1228   ASSERT_FALSE(file_util::PathExists(dir_name_to));
1229
1230   EXPECT_TRUE(file_util::CopyDirectory(dir_name_from, dir_name_to, true));
1231
1232   // Check everything has been copied.
1233   EXPECT_TRUE(file_util::PathExists(dir_name_from));
1234   EXPECT_TRUE(file_util::PathExists(file_name_from));
1235   EXPECT_TRUE(file_util::PathExists(subdir_name_from));
1236   EXPECT_TRUE(file_util::PathExists(file_name2_from));
1237   EXPECT_TRUE(file_util::PathExists(dir_name_to));
1238   EXPECT_TRUE(file_util::PathExists(file_name_to));
1239   EXPECT_TRUE(file_util::PathExists(subdir_name_to));
1240   EXPECT_TRUE(file_util::PathExists(file_name2_to));
1241 }
1242
1243 TEST_F(FileUtilTest, CopyDirectoryRecursivelyExists) {
1244   // Create a directory.
1245   FilePath dir_name_from =
1246       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
1247   file_util::CreateDirectory(dir_name_from);
1248   ASSERT_TRUE(file_util::PathExists(dir_name_from));
1249
1250   // Create a file under the directory.
1251   FilePath file_name_from =
1252       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1253   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1254   ASSERT_TRUE(file_util::PathExists(file_name_from));
1255
1256   // Create a subdirectory.
1257   FilePath subdir_name_from =
1258       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
1259   file_util::CreateDirectory(subdir_name_from);
1260   ASSERT_TRUE(file_util::PathExists(subdir_name_from));
1261
1262   // Create a file under the subdirectory.
1263   FilePath file_name2_from =
1264       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1265   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
1266   ASSERT_TRUE(file_util::PathExists(file_name2_from));
1267
1268   // Copy the directory recursively.
1269   FilePath dir_name_exists =
1270       temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
1271
1272   FilePath dir_name_to =
1273       dir_name_exists.Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
1274   FilePath file_name_to =
1275       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1276   FilePath subdir_name_to =
1277       dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
1278   FilePath file_name2_to =
1279       subdir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1280
1281   // Create the destination directory.
1282   file_util::CreateDirectory(dir_name_exists);
1283   ASSERT_TRUE(file_util::PathExists(dir_name_exists));
1284
1285   EXPECT_TRUE(file_util::CopyDirectory(dir_name_from, dir_name_exists, true));
1286
1287   // Check everything has been copied.
1288   EXPECT_TRUE(file_util::PathExists(dir_name_from));
1289   EXPECT_TRUE(file_util::PathExists(file_name_from));
1290   EXPECT_TRUE(file_util::PathExists(subdir_name_from));
1291   EXPECT_TRUE(file_util::PathExists(file_name2_from));
1292   EXPECT_TRUE(file_util::PathExists(dir_name_to));
1293   EXPECT_TRUE(file_util::PathExists(file_name_to));
1294   EXPECT_TRUE(file_util::PathExists(subdir_name_to));
1295   EXPECT_TRUE(file_util::PathExists(file_name2_to));
1296 }
1297
1298 TEST_F(FileUtilTest, CopyDirectoryNew) {
1299   // Create a directory.
1300   FilePath dir_name_from =
1301       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
1302   file_util::CreateDirectory(dir_name_from);
1303   ASSERT_TRUE(file_util::PathExists(dir_name_from));
1304
1305   // Create a file under the directory.
1306   FilePath file_name_from =
1307       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1308   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1309   ASSERT_TRUE(file_util::PathExists(file_name_from));
1310
1311   // Create a subdirectory.
1312   FilePath subdir_name_from =
1313       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
1314   file_util::CreateDirectory(subdir_name_from);
1315   ASSERT_TRUE(file_util::PathExists(subdir_name_from));
1316
1317   // Create a file under the subdirectory.
1318   FilePath file_name2_from =
1319       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1320   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
1321   ASSERT_TRUE(file_util::PathExists(file_name2_from));
1322
1323   // Copy the directory not recursively.
1324   FilePath dir_name_to =
1325       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
1326   FilePath file_name_to =
1327       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1328   FilePath subdir_name_to =
1329       dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
1330
1331   ASSERT_FALSE(file_util::PathExists(dir_name_to));
1332
1333   EXPECT_TRUE(file_util::CopyDirectory(dir_name_from, dir_name_to, false));
1334
1335   // Check everything has been copied.
1336   EXPECT_TRUE(file_util::PathExists(dir_name_from));
1337   EXPECT_TRUE(file_util::PathExists(file_name_from));
1338   EXPECT_TRUE(file_util::PathExists(subdir_name_from));
1339   EXPECT_TRUE(file_util::PathExists(file_name2_from));
1340   EXPECT_TRUE(file_util::PathExists(dir_name_to));
1341   EXPECT_TRUE(file_util::PathExists(file_name_to));
1342   EXPECT_FALSE(file_util::PathExists(subdir_name_to));
1343 }
1344
1345 TEST_F(FileUtilTest, CopyDirectoryExists) {
1346   // Create a directory.
1347   FilePath dir_name_from =
1348       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
1349   file_util::CreateDirectory(dir_name_from);
1350   ASSERT_TRUE(file_util::PathExists(dir_name_from));
1351
1352   // Create a file under the directory.
1353   FilePath file_name_from =
1354       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1355   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1356   ASSERT_TRUE(file_util::PathExists(file_name_from));
1357
1358   // Create a subdirectory.
1359   FilePath subdir_name_from =
1360       dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
1361   file_util::CreateDirectory(subdir_name_from);
1362   ASSERT_TRUE(file_util::PathExists(subdir_name_from));
1363
1364   // Create a file under the subdirectory.
1365   FilePath file_name2_from =
1366       subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1367   CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
1368   ASSERT_TRUE(file_util::PathExists(file_name2_from));
1369
1370   // Copy the directory not recursively.
1371   FilePath dir_name_to =
1372       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
1373   FilePath file_name_to =
1374       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1375   FilePath subdir_name_to =
1376       dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
1377
1378   // Create the destination directory.
1379   file_util::CreateDirectory(dir_name_to);
1380   ASSERT_TRUE(file_util::PathExists(dir_name_to));
1381
1382   EXPECT_TRUE(file_util::CopyDirectory(dir_name_from, dir_name_to, false));
1383
1384   // Check everything has been copied.
1385   EXPECT_TRUE(file_util::PathExists(dir_name_from));
1386   EXPECT_TRUE(file_util::PathExists(file_name_from));
1387   EXPECT_TRUE(file_util::PathExists(subdir_name_from));
1388   EXPECT_TRUE(file_util::PathExists(file_name2_from));
1389   EXPECT_TRUE(file_util::PathExists(dir_name_to));
1390   EXPECT_TRUE(file_util::PathExists(file_name_to));
1391   EXPECT_FALSE(file_util::PathExists(subdir_name_to));
1392 }
1393
1394 TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToNew) {
1395   // Create a file
1396   FilePath file_name_from =
1397       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1398   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1399   ASSERT_TRUE(file_util::PathExists(file_name_from));
1400
1401   // The destination name
1402   FilePath file_name_to = temp_dir_.path().Append(
1403       FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
1404   ASSERT_FALSE(file_util::PathExists(file_name_to));
1405
1406   EXPECT_TRUE(file_util::CopyDirectory(file_name_from, file_name_to, true));
1407
1408   // Check the has been copied
1409   EXPECT_TRUE(file_util::PathExists(file_name_to));
1410 }
1411
1412 TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExisting) {
1413   // Create a file
1414   FilePath file_name_from =
1415       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1416   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1417   ASSERT_TRUE(file_util::PathExists(file_name_from));
1418
1419   // The destination name
1420   FilePath file_name_to = temp_dir_.path().Append(
1421       FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
1422   CreateTextFile(file_name_to, L"Old file content");
1423   ASSERT_TRUE(file_util::PathExists(file_name_to));
1424
1425   EXPECT_TRUE(file_util::CopyDirectory(file_name_from, file_name_to, true));
1426
1427   // Check the has been copied
1428   EXPECT_TRUE(file_util::PathExists(file_name_to));
1429   EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
1430 }
1431
1432 TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExistingDirectory) {
1433   // Create a file
1434   FilePath file_name_from =
1435       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1436   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1437   ASSERT_TRUE(file_util::PathExists(file_name_from));
1438
1439   // The destination
1440   FilePath dir_name_to =
1441       temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
1442   file_util::CreateDirectory(dir_name_to);
1443   ASSERT_TRUE(file_util::PathExists(dir_name_to));
1444   FilePath file_name_to =
1445       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1446
1447   EXPECT_TRUE(file_util::CopyDirectory(file_name_from, dir_name_to, true));
1448
1449   // Check the has been copied
1450   EXPECT_TRUE(file_util::PathExists(file_name_to));
1451 }
1452
1453 TEST_F(FileUtilTest, CopyDirectoryWithTrailingSeparators) {
1454   // Create a directory.
1455   FilePath dir_name_from =
1456       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
1457   file_util::CreateDirectory(dir_name_from);
1458   ASSERT_TRUE(file_util::PathExists(dir_name_from));
1459
1460   // Create a file under the directory.
1461   FilePath file_name_from =
1462       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1463   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1464   ASSERT_TRUE(file_util::PathExists(file_name_from));
1465
1466   // Copy the directory recursively.
1467   FilePath dir_name_to =
1468       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
1469   FilePath file_name_to =
1470       dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1471
1472   // Create from path with trailing separators.
1473 #if defined(OS_WIN)
1474   FilePath from_path =
1475       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir\\\\\\"));
1476 #elif defined (OS_POSIX)
1477   FilePath from_path =
1478       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir///"));
1479 #endif
1480
1481   EXPECT_TRUE(file_util::CopyDirectory(from_path, dir_name_to, true));
1482
1483   // Check everything has been copied.
1484   EXPECT_TRUE(file_util::PathExists(dir_name_from));
1485   EXPECT_TRUE(file_util::PathExists(file_name_from));
1486   EXPECT_TRUE(file_util::PathExists(dir_name_to));
1487   EXPECT_TRUE(file_util::PathExists(file_name_to));
1488 }
1489
1490 TEST_F(FileUtilTest, CopyFile) {
1491   // Create a directory
1492   FilePath dir_name_from =
1493       temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
1494   file_util::CreateDirectory(dir_name_from);
1495   ASSERT_TRUE(file_util::PathExists(dir_name_from));
1496
1497   // Create a file under the directory
1498   FilePath file_name_from =
1499       dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1500   const std::wstring file_contents(L"Gooooooooooooooooooooogle");
1501   CreateTextFile(file_name_from, file_contents);
1502   ASSERT_TRUE(file_util::PathExists(file_name_from));
1503
1504   // Copy the file.
1505   FilePath dest_file = dir_name_from.Append(FILE_PATH_LITERAL("DestFile.txt"));
1506   ASSERT_TRUE(file_util::CopyFile(file_name_from, dest_file));
1507
1508   // Copy the file to another location using '..' in the path.
1509   FilePath dest_file2(dir_name_from);
1510   dest_file2 = dest_file2.AppendASCII("..");
1511   dest_file2 = dest_file2.AppendASCII("DestFile.txt");
1512   ASSERT_FALSE(file_util::CopyFile(file_name_from, dest_file2));
1513   ASSERT_TRUE(file_util::CopyFileUnsafe(file_name_from, dest_file2));
1514
1515   FilePath dest_file2_test(dir_name_from);
1516   dest_file2_test = dest_file2_test.DirName();
1517   dest_file2_test = dest_file2_test.AppendASCII("DestFile.txt");
1518
1519   // Check everything has been copied.
1520   EXPECT_TRUE(file_util::PathExists(file_name_from));
1521   EXPECT_TRUE(file_util::PathExists(dest_file));
1522   const std::wstring read_contents = ReadTextFile(dest_file);
1523   EXPECT_EQ(file_contents, read_contents);
1524   EXPECT_TRUE(file_util::PathExists(dest_file2_test));
1525   EXPECT_TRUE(file_util::PathExists(dest_file2));
1526 }
1527
1528 // file_util winds up using autoreleased objects on the Mac, so this needs
1529 // to be a PlatformTest.
1530 typedef PlatformTest ReadOnlyFileUtilTest;
1531
1532 TEST_F(ReadOnlyFileUtilTest, ContentsEqual) {
1533   FilePath data_dir;
1534   ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir));
1535   data_dir = data_dir.AppendASCII("file_util");
1536   ASSERT_TRUE(file_util::PathExists(data_dir));
1537
1538   FilePath original_file =
1539       data_dir.Append(FILE_PATH_LITERAL("original.txt"));
1540   FilePath same_file =
1541       data_dir.Append(FILE_PATH_LITERAL("same.txt"));
1542   FilePath same_length_file =
1543       data_dir.Append(FILE_PATH_LITERAL("same_length.txt"));
1544   FilePath different_file =
1545       data_dir.Append(FILE_PATH_LITERAL("different.txt"));
1546   FilePath different_first_file =
1547       data_dir.Append(FILE_PATH_LITERAL("different_first.txt"));
1548   FilePath different_last_file =
1549       data_dir.Append(FILE_PATH_LITERAL("different_last.txt"));
1550   FilePath empty1_file =
1551       data_dir.Append(FILE_PATH_LITERAL("empty1.txt"));
1552   FilePath empty2_file =
1553       data_dir.Append(FILE_PATH_LITERAL("empty2.txt"));
1554   FilePath shortened_file =
1555       data_dir.Append(FILE_PATH_LITERAL("shortened.txt"));
1556   FilePath binary_file =
1557       data_dir.Append(FILE_PATH_LITERAL("binary_file.bin"));
1558   FilePath binary_file_same =
1559       data_dir.Append(FILE_PATH_LITERAL("binary_file_same.bin"));
1560   FilePath binary_file_diff =
1561       data_dir.Append(FILE_PATH_LITERAL("binary_file_diff.bin"));
1562
1563   EXPECT_TRUE(file_util::ContentsEqual(original_file, original_file));
1564   EXPECT_TRUE(file_util::ContentsEqual(original_file, same_file));
1565   EXPECT_FALSE(file_util::ContentsEqual(original_file, same_length_file));
1566   EXPECT_FALSE(file_util::ContentsEqual(original_file, different_file));
1567   EXPECT_FALSE(file_util::ContentsEqual(
1568       FilePath(FILE_PATH_LITERAL("bogusname")),
1569       FilePath(FILE_PATH_LITERAL("bogusname"))));
1570   EXPECT_FALSE(file_util::ContentsEqual(original_file, different_first_file));
1571   EXPECT_FALSE(file_util::ContentsEqual(original_file, different_last_file));
1572   EXPECT_TRUE(file_util::ContentsEqual(empty1_file, empty2_file));
1573   EXPECT_FALSE(file_util::ContentsEqual(original_file, shortened_file));
1574   EXPECT_FALSE(file_util::ContentsEqual(shortened_file, original_file));
1575   EXPECT_TRUE(file_util::ContentsEqual(binary_file, binary_file_same));
1576   EXPECT_FALSE(file_util::ContentsEqual(binary_file, binary_file_diff));
1577 }
1578
1579 TEST_F(ReadOnlyFileUtilTest, TextContentsEqual) {
1580   FilePath data_dir;
1581   ASSERT_TRUE(PathService::Get(base::DIR_TEST_DATA, &data_dir));
1582   data_dir = data_dir.AppendASCII("file_util");
1583   ASSERT_TRUE(file_util::PathExists(data_dir));
1584
1585   FilePath original_file =
1586       data_dir.Append(FILE_PATH_LITERAL("original.txt"));
1587   FilePath same_file =
1588       data_dir.Append(FILE_PATH_LITERAL("same.txt"));
1589   FilePath crlf_file =
1590       data_dir.Append(FILE_PATH_LITERAL("crlf.txt"));
1591   FilePath shortened_file =
1592       data_dir.Append(FILE_PATH_LITERAL("shortened.txt"));
1593   FilePath different_file =
1594       data_dir.Append(FILE_PATH_LITERAL("different.txt"));
1595   FilePath different_first_file =
1596       data_dir.Append(FILE_PATH_LITERAL("different_first.txt"));
1597   FilePath different_last_file =
1598       data_dir.Append(FILE_PATH_LITERAL("different_last.txt"));
1599   FilePath first1_file =
1600       data_dir.Append(FILE_PATH_LITERAL("first1.txt"));
1601   FilePath first2_file =
1602       data_dir.Append(FILE_PATH_LITERAL("first2.txt"));
1603   FilePath empty1_file =
1604       data_dir.Append(FILE_PATH_LITERAL("empty1.txt"));
1605   FilePath empty2_file =
1606       data_dir.Append(FILE_PATH_LITERAL("empty2.txt"));
1607   FilePath blank_line_file =
1608       data_dir.Append(FILE_PATH_LITERAL("blank_line.txt"));
1609   FilePath blank_line_crlf_file =
1610       data_dir.Append(FILE_PATH_LITERAL("blank_line_crlf.txt"));
1611
1612   EXPECT_TRUE(file_util::TextContentsEqual(original_file, same_file));
1613   EXPECT_TRUE(file_util::TextContentsEqual(original_file, crlf_file));
1614   EXPECT_FALSE(file_util::TextContentsEqual(original_file, shortened_file));
1615   EXPECT_FALSE(file_util::TextContentsEqual(original_file, different_file));
1616   EXPECT_FALSE(file_util::TextContentsEqual(original_file,
1617                                             different_first_file));
1618   EXPECT_FALSE(file_util::TextContentsEqual(original_file,
1619                                             different_last_file));
1620   EXPECT_FALSE(file_util::TextContentsEqual(first1_file, first2_file));
1621   EXPECT_TRUE(file_util::TextContentsEqual(empty1_file, empty2_file));
1622   EXPECT_FALSE(file_util::TextContentsEqual(original_file, empty1_file));
1623   EXPECT_TRUE(file_util::TextContentsEqual(blank_line_file,
1624                                            blank_line_crlf_file));
1625 }
1626
1627 // We don't need equivalent functionality outside of Windows.
1628 #if defined(OS_WIN)
1629 TEST_F(FileUtilTest, CopyAndDeleteDirectoryTest) {
1630   // Create a directory
1631   FilePath dir_name_from =
1632       temp_dir_.path().Append(FILE_PATH_LITERAL("CopyAndDelete_From_Subdir"));
1633   file_util::CreateDirectory(dir_name_from);
1634   ASSERT_TRUE(file_util::PathExists(dir_name_from));
1635
1636   // Create a file under the directory
1637   FilePath file_name_from =
1638       dir_name_from.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
1639   CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1640   ASSERT_TRUE(file_util::PathExists(file_name_from));
1641
1642   // Move the directory by using CopyAndDeleteDirectory
1643   FilePath dir_name_to = temp_dir_.path().Append(
1644       FILE_PATH_LITERAL("CopyAndDelete_To_Subdir"));
1645   FilePath file_name_to =
1646       dir_name_to.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
1647
1648   ASSERT_FALSE(file_util::PathExists(dir_name_to));
1649
1650   EXPECT_TRUE(file_util::CopyAndDeleteDirectory(dir_name_from, dir_name_to));
1651
1652   // Check everything has been moved.
1653   EXPECT_FALSE(file_util::PathExists(dir_name_from));
1654   EXPECT_FALSE(file_util::PathExists(file_name_from));
1655   EXPECT_TRUE(file_util::PathExists(dir_name_to));
1656   EXPECT_TRUE(file_util::PathExists(file_name_to));
1657 }
1658
1659 TEST_F(FileUtilTest, GetTempDirTest) {
1660   static const TCHAR* kTmpKey = _T("TMP");
1661   static const TCHAR* kTmpValues[] = {
1662     _T(""), _T("C:"), _T("C:\\"), _T("C:\\tmp"), _T("C:\\tmp\\")
1663   };
1664   // Save the original $TMP.
1665   size_t original_tmp_size;
1666   TCHAR* original_tmp;
1667   ASSERT_EQ(0, ::_tdupenv_s(&original_tmp, &original_tmp_size, kTmpKey));
1668   // original_tmp may be NULL.
1669
1670   for (unsigned int i = 0; i < arraysize(kTmpValues); ++i) {
1671     FilePath path;
1672     ::_tputenv_s(kTmpKey, kTmpValues[i]);
1673     file_util::GetTempDir(&path);
1674     EXPECT_TRUE(path.IsAbsolute()) << "$TMP=" << kTmpValues[i] <<
1675         " result=" << path.value();
1676   }
1677
1678   // Restore the original $TMP.
1679   if (original_tmp) {
1680     ::_tputenv_s(kTmpKey, original_tmp);
1681     free(original_tmp);
1682   } else {
1683     ::_tputenv_s(kTmpKey, _T(""));
1684   }
1685 }
1686 #endif  // OS_WIN
1687
1688 TEST_F(FileUtilTest, CreateTemporaryFileTest) {
1689   FilePath temp_files[3];
1690   for (int i = 0; i < 3; i++) {
1691     ASSERT_TRUE(file_util::CreateTemporaryFile(&(temp_files[i])));
1692     EXPECT_TRUE(file_util::PathExists(temp_files[i]));
1693     EXPECT_FALSE(file_util::DirectoryExists(temp_files[i]));
1694   }
1695   for (int i = 0; i < 3; i++)
1696     EXPECT_FALSE(temp_files[i] == temp_files[(i+1)%3]);
1697   for (int i = 0; i < 3; i++)
1698     EXPECT_TRUE(file_util::Delete(temp_files[i], false));
1699 }
1700
1701 TEST_F(FileUtilTest, CreateAndOpenTemporaryFileTest) {
1702   FilePath names[3];
1703   FILE* fps[3];
1704   int i;
1705
1706   // Create; make sure they are open and exist.
1707   for (i = 0; i < 3; ++i) {
1708     fps[i] = file_util::CreateAndOpenTemporaryFile(&(names[i]));
1709     ASSERT_TRUE(fps[i]);
1710     EXPECT_TRUE(file_util::PathExists(names[i]));
1711   }
1712
1713   // Make sure all names are unique.
1714   for (i = 0; i < 3; ++i) {
1715     EXPECT_FALSE(names[i] == names[(i+1)%3]);
1716   }
1717
1718   // Close and delete.
1719   for (i = 0; i < 3; ++i) {
1720     EXPECT_TRUE(file_util::CloseFile(fps[i]));
1721     EXPECT_TRUE(file_util::Delete(names[i], false));
1722   }
1723 }
1724
1725 TEST_F(FileUtilTest, CreateNewTempDirectoryTest) {
1726   FilePath temp_dir;
1727   ASSERT_TRUE(file_util::CreateNewTempDirectory(FilePath::StringType(),
1728                                                 &temp_dir));
1729   EXPECT_TRUE(file_util::PathExists(temp_dir));
1730   EXPECT_TRUE(file_util::Delete(temp_dir, false));
1731 }
1732
1733 TEST_F(FileUtilTest, CreateNewTemporaryDirInDirTest) {
1734   FilePath new_dir;
1735   ASSERT_TRUE(file_util::CreateTemporaryDirInDir(
1736                   temp_dir_.path(),
1737                   FILE_PATH_LITERAL("CreateNewTemporaryDirInDirTest"),
1738                   &new_dir));
1739   EXPECT_TRUE(file_util::PathExists(new_dir));
1740   EXPECT_TRUE(temp_dir_.path().IsParent(new_dir));
1741   EXPECT_TRUE(file_util::Delete(new_dir, false));
1742 }
1743
1744 TEST_F(FileUtilTest, GetShmemTempDirTest) {
1745   FilePath dir;
1746   EXPECT_TRUE(file_util::GetShmemTempDir(&dir, false));
1747   EXPECT_TRUE(file_util::DirectoryExists(dir));
1748 }
1749
1750 TEST_F(FileUtilTest, CreateDirectoryTest) {
1751   FilePath test_root =
1752       temp_dir_.path().Append(FILE_PATH_LITERAL("create_directory_test"));
1753 #if defined(OS_WIN)
1754   FilePath test_path =
1755       test_root.Append(FILE_PATH_LITERAL("dir\\tree\\likely\\doesnt\\exist\\"));
1756 #elif defined(OS_POSIX)
1757   FilePath test_path =
1758       test_root.Append(FILE_PATH_LITERAL("dir/tree/likely/doesnt/exist/"));
1759 #endif
1760
1761   EXPECT_FALSE(file_util::PathExists(test_path));
1762   EXPECT_TRUE(file_util::CreateDirectory(test_path));
1763   EXPECT_TRUE(file_util::PathExists(test_path));
1764   // CreateDirectory returns true if the DirectoryExists returns true.
1765   EXPECT_TRUE(file_util::CreateDirectory(test_path));
1766
1767   // Doesn't work to create it on top of a non-dir
1768   test_path = test_path.Append(FILE_PATH_LITERAL("foobar.txt"));
1769   EXPECT_FALSE(file_util::PathExists(test_path));
1770   CreateTextFile(test_path, L"test file");
1771   EXPECT_TRUE(file_util::PathExists(test_path));
1772   EXPECT_FALSE(file_util::CreateDirectory(test_path));
1773
1774   EXPECT_TRUE(file_util::Delete(test_root, true));
1775   EXPECT_FALSE(file_util::PathExists(test_root));
1776   EXPECT_FALSE(file_util::PathExists(test_path));
1777
1778   // Verify assumptions made by the Windows implementation:
1779   // 1. The current directory always exists.
1780   // 2. The root directory always exists.
1781   ASSERT_TRUE(file_util::DirectoryExists(
1782       FilePath(FilePath::kCurrentDirectory)));
1783   FilePath top_level = test_root;
1784   while (top_level != top_level.DirName()) {
1785     top_level = top_level.DirName();
1786   }
1787   ASSERT_TRUE(file_util::DirectoryExists(top_level));
1788
1789   // Given these assumptions hold, it should be safe to
1790   // test that "creating" these directories succeeds.
1791   EXPECT_TRUE(file_util::CreateDirectory(
1792       FilePath(FilePath::kCurrentDirectory)));
1793   EXPECT_TRUE(file_util::CreateDirectory(top_level));
1794
1795 #if defined(OS_WIN)
1796   FilePath invalid_drive(FILE_PATH_LITERAL("o:\\"));
1797   FilePath invalid_path =
1798       invalid_drive.Append(FILE_PATH_LITERAL("some\\inaccessible\\dir"));
1799   if (!file_util::PathExists(invalid_drive)) {
1800     EXPECT_FALSE(file_util::CreateDirectory(invalid_path));
1801   }
1802 #endif
1803 }
1804
1805 TEST_F(FileUtilTest, DetectDirectoryTest) {
1806   // Check a directory
1807   FilePath test_root =
1808       temp_dir_.path().Append(FILE_PATH_LITERAL("detect_directory_test"));
1809   EXPECT_FALSE(file_util::PathExists(test_root));
1810   EXPECT_TRUE(file_util::CreateDirectory(test_root));
1811   EXPECT_TRUE(file_util::PathExists(test_root));
1812   EXPECT_TRUE(file_util::DirectoryExists(test_root));
1813   // Check a file
1814   FilePath test_path =
1815       test_root.Append(FILE_PATH_LITERAL("foobar.txt"));
1816   EXPECT_FALSE(file_util::PathExists(test_path));
1817   CreateTextFile(test_path, L"test file");
1818   EXPECT_TRUE(file_util::PathExists(test_path));
1819   EXPECT_FALSE(file_util::DirectoryExists(test_path));
1820   EXPECT_TRUE(file_util::Delete(test_path, false));
1821
1822   EXPECT_TRUE(file_util::Delete(test_root, true));
1823 }
1824
1825 TEST_F(FileUtilTest, FileEnumeratorTest) {
1826   // Test an empty directory.
1827   FileEnumerator f0(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
1828   EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
1829   EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
1830
1831   // Test an empty directory, non-recursively, including "..".
1832   FileEnumerator f0_dotdot(temp_dir_.path(), false,
1833       FILES_AND_DIRECTORIES | FileEnumerator::INCLUDE_DOT_DOT);
1834   EXPECT_EQ(temp_dir_.path().Append(FILE_PATH_LITERAL("..")).value(),
1835             f0_dotdot.Next().value());
1836   EXPECT_EQ(FILE_PATH_LITERAL(""),
1837             f0_dotdot.Next().value());
1838
1839   // create the directories
1840   FilePath dir1 = temp_dir_.path().Append(FILE_PATH_LITERAL("dir1"));
1841   EXPECT_TRUE(file_util::CreateDirectory(dir1));
1842   FilePath dir2 = temp_dir_.path().Append(FILE_PATH_LITERAL("dir2"));
1843   EXPECT_TRUE(file_util::CreateDirectory(dir2));
1844   FilePath dir2inner = dir2.Append(FILE_PATH_LITERAL("inner"));
1845   EXPECT_TRUE(file_util::CreateDirectory(dir2inner));
1846
1847   // create the files
1848   FilePath dir2file = dir2.Append(FILE_PATH_LITERAL("dir2file.txt"));
1849   CreateTextFile(dir2file, std::wstring());
1850   FilePath dir2innerfile = dir2inner.Append(FILE_PATH_LITERAL("innerfile.txt"));
1851   CreateTextFile(dir2innerfile, std::wstring());
1852   FilePath file1 = temp_dir_.path().Append(FILE_PATH_LITERAL("file1.txt"));
1853   CreateTextFile(file1, std::wstring());
1854   FilePath file2_rel = dir2.Append(FilePath::kParentDirectory)
1855       .Append(FILE_PATH_LITERAL("file2.txt"));
1856   CreateTextFile(file2_rel, std::wstring());
1857   FilePath file2_abs = temp_dir_.path().Append(FILE_PATH_LITERAL("file2.txt"));
1858
1859   // Only enumerate files.
1860   FileEnumerator f1(temp_dir_.path(), true, FileEnumerator::FILES);
1861   FindResultCollector c1(f1);
1862   EXPECT_TRUE(c1.HasFile(file1));
1863   EXPECT_TRUE(c1.HasFile(file2_abs));
1864   EXPECT_TRUE(c1.HasFile(dir2file));
1865   EXPECT_TRUE(c1.HasFile(dir2innerfile));
1866   EXPECT_EQ(c1.size(), 4);
1867
1868   // Only enumerate directories.
1869   FileEnumerator f2(temp_dir_.path(), true, FileEnumerator::DIRECTORIES);
1870   FindResultCollector c2(f2);
1871   EXPECT_TRUE(c2.HasFile(dir1));
1872   EXPECT_TRUE(c2.HasFile(dir2));
1873   EXPECT_TRUE(c2.HasFile(dir2inner));
1874   EXPECT_EQ(c2.size(), 3);
1875
1876   // Only enumerate directories non-recursively.
1877   FileEnumerator f2_non_recursive(
1878       temp_dir_.path(), false, FileEnumerator::DIRECTORIES);
1879   FindResultCollector c2_non_recursive(f2_non_recursive);
1880   EXPECT_TRUE(c2_non_recursive.HasFile(dir1));
1881   EXPECT_TRUE(c2_non_recursive.HasFile(dir2));
1882   EXPECT_EQ(c2_non_recursive.size(), 2);
1883
1884   // Only enumerate directories, non-recursively, including "..".
1885   FileEnumerator f2_dotdot(temp_dir_.path(), false,
1886                            FileEnumerator::DIRECTORIES |
1887                            FileEnumerator::INCLUDE_DOT_DOT);
1888   FindResultCollector c2_dotdot(f2_dotdot);
1889   EXPECT_TRUE(c2_dotdot.HasFile(dir1));
1890   EXPECT_TRUE(c2_dotdot.HasFile(dir2));
1891   EXPECT_TRUE(c2_dotdot.HasFile(
1892       temp_dir_.path().Append(FILE_PATH_LITERAL(".."))));
1893   EXPECT_EQ(c2_dotdot.size(), 3);
1894
1895   // Enumerate files and directories.
1896   FileEnumerator f3(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
1897   FindResultCollector c3(f3);
1898   EXPECT_TRUE(c3.HasFile(dir1));
1899   EXPECT_TRUE(c3.HasFile(dir2));
1900   EXPECT_TRUE(c3.HasFile(file1));
1901   EXPECT_TRUE(c3.HasFile(file2_abs));
1902   EXPECT_TRUE(c3.HasFile(dir2file));
1903   EXPECT_TRUE(c3.HasFile(dir2inner));
1904   EXPECT_TRUE(c3.HasFile(dir2innerfile));
1905   EXPECT_EQ(c3.size(), 7);
1906
1907   // Non-recursive operation.
1908   FileEnumerator f4(temp_dir_.path(), false, FILES_AND_DIRECTORIES);
1909   FindResultCollector c4(f4);
1910   EXPECT_TRUE(c4.HasFile(dir2));
1911   EXPECT_TRUE(c4.HasFile(dir2));
1912   EXPECT_TRUE(c4.HasFile(file1));
1913   EXPECT_TRUE(c4.HasFile(file2_abs));
1914   EXPECT_EQ(c4.size(), 4);
1915
1916   // Enumerate with a pattern.
1917   FileEnumerator f5(temp_dir_.path(), true, FILES_AND_DIRECTORIES,
1918       FILE_PATH_LITERAL("dir*"));
1919   FindResultCollector c5(f5);
1920   EXPECT_TRUE(c5.HasFile(dir1));
1921   EXPECT_TRUE(c5.HasFile(dir2));
1922   EXPECT_TRUE(c5.HasFile(dir2file));
1923   EXPECT_TRUE(c5.HasFile(dir2inner));
1924   EXPECT_TRUE(c5.HasFile(dir2innerfile));
1925   EXPECT_EQ(c5.size(), 5);
1926
1927   // Make sure the destructor closes the find handle while in the middle of a
1928   // query to allow TearDown to delete the directory.
1929   FileEnumerator f6(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
1930   EXPECT_FALSE(f6.Next().value().empty());  // Should have found something
1931                                             // (we don't care what).
1932 }
1933
1934 TEST_F(FileUtilTest, AppendToFile) {
1935   FilePath data_dir =
1936       temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
1937
1938   // Create a fresh, empty copy of this directory.
1939   if (file_util::PathExists(data_dir)) {
1940     ASSERT_TRUE(file_util::Delete(data_dir, true));
1941   }
1942   ASSERT_TRUE(file_util::CreateDirectory(data_dir));
1943
1944   // Create a fresh, empty copy of this directory.
1945   if (file_util::PathExists(data_dir)) {
1946     ASSERT_TRUE(file_util::Delete(data_dir, true));
1947   }
1948   ASSERT_TRUE(file_util::CreateDirectory(data_dir));
1949   FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
1950
1951   std::string data("hello");
1952   EXPECT_EQ(-1, file_util::AppendToFile(foobar, data.c_str(), data.length()));
1953   EXPECT_EQ(static_cast<int>(data.length()),
1954             file_util::WriteFile(foobar, data.c_str(), data.length()));
1955   EXPECT_EQ(static_cast<int>(data.length()),
1956             file_util::AppendToFile(foobar, data.c_str(), data.length()));
1957
1958   const std::wstring read_content = ReadTextFile(foobar);
1959   EXPECT_EQ(L"hellohello", read_content);
1960 }
1961
1962 TEST_F(FileUtilTest, TouchFile) {
1963   FilePath data_dir =
1964       temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
1965
1966   // Create a fresh, empty copy of this directory.
1967   if (file_util::PathExists(data_dir)) {
1968     ASSERT_TRUE(file_util::Delete(data_dir, true));
1969   }
1970   ASSERT_TRUE(file_util::CreateDirectory(data_dir));
1971
1972   FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
1973   std::string data("hello");
1974   ASSERT_TRUE(file_util::WriteFile(foobar, data.c_str(), data.length()));
1975
1976   base::Time access_time;
1977   // This timestamp is divisible by one day (in local timezone),
1978   // to make it work on FAT too.
1979   ASSERT_TRUE(base::Time::FromString("Wed, 16 Nov 1994, 00:00:00",
1980                                      &access_time));
1981
1982   base::Time modification_time;
1983   // Note that this timestamp is divisible by two (seconds) - FAT stores
1984   // modification times with 2s resolution.
1985   ASSERT_TRUE(base::Time::FromString("Tue, 15 Nov 1994, 12:45:26 GMT",
1986               &modification_time));
1987
1988   ASSERT_TRUE(file_util::TouchFile(foobar, access_time, modification_time));
1989   base::PlatformFileInfo file_info;
1990   ASSERT_TRUE(file_util::GetFileInfo(foobar, &file_info));
1991   EXPECT_EQ(file_info.last_accessed.ToInternalValue(),
1992             access_time.ToInternalValue());
1993   EXPECT_EQ(file_info.last_modified.ToInternalValue(),
1994             modification_time.ToInternalValue());
1995 }
1996
1997 TEST_F(FileUtilTest, IsDirectoryEmpty) {
1998   FilePath empty_dir = temp_dir_.path().Append(FILE_PATH_LITERAL("EmptyDir"));
1999
2000   ASSERT_FALSE(file_util::PathExists(empty_dir));
2001
2002   ASSERT_TRUE(file_util::CreateDirectory(empty_dir));
2003
2004   EXPECT_TRUE(file_util::IsDirectoryEmpty(empty_dir));
2005
2006   FilePath foo(empty_dir.Append(FILE_PATH_LITERAL("foo.txt")));
2007   std::string bar("baz");
2008   ASSERT_TRUE(file_util::WriteFile(foo, bar.c_str(), bar.length()));
2009
2010   EXPECT_FALSE(file_util::IsDirectoryEmpty(empty_dir));
2011 }
2012
2013 #if defined(OS_POSIX)
2014
2015 // Testing VerifyPathControlledByAdmin() is hard, because there is no
2016 // way a test can make a file owned by root, or change file paths
2017 // at the root of the file system.  VerifyPathControlledByAdmin()
2018 // is implemented as a call to VerifyPathControlledByUser, which gives
2019 // us the ability to test with paths under the test's temp directory,
2020 // using a user id we control.
2021 // Pull tests of VerifyPathControlledByUserTest() into a separate test class
2022 // with a common SetUp() method.
2023 class VerifyPathControlledByUserTest : public FileUtilTest {
2024  protected:
2025   virtual void SetUp() OVERRIDE {
2026     FileUtilTest::SetUp();
2027
2028     // Create a basic structure used by each test.
2029     // base_dir_
2030     //  |-> sub_dir_
2031     //       |-> text_file_
2032
2033     base_dir_ = temp_dir_.path().AppendASCII("base_dir");
2034     ASSERT_TRUE(file_util::CreateDirectory(base_dir_));
2035
2036     sub_dir_ = base_dir_.AppendASCII("sub_dir");
2037     ASSERT_TRUE(file_util::CreateDirectory(sub_dir_));
2038
2039     text_file_ = sub_dir_.AppendASCII("file.txt");
2040     CreateTextFile(text_file_, L"This text file has some text in it.");
2041
2042     // Get the user and group files are created with from |base_dir_|.
2043     struct stat stat_buf;
2044     ASSERT_EQ(0, stat(base_dir_.value().c_str(), &stat_buf));
2045     uid_ = stat_buf.st_uid;
2046     ok_gids_.insert(stat_buf.st_gid);
2047     bad_gids_.insert(stat_buf.st_gid + 1);
2048
2049     ASSERT_EQ(uid_, getuid());  // This process should be the owner.
2050
2051     // To ensure that umask settings do not cause the initial state
2052     // of permissions to be different from what we expect, explicitly
2053     // set permissions on the directories we create.
2054     // Make all files and directories non-world-writable.
2055
2056     // Users and group can read, write, traverse
2057     int enabled_permissions =
2058         file_util::FILE_PERMISSION_USER_MASK |
2059         file_util::FILE_PERMISSION_GROUP_MASK;
2060     // Other users can't read, write, traverse
2061     int disabled_permissions =
2062         file_util::FILE_PERMISSION_OTHERS_MASK;
2063
2064     ASSERT_NO_FATAL_FAILURE(
2065         ChangePosixFilePermissions(
2066             base_dir_, enabled_permissions, disabled_permissions));
2067     ASSERT_NO_FATAL_FAILURE(
2068         ChangePosixFilePermissions(
2069             sub_dir_, enabled_permissions, disabled_permissions));
2070   }
2071
2072   FilePath base_dir_;
2073   FilePath sub_dir_;
2074   FilePath text_file_;
2075   uid_t uid_;
2076
2077   std::set<gid_t> ok_gids_;
2078   std::set<gid_t> bad_gids_;
2079 };
2080
2081 TEST_F(VerifyPathControlledByUserTest, BadPaths) {
2082   // File does not exist.
2083   FilePath does_not_exist = base_dir_.AppendASCII("does")
2084                                      .AppendASCII("not")
2085                                      .AppendASCII("exist");
2086   EXPECT_FALSE(
2087       file_util::VerifyPathControlledByUser(
2088           base_dir_, does_not_exist, uid_, ok_gids_));
2089
2090   // |base| not a subpath of |path|.
2091   EXPECT_FALSE(
2092       file_util::VerifyPathControlledByUser(
2093           sub_dir_, base_dir_, uid_, ok_gids_));
2094
2095   // An empty base path will fail to be a prefix for any path.
2096   FilePath empty;
2097   EXPECT_FALSE(
2098       file_util::VerifyPathControlledByUser(
2099           empty, base_dir_, uid_, ok_gids_));
2100
2101   // Finding that a bad call fails proves nothing unless a good call succeeds.
2102   EXPECT_TRUE(
2103       file_util::VerifyPathControlledByUser(
2104           base_dir_, sub_dir_, uid_, ok_gids_));
2105 }
2106
2107 TEST_F(VerifyPathControlledByUserTest, Symlinks) {
2108   // Symlinks in the path should cause failure.
2109
2110   // Symlink to the file at the end of the path.
2111   FilePath file_link =  base_dir_.AppendASCII("file_link");
2112   ASSERT_TRUE(file_util::CreateSymbolicLink(text_file_, file_link))
2113       << "Failed to create symlink.";
2114
2115   EXPECT_FALSE(
2116       file_util::VerifyPathControlledByUser(
2117           base_dir_, file_link, uid_, ok_gids_));
2118   EXPECT_FALSE(
2119       file_util::VerifyPathControlledByUser(
2120           file_link, file_link, uid_, ok_gids_));
2121
2122   // Symlink from one directory to another within the path.
2123   FilePath link_to_sub_dir =  base_dir_.AppendASCII("link_to_sub_dir");
2124   ASSERT_TRUE(file_util::CreateSymbolicLink(sub_dir_, link_to_sub_dir))
2125     << "Failed to create symlink.";
2126
2127   FilePath file_path_with_link = link_to_sub_dir.AppendASCII("file.txt");
2128   ASSERT_TRUE(file_util::PathExists(file_path_with_link));
2129
2130   EXPECT_FALSE(
2131       file_util::VerifyPathControlledByUser(
2132           base_dir_, file_path_with_link, uid_, ok_gids_));
2133
2134   EXPECT_FALSE(
2135       file_util::VerifyPathControlledByUser(
2136           link_to_sub_dir, file_path_with_link, uid_, ok_gids_));
2137
2138   // Symlinks in parents of base path are allowed.
2139   EXPECT_TRUE(
2140       file_util::VerifyPathControlledByUser(
2141           file_path_with_link, file_path_with_link, uid_, ok_gids_));
2142 }
2143
2144 TEST_F(VerifyPathControlledByUserTest, OwnershipChecks) {
2145   // Get a uid that is not the uid of files we create.
2146   uid_t bad_uid = uid_ + 1;
2147
2148   // Make all files and directories non-world-writable.
2149   ASSERT_NO_FATAL_FAILURE(
2150       ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
2151   ASSERT_NO_FATAL_FAILURE(
2152       ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
2153   ASSERT_NO_FATAL_FAILURE(
2154       ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
2155
2156   // We control these paths.
2157   EXPECT_TRUE(
2158       file_util::VerifyPathControlledByUser(
2159           base_dir_, sub_dir_, uid_, ok_gids_));
2160   EXPECT_TRUE(
2161       file_util::VerifyPathControlledByUser(
2162           base_dir_, text_file_, uid_, ok_gids_));
2163   EXPECT_TRUE(
2164       file_util::VerifyPathControlledByUser(
2165           sub_dir_, text_file_, uid_, ok_gids_));
2166
2167   // Another user does not control these paths.
2168   EXPECT_FALSE(
2169       file_util::VerifyPathControlledByUser(
2170           base_dir_, sub_dir_, bad_uid, ok_gids_));
2171   EXPECT_FALSE(
2172       file_util::VerifyPathControlledByUser(
2173           base_dir_, text_file_, bad_uid, ok_gids_));
2174   EXPECT_FALSE(
2175       file_util::VerifyPathControlledByUser(
2176           sub_dir_, text_file_, bad_uid, ok_gids_));
2177
2178   // Another group does not control the paths.
2179   EXPECT_FALSE(
2180       file_util::VerifyPathControlledByUser(
2181           base_dir_, sub_dir_, uid_, bad_gids_));
2182   EXPECT_FALSE(
2183       file_util::VerifyPathControlledByUser(
2184           base_dir_, text_file_, uid_, bad_gids_));
2185   EXPECT_FALSE(
2186       file_util::VerifyPathControlledByUser(
2187           sub_dir_, text_file_, uid_, bad_gids_));
2188 }
2189
2190 TEST_F(VerifyPathControlledByUserTest, GroupWriteTest) {
2191   // Make all files and directories writable only by their owner.
2192   ASSERT_NO_FATAL_FAILURE(
2193       ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH|S_IWGRP));
2194   ASSERT_NO_FATAL_FAILURE(
2195       ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH|S_IWGRP));
2196   ASSERT_NO_FATAL_FAILURE(
2197       ChangePosixFilePermissions(text_file_, 0u, S_IWOTH|S_IWGRP));
2198
2199   // Any group is okay because the path is not group-writable.
2200   EXPECT_TRUE(
2201       file_util::VerifyPathControlledByUser(
2202           base_dir_, sub_dir_, uid_, ok_gids_));
2203   EXPECT_TRUE(
2204       file_util::VerifyPathControlledByUser(
2205           base_dir_, text_file_, uid_, ok_gids_));
2206   EXPECT_TRUE(
2207       file_util::VerifyPathControlledByUser(
2208           sub_dir_, text_file_, uid_, ok_gids_));
2209
2210   EXPECT_TRUE(
2211       file_util::VerifyPathControlledByUser(
2212           base_dir_, sub_dir_, uid_, bad_gids_));
2213   EXPECT_TRUE(
2214       file_util::VerifyPathControlledByUser(
2215           base_dir_, text_file_, uid_, bad_gids_));
2216   EXPECT_TRUE(
2217       file_util::VerifyPathControlledByUser(
2218           sub_dir_, text_file_, uid_, bad_gids_));
2219
2220   // No group is okay, because we don't check the group
2221   // if no group can write.
2222   std::set<gid_t> no_gids;  // Empty set of gids.
2223   EXPECT_TRUE(
2224       file_util::VerifyPathControlledByUser(
2225           base_dir_, sub_dir_, uid_, no_gids));
2226   EXPECT_TRUE(
2227       file_util::VerifyPathControlledByUser(
2228           base_dir_, text_file_, uid_, no_gids));
2229   EXPECT_TRUE(
2230       file_util::VerifyPathControlledByUser(
2231           sub_dir_, text_file_, uid_, no_gids));
2232
2233
2234   // Make all files and directories writable by their group.
2235   ASSERT_NO_FATAL_FAILURE(
2236       ChangePosixFilePermissions(base_dir_, S_IWGRP, 0u));
2237   ASSERT_NO_FATAL_FAILURE(
2238       ChangePosixFilePermissions(sub_dir_, S_IWGRP, 0u));
2239   ASSERT_NO_FATAL_FAILURE(
2240       ChangePosixFilePermissions(text_file_, S_IWGRP, 0u));
2241
2242   // Now |ok_gids_| works, but |bad_gids_| fails.
2243   EXPECT_TRUE(
2244       file_util::VerifyPathControlledByUser(
2245           base_dir_, sub_dir_, uid_, ok_gids_));
2246   EXPECT_TRUE(
2247       file_util::VerifyPathControlledByUser(
2248           base_dir_, text_file_, uid_, ok_gids_));
2249   EXPECT_TRUE(
2250       file_util::VerifyPathControlledByUser(
2251           sub_dir_, text_file_, uid_, ok_gids_));
2252
2253   EXPECT_FALSE(
2254       file_util::VerifyPathControlledByUser(
2255           base_dir_, sub_dir_, uid_, bad_gids_));
2256   EXPECT_FALSE(
2257       file_util::VerifyPathControlledByUser(
2258           base_dir_, text_file_, uid_, bad_gids_));
2259   EXPECT_FALSE(
2260       file_util::VerifyPathControlledByUser(
2261           sub_dir_, text_file_, uid_, bad_gids_));
2262
2263   // Because any group in the group set is allowed,
2264   // the union of good and bad gids passes.
2265
2266   std::set<gid_t> multiple_gids;
2267   std::set_union(
2268       ok_gids_.begin(), ok_gids_.end(),
2269       bad_gids_.begin(), bad_gids_.end(),
2270       std::inserter(multiple_gids, multiple_gids.begin()));
2271
2272   EXPECT_TRUE(
2273       file_util::VerifyPathControlledByUser(
2274           base_dir_, sub_dir_, uid_, multiple_gids));
2275   EXPECT_TRUE(
2276       file_util::VerifyPathControlledByUser(
2277           base_dir_, text_file_, uid_, multiple_gids));
2278   EXPECT_TRUE(
2279       file_util::VerifyPathControlledByUser(
2280           sub_dir_, text_file_, uid_, multiple_gids));
2281 }
2282
2283 TEST_F(VerifyPathControlledByUserTest, WriteBitChecks) {
2284   // Make all files and directories non-world-writable.
2285   ASSERT_NO_FATAL_FAILURE(
2286       ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
2287   ASSERT_NO_FATAL_FAILURE(
2288       ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
2289   ASSERT_NO_FATAL_FAILURE(
2290       ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
2291
2292   // Initialy, we control all parts of the path.
2293   EXPECT_TRUE(
2294       file_util::VerifyPathControlledByUser(
2295           base_dir_, sub_dir_, uid_, ok_gids_));
2296   EXPECT_TRUE(
2297       file_util::VerifyPathControlledByUser(
2298           base_dir_, text_file_, uid_, ok_gids_));
2299   EXPECT_TRUE(
2300       file_util::VerifyPathControlledByUser(
2301           sub_dir_, text_file_, uid_, ok_gids_));
2302
2303   // Make base_dir_ world-writable.
2304   ASSERT_NO_FATAL_FAILURE(
2305       ChangePosixFilePermissions(base_dir_, S_IWOTH, 0u));
2306   EXPECT_FALSE(
2307       file_util::VerifyPathControlledByUser(
2308           base_dir_, sub_dir_, uid_, ok_gids_));
2309   EXPECT_FALSE(
2310       file_util::VerifyPathControlledByUser(
2311           base_dir_, text_file_, uid_, ok_gids_));
2312   EXPECT_TRUE(
2313       file_util::VerifyPathControlledByUser(
2314           sub_dir_, text_file_, uid_, ok_gids_));
2315
2316   // Make sub_dir_ world writable.
2317   ASSERT_NO_FATAL_FAILURE(
2318       ChangePosixFilePermissions(sub_dir_, S_IWOTH, 0u));
2319   EXPECT_FALSE(
2320       file_util::VerifyPathControlledByUser(
2321           base_dir_, sub_dir_, uid_, ok_gids_));
2322   EXPECT_FALSE(
2323       file_util::VerifyPathControlledByUser(
2324           base_dir_, text_file_, uid_, ok_gids_));
2325   EXPECT_FALSE(
2326       file_util::VerifyPathControlledByUser(
2327           sub_dir_, text_file_, uid_, ok_gids_));
2328
2329   // Make text_file_ world writable.
2330   ASSERT_NO_FATAL_FAILURE(
2331       ChangePosixFilePermissions(text_file_, S_IWOTH, 0u));
2332   EXPECT_FALSE(
2333       file_util::VerifyPathControlledByUser(
2334           base_dir_, sub_dir_, uid_, ok_gids_));
2335   EXPECT_FALSE(
2336       file_util::VerifyPathControlledByUser(
2337           base_dir_, text_file_, uid_, ok_gids_));
2338   EXPECT_FALSE(
2339       file_util::VerifyPathControlledByUser(
2340           sub_dir_, text_file_, uid_, ok_gids_));
2341
2342   // Make sub_dir_ non-world writable.
2343   ASSERT_NO_FATAL_FAILURE(
2344       ChangePosixFilePermissions(sub_dir_, 0u, S_IWOTH));
2345   EXPECT_FALSE(
2346       file_util::VerifyPathControlledByUser(
2347           base_dir_, sub_dir_, uid_, ok_gids_));
2348   EXPECT_FALSE(
2349       file_util::VerifyPathControlledByUser(
2350           base_dir_, text_file_, uid_, ok_gids_));
2351   EXPECT_FALSE(
2352       file_util::VerifyPathControlledByUser(
2353           sub_dir_, text_file_, uid_, ok_gids_));
2354
2355   // Make base_dir_ non-world-writable.
2356   ASSERT_NO_FATAL_FAILURE(
2357       ChangePosixFilePermissions(base_dir_, 0u, S_IWOTH));
2358   EXPECT_TRUE(
2359       file_util::VerifyPathControlledByUser(
2360           base_dir_, sub_dir_, uid_, ok_gids_));
2361   EXPECT_FALSE(
2362       file_util::VerifyPathControlledByUser(
2363           base_dir_, text_file_, uid_, ok_gids_));
2364   EXPECT_FALSE(
2365       file_util::VerifyPathControlledByUser(
2366           sub_dir_, text_file_, uid_, ok_gids_));
2367
2368   // Back to the initial state: Nothing is writable, so every path
2369   // should pass.
2370   ASSERT_NO_FATAL_FAILURE(
2371       ChangePosixFilePermissions(text_file_, 0u, S_IWOTH));
2372   EXPECT_TRUE(
2373       file_util::VerifyPathControlledByUser(
2374           base_dir_, sub_dir_, uid_, ok_gids_));
2375   EXPECT_TRUE(
2376       file_util::VerifyPathControlledByUser(
2377           base_dir_, text_file_, uid_, ok_gids_));
2378   EXPECT_TRUE(
2379       file_util::VerifyPathControlledByUser(
2380           sub_dir_, text_file_, uid_, ok_gids_));
2381 }
2382
2383 #endif  // defined(OS_POSIX)
2384
2385 }  // namespace