blob: cb778281a0c4b436ca8c2f62e4cd860e31076c0e [file] [log] [blame]
jochen@chromium.orga6879772010-02-18 19:02:26 +09001// Copyright (c) 2010 The Chromium Authors. All rights reserved.
license.botf003cfe2008-08-24 09:55:55 +09002// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit3f4a7322008-07-27 06:49:38 +09004
erikkay@google.comc8ec9e92008-08-16 02:50:10 +09005#include "build/build_config.h"
6
erikkay@google.com014161d2008-08-16 02:45:13 +09007#if defined(OS_WIN)
initial.commit3f4a7322008-07-27 06:49:38 +09008#include <windows.h>
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +09009#include <winioctl.h>
initial.commit3f4a7322008-07-27 06:49:38 +090010#include <shellapi.h>
11#include <shlobj.h>
tkent@chromium.org8da14162009-10-09 16:33:39 +090012#include <tchar.h>
erikkay@google.comdfb51b22008-08-16 02:32:10 +090013#endif
initial.commit3f4a7322008-07-27 06:49:38 +090014
15#include <fstream>
erikkay@google.comdfb51b22008-08-16 02:32:10 +090016#include <set>
initial.commit3f4a7322008-07-27 06:49:38 +090017
18#include "base/base_paths.h"
evanm@google.com874d1672008-10-31 08:54:04 +090019#include "base/file_path.h"
initial.commit3f4a7322008-07-27 06:49:38 +090020#include "base/file_util.h"
initial.commit3f4a7322008-07-27 06:49:38 +090021#include "base/path_service.h"
erikkay@google.com8d133f62009-04-24 00:05:19 +090022#include "base/platform_thread.h"
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +090023#include "base/scoped_handle.h"
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +090024#include "base/scoped_temp_dir.h"
erikkay@google.com9ac26762009-04-18 09:42:48 +090025#include "base/time.h"
brettw@chromium.org50c94652009-10-07 11:10:20 +090026#include "base/utf_string_conversions.h"
initial.commit3f4a7322008-07-27 06:49:38 +090027#include "testing/gtest/include/gtest/gtest.h"
jeremy@chromium.org0d8eba72008-12-03 04:20:15 +090028#include "testing/platform_test.h"
initial.commit3f4a7322008-07-27 06:49:38 +090029
phajdan.jr@chromium.orgf9908a72009-04-04 02:17:58 +090030// This macro helps avoid wrapped lines in the test structs.
31#define FPL(x) FILE_PATH_LITERAL(x)
32
initial.commit3f4a7322008-07-27 06:49:38 +090033namespace {
34
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +090035// To test that file_util::Normalize FilePath() deals with NTFS reparse points
36// correctly, we need functions to create and delete reparse points.
37#if defined(OS_WIN)
38typedef struct _REPARSE_DATA_BUFFER {
39 ULONG ReparseTag;
40 USHORT ReparseDataLength;
41 USHORT Reserved;
42 union {
43 struct {
44 USHORT SubstituteNameOffset;
45 USHORT SubstituteNameLength;
46 USHORT PrintNameOffset;
47 USHORT PrintNameLength;
48 ULONG Flags;
49 WCHAR PathBuffer[1];
50 } SymbolicLinkReparseBuffer;
51 struct {
52 USHORT SubstituteNameOffset;
53 USHORT SubstituteNameLength;
54 USHORT PrintNameOffset;
55 USHORT PrintNameLength;
56 WCHAR PathBuffer[1];
57 } MountPointReparseBuffer;
58 struct {
59 UCHAR DataBuffer[1];
60 } GenericReparseBuffer;
61 };
62} REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
63
64// Sets a reparse point. |source| will now point to |target|. Returns true if
65// the call succeeds, false otherwise.
66bool SetReparsePoint(HANDLE source, const FilePath& target_path) {
67 std::wstring kPathPrefix = L"\\??\\";
68 std::wstring target_str;
69 // The juction will not work if the target path does not start with \??\ .
70 if (kPathPrefix != target_path.value().substr(0, kPathPrefix.size()))
71 target_str += kPathPrefix;
72 target_str += target_path.value();
73 const wchar_t* target = target_str.c_str();
74 USHORT size_target = static_cast<USHORT>(wcslen(target)) * sizeof(target[0]);
75 char buffer[2000] = {0};
76 DWORD returned;
77
78 REPARSE_DATA_BUFFER* data = reinterpret_cast<REPARSE_DATA_BUFFER*>(buffer);
79
80 data->ReparseTag = 0xa0000003;
81 memcpy(data->MountPointReparseBuffer.PathBuffer, target, size_target + 2);
82
83 data->MountPointReparseBuffer.SubstituteNameLength = size_target;
84 data->MountPointReparseBuffer.PrintNameOffset = size_target + 2;
85 data->ReparseDataLength = size_target + 4 + 8;
86
87 int data_size = data->ReparseDataLength + 8;
88
89 if (!DeviceIoControl(source, FSCTL_SET_REPARSE_POINT, &buffer, data_size,
90 NULL, 0, &returned, NULL)) {
91 return false;
92 }
93 return true;
94}
95
96// Delete the reparse point referenced by |source|. Returns true if the call
97// succeeds, false otherwise.
98bool DeleteReparsePoint(HANDLE source) {
99 DWORD returned;
100 REPARSE_DATA_BUFFER data = {0};
101 data.ReparseTag = 0xa0000003;
102 if (!DeviceIoControl(source, FSCTL_DELETE_REPARSE_POINT, &data, 8, NULL, 0,
103 &returned, NULL)) {
104 return false;
105 }
106 return true;
107}
108#endif
109
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900110const wchar_t bogus_content[] = L"I'm cannon fodder.";
111
yuzo@chromium.org2da0f822009-06-09 14:57:38 +0900112const file_util::FileEnumerator::FILE_TYPE FILES_AND_DIRECTORIES =
113 static_cast<file_util::FileEnumerator::FILE_TYPE>(
114 file_util::FileEnumerator::FILES |
115 file_util::FileEnumerator::DIRECTORIES);
116
erikkay@google.comf2406842008-08-21 00:59:49 +0900117// file_util winds up using autoreleased objects on the Mac, so this needs
118// to be a PlatformTest
119class FileUtilTest : public PlatformTest {
initial.commit3f4a7322008-07-27 06:49:38 +0900120 protected:
121 virtual void SetUp() {
erikkay@google.comf2406842008-08-21 00:59:49 +0900122 PlatformTest::SetUp();
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900123 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
initial.commit3f4a7322008-07-27 06:49:38 +0900124 }
125
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900126 ScopedTempDir temp_dir_;
initial.commit3f4a7322008-07-27 06:49:38 +0900127};
128
129// Collects all the results from the given file enumerator, and provides an
130// interface to query whether a given file is present.
131class FindResultCollector {
132 public:
evan@chromium.org1543ad32009-08-27 05:00:14 +0900133 explicit FindResultCollector(file_util::FileEnumerator& enumerator) {
avi@google.com5cb79352008-12-11 23:55:12 +0900134 FilePath cur_file;
135 while (!(cur_file = enumerator.Next()).value().empty()) {
136 FilePath::StringType path = cur_file.value();
initial.commit3f4a7322008-07-27 06:49:38 +0900137 // The file should not be returned twice.
evanm@google.com874d1672008-10-31 08:54:04 +0900138 EXPECT_TRUE(files_.end() == files_.find(path))
initial.commit3f4a7322008-07-27 06:49:38 +0900139 << "Same file returned twice";
140
141 // Save for later.
evanm@google.com874d1672008-10-31 08:54:04 +0900142 files_.insert(path);
initial.commit3f4a7322008-07-27 06:49:38 +0900143 }
144 }
145
146 // Returns true if the enumerator found the file.
evanm@google.com874d1672008-10-31 08:54:04 +0900147 bool HasFile(const FilePath& file) const {
148 return files_.find(file.value()) != files_.end();
initial.commit3f4a7322008-07-27 06:49:38 +0900149 }
evanm@google.com874d1672008-10-31 08:54:04 +0900150
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900151 int size() {
erikkay@google.comc8ec9e92008-08-16 02:50:10 +0900152 return static_cast<int>(files_.size());
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900153 }
initial.commit3f4a7322008-07-27 06:49:38 +0900154
155 private:
evanm@google.com874d1672008-10-31 08:54:04 +0900156 std::set<FilePath::StringType> files_;
initial.commit3f4a7322008-07-27 06:49:38 +0900157};
158
159// Simple function to dump some text into a new file.
evanm@google.com874d1672008-10-31 08:54:04 +0900160void CreateTextFile(const FilePath& filename,
initial.commit3f4a7322008-07-27 06:49:38 +0900161 const std::wstring& contents) {
162 std::ofstream file;
evanm@google.com874d1672008-10-31 08:54:04 +0900163 file.open(WideToUTF8(filename.ToWStringHack()).c_str());
initial.commit3f4a7322008-07-27 06:49:38 +0900164 ASSERT_TRUE(file.is_open());
165 file << contents;
166 file.close();
167}
168
169// Simple function to take out some text from a file.
evanm@google.com874d1672008-10-31 08:54:04 +0900170std::wstring ReadTextFile(const FilePath& filename) {
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900171 wchar_t contents[64];
initial.commit3f4a7322008-07-27 06:49:38 +0900172 std::wifstream file;
evanm@google.com874d1672008-10-31 08:54:04 +0900173 file.open(WideToUTF8(filename.ToWStringHack()).c_str());
initial.commit3f4a7322008-07-27 06:49:38 +0900174 EXPECT_TRUE(file.is_open());
175 file.getline(contents, 64);
176 file.close();
177 return std::wstring(contents);
178}
179
erikkay@google.com014161d2008-08-16 02:45:13 +0900180#if defined(OS_WIN)
initial.commit3f4a7322008-07-27 06:49:38 +0900181uint64 FileTimeAsUint64(const FILETIME& ft) {
182 ULARGE_INTEGER u;
183 u.LowPart = ft.dwLowDateTime;
184 u.HighPart = ft.dwHighDateTime;
185 return u.QuadPart;
186}
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900187#endif
initial.commit3f4a7322008-07-27 06:49:38 +0900188
189const struct append_case {
190 const wchar_t* path;
191 const wchar_t* ending;
192 const wchar_t* result;
193} append_cases[] = {
erikkay@google.com014161d2008-08-16 02:45:13 +0900194#if defined(OS_WIN)
initial.commit3f4a7322008-07-27 06:49:38 +0900195 {L"c:\\colon\\backslash", L"path", L"c:\\colon\\backslash\\path"},
196 {L"c:\\colon\\backslash\\", L"path", L"c:\\colon\\backslash\\path"},
197 {L"c:\\colon\\backslash\\\\", L"path", L"c:\\colon\\backslash\\\\path"},
198 {L"c:\\colon\\backslash\\", L"", L"c:\\colon\\backslash\\"},
199 {L"c:\\colon\\backslash", L"", L"c:\\colon\\backslash\\"},
200 {L"", L"path", L"\\path"},
201 {L"", L"", L"\\"},
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900202#elif defined(OS_POSIX)
203 {L"/foo/bar", L"path", L"/foo/bar/path"},
204 {L"/foo/bar/", L"path", L"/foo/bar/path"},
205 {L"/foo/bar//", L"path", L"/foo/bar//path"},
206 {L"/foo/bar/", L"", L"/foo/bar/"},
207 {L"/foo/bar", L"", L"/foo/bar/"},
208 {L"", L"path", L"/path"},
209 {L"", L"", L"/"},
210#endif
initial.commit3f4a7322008-07-27 06:49:38 +0900211};
212
evan@chromium.org1db7f942010-02-27 00:11:55 +0900213#if defined(OS_WIN)
214// This function is deprecated, but still used on Windows.
initial.commit3f4a7322008-07-27 06:49:38 +0900215TEST_F(FileUtilTest, AppendToPath) {
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900216 for (unsigned int i = 0; i < arraysize(append_cases); ++i) {
initial.commit3f4a7322008-07-27 06:49:38 +0900217 const append_case& value = append_cases[i];
218 std::wstring result = value.path;
219 file_util::AppendToPath(&result, value.ending);
220 EXPECT_EQ(value.result, result);
221 }
222
223#ifdef NDEBUG
224 file_util::AppendToPath(NULL, L"path"); // asserts in debug mode
225#endif
226}
evan@chromium.org1db7f942010-02-27 00:11:55 +0900227#endif // defined(OS_WIN)
228
initial.commit3f4a7322008-07-27 06:49:38 +0900229static const struct filename_case {
230 const wchar_t* path;
231 const wchar_t* filename;
232} filename_cases[] = {
erikkay@google.com014161d2008-08-16 02:45:13 +0900233#if defined(OS_WIN)
initial.commit3f4a7322008-07-27 06:49:38 +0900234 {L"c:\\colon\\backslash", L"backslash"},
235 {L"c:\\colon\\backslash\\", L""},
236 {L"\\\\filename.exe", L"filename.exe"},
237 {L"filename.exe", L"filename.exe"},
238 {L"", L""},
239 {L"\\\\\\", L""},
240 {L"c:/colon/backslash", L"backslash"},
241 {L"c:/colon/backslash/", L""},
242 {L"//////", L""},
243 {L"///filename.exe", L"filename.exe"},
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900244#elif defined(OS_POSIX)
245 {L"/foo/bar", L"bar"},
246 {L"/foo/bar/", L""},
247 {L"/filename.exe", L"filename.exe"},
248 {L"filename.exe", L"filename.exe"},
249 {L"", L""},
250 {L"/", L""},
251#endif
initial.commit3f4a7322008-07-27 06:49:38 +0900252};
253
evan@chromium.org5a196702010-07-02 08:19:02 +0900254#if defined(OS_WIN)
255// This function is deprecated on non-Windows.
initial.commit3f4a7322008-07-27 06:49:38 +0900256TEST_F(FileUtilTest, GetFilenameFromPath) {
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900257 for (unsigned int i = 0; i < arraysize(filename_cases); ++i) {
initial.commit3f4a7322008-07-27 06:49:38 +0900258 const filename_case& value = filename_cases[i];
259 std::wstring result = file_util::GetFilenameFromPath(value.path);
260 EXPECT_EQ(value.filename, result);
261 }
262}
evan@chromium.org5a196702010-07-02 08:19:02 +0900263#endif
initial.commit3f4a7322008-07-27 06:49:38 +0900264
265// Test finding the file type from a path name
266static const struct extension_case {
267 const wchar_t* path;
268 const wchar_t* extension;
269} extension_cases[] = {
erikkay@google.com014161d2008-08-16 02:45:13 +0900270#if defined(OS_WIN)
initial.commit3f4a7322008-07-27 06:49:38 +0900271 {L"C:\\colon\\backslash\\filename.extension", L"extension"},
272 {L"C:\\colon\\backslash\\filename.", L""},
273 {L"C:\\colon\\backslash\\filename", L""},
274 {L"C:\\colon\\backslash\\", L""},
275 {L"C:\\colon\\backslash.\\", L""},
276 {L"C:\\colon\\backslash\filename.extension.extension2", L"extension2"},
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900277#elif defined(OS_POSIX)
278 {L"/foo/bar/filename.extension", L"extension"},
279 {L"/foo/bar/filename.", L""},
280 {L"/foo/bar/filename", L""},
281 {L"/foo/bar/", L""},
282 {L"/foo/bar./", L""},
283 {L"/foo/bar/filename.extension.extension2", L"extension2"},
284 {L".", L""},
285 {L"..", L""},
286 {L"./foo", L""},
287 {L"./foo.extension", L"extension"},
288 {L"/foo.extension1/bar.extension2", L"extension2"},
289#endif
initial.commit3f4a7322008-07-27 06:49:38 +0900290};
291
evan@chromium.org3b660ad2010-07-09 02:49:05 +0900292#if defined(OS_WIN)
293// This function has been deprecated on non-Windows.
initial.commit3f4a7322008-07-27 06:49:38 +0900294TEST_F(FileUtilTest, GetFileExtensionFromPath) {
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900295 for (unsigned int i = 0; i < arraysize(extension_cases); ++i) {
initial.commit3f4a7322008-07-27 06:49:38 +0900296 const extension_case& ext = extension_cases[i];
297 const std::wstring fext = file_util::GetFileExtensionFromPath(ext.path);
298 EXPECT_EQ(ext.extension, fext);
299 }
300}
evan@chromium.org3b660ad2010-07-09 02:49:05 +0900301#endif
initial.commit3f4a7322008-07-27 06:49:38 +0900302
303// Test finding the directory component of a path
304static const struct dir_case {
305 const wchar_t* full_path;
306 const wchar_t* directory;
307} dir_cases[] = {
erikkay@google.com014161d2008-08-16 02:45:13 +0900308#if defined(OS_WIN)
initial.commit3f4a7322008-07-27 06:49:38 +0900309 {L"C:\\WINDOWS\\system32\\gdi32.dll", L"C:\\WINDOWS\\system32"},
310 {L"C:\\WINDOWS\\system32\\not_exist_thx_1138", L"C:\\WINDOWS\\system32"},
311 {L"C:\\WINDOWS\\system32\\", L"C:\\WINDOWS\\system32"},
312 {L"C:\\WINDOWS\\system32\\\\", L"C:\\WINDOWS\\system32"},
313 {L"C:\\WINDOWS\\system32", L"C:\\WINDOWS"},
314 {L"C:\\WINDOWS\\system32.\\", L"C:\\WINDOWS\\system32."},
tkent@chromium.orgfce07c72009-10-15 14:00:25 +0900315 {L"C:\\", L"C:\\"},
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900316#elif defined(OS_POSIX)
317 {L"/foo/bar/gdi32.dll", L"/foo/bar"},
318 {L"/foo/bar/not_exist_thx_1138", L"/foo/bar"},
319 {L"/foo/bar/", L"/foo/bar"},
320 {L"/foo/bar//", L"/foo/bar"},
321 {L"/foo/bar", L"/foo"},
322 {L"/foo/bar./", L"/foo/bar."},
323 {L"/", L"/"},
324 {L".", L"."},
evan@chromium.org1543ad32009-08-27 05:00:14 +0900325 {L"..", L"."}, // yes, ".." technically lives in "."
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900326#endif
initial.commit3f4a7322008-07-27 06:49:38 +0900327};
328
evan@chromium.org9c7cbbe2010-02-23 21:52:11 +0900329#if defined(OS_WIN)
330// This function is deprecated, and only exists on Windows anymore.
initial.commit3f4a7322008-07-27 06:49:38 +0900331TEST_F(FileUtilTest, GetDirectoryFromPath) {
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900332 for (unsigned int i = 0; i < arraysize(dir_cases); ++i) {
initial.commit3f4a7322008-07-27 06:49:38 +0900333 const dir_case& dir = dir_cases[i];
334 const std::wstring parent =
335 file_util::GetDirectoryFromPath(dir.full_path);
336 EXPECT_EQ(dir.directory, parent);
337 }
338}
evan@chromium.org9c7cbbe2010-02-23 21:52:11 +0900339#endif
initial.commit3f4a7322008-07-27 06:49:38 +0900340
glider@chromium.org5fd12332010-06-10 22:05:26 +0900341// Flaky, http://crbug.com/46246
glider@chromium.orge1879a22010-06-10 21:40:52 +0900342TEST_F(FileUtilTest, FLAKY_CountFilesCreatedAfter) {
initial.commit3f4a7322008-07-27 06:49:38 +0900343 // Create old file (that we don't want to count)
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900344 FilePath old_file_name =
345 temp_dir_.path().Append(FILE_PATH_LITERAL("Old File.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +0900346 CreateTextFile(old_file_name, L"Just call me Mr. Creakybits");
347
348 // Age to perfection
evan@chromium.org37301322009-04-21 10:50:39 +0900349#if defined(OS_WIN)
erikkay@google.com8d133f62009-04-24 00:05:19 +0900350 PlatformThread::Sleep(100);
evan@chromium.org37301322009-04-21 10:50:39 +0900351#elif defined(OS_POSIX)
352 // We need to wait at least one second here because the precision of
353 // file creation time is one second.
erikkay@google.com8d133f62009-04-24 00:05:19 +0900354 PlatformThread::Sleep(1500);
evan@chromium.org37301322009-04-21 10:50:39 +0900355#endif
initial.commit3f4a7322008-07-27 06:49:38 +0900356
357 // Establish our cutoff time
erikkay@google.com9ac26762009-04-18 09:42:48 +0900358 base::Time now(base::Time::NowFromSystemTime());
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900359 EXPECT_EQ(0, file_util::CountFilesCreatedAfter(temp_dir_.path(), now));
initial.commit3f4a7322008-07-27 06:49:38 +0900360
361 // Create a new file (that we do want to count)
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900362 FilePath new_file_name =
363 temp_dir_.path().Append(FILE_PATH_LITERAL("New File.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +0900364 CreateTextFile(new_file_name, L"Waaaaaaaaaaaaaah.");
365
366 // We should see only the new file.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900367 EXPECT_EQ(1, file_util::CountFilesCreatedAfter(temp_dir_.path(), now));
initial.commit3f4a7322008-07-27 06:49:38 +0900368
369 // Delete new file, we should see no files after cutoff now
370 EXPECT_TRUE(file_util::Delete(new_file_name, false));
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900371 EXPECT_EQ(0, file_util::CountFilesCreatedAfter(temp_dir_.path(), now));
initial.commit3f4a7322008-07-27 06:49:38 +0900372}
373
cpu@chromium.org83f07be2010-03-25 06:56:26 +0900374TEST_F(FileUtilTest, FileAndDirectorySize) {
375 // Create three files of 20, 30 and 3 chars (utf8). ComputeDirectorySize
376 // should return 53 bytes.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900377 FilePath file_01 = temp_dir_.path().Append(FPL("The file 01.txt"));
cpu@chromium.org83f07be2010-03-25 06:56:26 +0900378 CreateTextFile(file_01, L"12345678901234567890");
379 int64 size_f1 = 0;
380 ASSERT_TRUE(file_util::GetFileSize(file_01, &size_f1));
381 EXPECT_EQ(20ll, size_f1);
382
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900383 FilePath subdir_path = temp_dir_.path().Append(FPL("Level2"));
cpu@chromium.org83f07be2010-03-25 06:56:26 +0900384 file_util::CreateDirectory(subdir_path);
385
386 FilePath file_02 = subdir_path.Append(FPL("The file 02.txt"));
387 CreateTextFile(file_02, L"123456789012345678901234567890");
388 int64 size_f2 = 0;
389 ASSERT_TRUE(file_util::GetFileSize(file_02, &size_f2));
390 EXPECT_EQ(30ll, size_f2);
391
392 FilePath subsubdir_path = subdir_path.Append(FPL("Level3"));
393 file_util::CreateDirectory(subsubdir_path);
394
395 FilePath file_03 = subsubdir_path.Append(FPL("The file 03.txt"));
396 CreateTextFile(file_03, L"123");
397
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900398 int64 computed_size = file_util::ComputeDirectorySize(temp_dir_.path());
cpu@chromium.org83f07be2010-03-25 06:56:26 +0900399 EXPECT_EQ(size_f1 + size_f2 + 3, computed_size);
rvargas@google.comaa24e112010-06-12 07:53:43 +0900400
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900401 computed_size =
402 file_util::ComputeFilesSize(temp_dir_.path(), FPL("The file*"));
rvargas@google.comaa24e112010-06-12 07:53:43 +0900403 EXPECT_EQ(size_f1, computed_size);
404
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900405 computed_size = file_util::ComputeFilesSize(temp_dir_.path(), FPL("bla*"));
rvargas@google.comaa24e112010-06-12 07:53:43 +0900406 EXPECT_EQ(0, computed_size);
cpu@chromium.org83f07be2010-03-25 06:56:26 +0900407}
408
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900409TEST_F(FileUtilTest, NormalizeFilePathBasic) {
410 // Create a directory under the test dir. Because we create it,
411 // we know it is not a link.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900412 FilePath file_a_path = temp_dir_.path().Append(FPL("file_a"));
413 FilePath dir_path = temp_dir_.path().Append(FPL("dir"));
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900414 FilePath file_b_path = dir_path.Append(FPL("file_b"));
415 file_util::CreateDirectory(dir_path);
skerner@chromium.org559baa92010-05-13 00:13:57 +0900416
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900417 FilePath normalized_file_a_path, normalized_file_b_path;
418 ASSERT_FALSE(file_util::PathExists(file_a_path));
419 ASSERT_FALSE(file_util::NormalizeFilePath(file_a_path,
420 &normalized_file_a_path))
viettrungluu@chromium.orgea703f12010-08-23 01:19:13 +0900421 << "NormalizeFilePath() should fail on nonexistent paths.";
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900422
423 CreateTextFile(file_a_path, bogus_content);
424 ASSERT_TRUE(file_util::PathExists(file_a_path));
425 ASSERT_TRUE(file_util::NormalizeFilePath(file_a_path,
426 &normalized_file_a_path));
427
428 CreateTextFile(file_b_path, bogus_content);
429 ASSERT_TRUE(file_util::PathExists(file_b_path));
430 ASSERT_TRUE(file_util::NormalizeFilePath(file_b_path,
431 &normalized_file_b_path));
432
433 // Beacuse this test created |dir_path|, we know it is not a link
434 // or junction. So, the real path of the directory holding file a
435 // must be the parent of the path holding file b.
436 ASSERT_TRUE(normalized_file_a_path.DirName()
437 .IsParent(normalized_file_b_path.DirName()));
438}
439
440#if defined(OS_WIN)
441
442TEST_F(FileUtilTest, NormalizeFilePathReparsePoints) {
443 // Build the following directory structure:
444 //
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900445 // temp_dir
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900446 // |-> base_a
447 // | |-> sub_a
448 // | |-> file.txt
449 // | |-> long_name___... (Very long name.)
450 // | |-> sub_long
451 // | |-> deep.txt
452 // |-> base_b
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900453 // |-> to_sub_a (reparse point to temp_dir\base_a\sub_a)
454 // |-> to_base_b (reparse point to temp_dir\base_b)
455 // |-> to_sub_long (reparse point to temp_dir\sub_a\long_name_\sub_long)
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900456
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900457 FilePath base_a = temp_dir_.path().Append(FPL("base_a"));
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900458 ASSERT_TRUE(file_util::CreateDirectory(base_a));
459
460 FilePath sub_a = base_a.Append(FPL("sub_a"));
461 ASSERT_TRUE(file_util::CreateDirectory(sub_a));
462
463 FilePath file_txt = sub_a.Append(FPL("file.txt"));
464 CreateTextFile(file_txt, bogus_content);
465
466 // Want a directory whose name is long enough to make the path to the file
467 // inside just under MAX_PATH chars. This will be used to test that when
468 // a junction expands to a path over MAX_PATH chars in length,
469 // NormalizeFilePath() fails without crashing.
470 FilePath sub_long_rel(FPL("sub_long"));
471 FilePath deep_txt(FPL("deep.txt"));
472
473 int target_length = MAX_PATH;
474 target_length -= (sub_a.value().length() + 1); // +1 for the sepperator '\'.
475 target_length -= (sub_long_rel.Append(deep_txt).value().length() + 1);
glider@chromium.orge1879a22010-06-10 21:40:52 +0900476 // Without making the path a bit shorter, CreateDirectory() fails.
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900477 // the resulting path is still long enough to hit the failing case in
478 // NormalizePath().
479 const int kCreateDirLimit = 4;
480 target_length -= kCreateDirLimit;
481 FilePath::StringType long_name_str = FPL("long_name_");
482 long_name_str.resize(target_length, '_');
483
484 FilePath long_name = sub_a.Append(FilePath(long_name_str));
485 FilePath deep_file = long_name.Append(sub_long_rel).Append(deep_txt);
486 ASSERT_EQ(MAX_PATH - kCreateDirLimit, deep_file.value().length());
487
488 FilePath sub_long = deep_file.DirName();
489 ASSERT_TRUE(file_util::CreateDirectory(sub_long));
490 CreateTextFile(deep_file, bogus_content);
491
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900492 FilePath base_b = temp_dir_.path().Append(FPL("base_b"));
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900493 ASSERT_TRUE(file_util::CreateDirectory(base_b));
494
495 FilePath to_sub_a = base_b.Append(FPL("to_sub_a"));
496 ASSERT_TRUE(file_util::CreateDirectory(to_sub_a));
497 ScopedHandle reparse_to_sub_a(
498 ::CreateFile(to_sub_a.value().c_str(),
499 FILE_ALL_ACCESS,
500 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
501 NULL,
502 OPEN_EXISTING,
503 FILE_FLAG_BACKUP_SEMANTICS, // Needed to open a directory.
504 NULL));
skerner@chromium.orgf1a62a32010-08-03 12:51:56 +0900505 ASSERT_TRUE(reparse_to_sub_a.IsValid());
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900506 ASSERT_TRUE(SetReparsePoint(reparse_to_sub_a, sub_a));
507
508 FilePath to_base_b = base_b.Append(FPL("to_base_b"));
509 ASSERT_TRUE(file_util::CreateDirectory(to_base_b));
510 ScopedHandle reparse_to_base_b(
511 ::CreateFile(to_base_b.value().c_str(),
512 FILE_ALL_ACCESS,
513 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
514 NULL,
515 OPEN_EXISTING,
516 FILE_FLAG_BACKUP_SEMANTICS, // Needed to open a directory.
517 NULL));
skerner@chromium.orgf1a62a32010-08-03 12:51:56 +0900518 ASSERT_TRUE(reparse_to_base_b.IsValid());
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900519 ASSERT_TRUE(SetReparsePoint(reparse_to_base_b, base_b));
520
521 FilePath to_sub_long = base_b.Append(FPL("to_sub_long"));
522 ASSERT_TRUE(file_util::CreateDirectory(to_sub_long));
523 ScopedHandle reparse_to_sub_long(
524 ::CreateFile(to_sub_long.value().c_str(),
525 FILE_ALL_ACCESS,
526 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
527 NULL,
528 OPEN_EXISTING,
529 FILE_FLAG_BACKUP_SEMANTICS, // Needed to open a directory.
530 NULL));
skerner@chromium.orgf1a62a32010-08-03 12:51:56 +0900531 ASSERT_TRUE(reparse_to_sub_long.IsValid());
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900532 ASSERT_TRUE(SetReparsePoint(reparse_to_sub_long, sub_long));
533
534 // Normalize a junction free path: base_a\sub_a\file.txt .
535 FilePath normalized_path;
536 ASSERT_TRUE(file_util::NormalizeFilePath(file_txt, &normalized_path));
537 ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
538
539 // Check that the path base_b\to_sub_a\file.txt can be normalized to exclude
540 // the junction to_sub_a.
541 ASSERT_TRUE(file_util::NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
542 &normalized_path));
543 ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
544
545 // Check that the path base_b\to_base_b\to_base_b\to_sub_a\file.txt can be
546 // normalized to exclude junctions to_base_b and to_sub_a .
547 ASSERT_TRUE(file_util::NormalizeFilePath(base_b.Append(FPL("to_base_b"))
548 .Append(FPL("to_base_b"))
549 .Append(FPL("to_sub_a"))
550 .Append(FPL("file.txt")),
551 &normalized_path));
552 ASSERT_STREQ(file_txt.value().c_str(), normalized_path.value().c_str());
553
554 // A long enough path will cause NormalizeFilePath() to fail. Make a long
555 // path using to_base_b many times, and check that paths long enough to fail
556 // do not cause a crash.
557 FilePath long_path = base_b;
558 const int kLengthLimit = MAX_PATH + 200;
559 while (long_path.value().length() <= kLengthLimit) {
560 long_path = long_path.Append(FPL("to_base_b"));
561 }
562 long_path = long_path.Append(FPL("to_sub_a"))
563 .Append(FPL("file.txt"));
564
565 ASSERT_FALSE(file_util::NormalizeFilePath(long_path, &normalized_path));
566
567 // Normalizing the junction to deep.txt should fail, because the expanded
568 // path to deep.txt is longer than MAX_PATH.
569 ASSERT_FALSE(file_util::NormalizeFilePath(to_sub_long.Append(deep_txt),
570 &normalized_path));
571
572 // Delete the reparse points, and see that NormalizeFilePath() fails
573 // to traverse them.
574 ASSERT_TRUE(DeleteReparsePoint(reparse_to_sub_a));
575 ASSERT_TRUE(DeleteReparsePoint(reparse_to_base_b));
576 ASSERT_TRUE(DeleteReparsePoint(reparse_to_sub_long));
577
578 ASSERT_FALSE(file_util::NormalizeFilePath(to_sub_a.Append(FPL("file.txt")),
579 &normalized_path));
580}
581
582#endif // defined(OS_WIN)
583
gspencer@chromium.org4dcc02c2010-11-30 09:43:37 +0900584#if defined(OS_POSIX)
585
586TEST_F(FileUtilTest, CreateAndReadSymlinks) {
587 FilePath link_from = temp_dir_.path().Append(FPL("from_file"));
588 FilePath link_to = temp_dir_.path().Append(FPL("to_file"));
589 CreateTextFile(link_to, bogus_content);
590
591 ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
592 << "Failed to create file symlink.";
593
594 // If we created the link properly, we should be able to read the
595 // contents through it.
596 std::wstring contents = ReadTextFile(link_from);
597 ASSERT_EQ(contents, bogus_content);
598
599 FilePath result;
600 ASSERT_TRUE(file_util::ReadSymbolicLink(link_from, &result));
601 ASSERT_EQ(link_to.value(), result.value());
602
603 // Link to a directory.
604 link_from = temp_dir_.path().Append(FPL("from_dir"));
605 link_to = temp_dir_.path().Append(FPL("to_dir"));
606 file_util::CreateDirectory(link_to);
607
608 ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
609 << "Failed to create directory symlink.";
610
611 // Test failures.
612 ASSERT_FALSE(file_util::CreateSymbolicLink(link_to, link_to));
613 ASSERT_FALSE(file_util::ReadSymbolicLink(link_to, &result));
614 FilePath missing = temp_dir_.path().Append(FPL("missing"));
615 ASSERT_FALSE(file_util::ReadSymbolicLink(missing, &result));
616}
617
618
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900619// The following test of NormalizeFilePath() require that we create a symlink.
gspencer@chromium.org4dcc02c2010-11-30 09:43:37 +0900620// This can not be done on Windows before Vista. On Vista, creating a symlink
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900621// requires privilege "SeCreateSymbolicLinkPrivilege".
622// TODO(skerner): Investigate the possibility of giving base_unittests the
623// privileges required to create a symlink.
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900624TEST_F(FileUtilTest, NormalizeFilePathSymlinks) {
625 FilePath normalized_path;
skerner@chromium.org559baa92010-05-13 00:13:57 +0900626
627 // Link one file to another.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900628 FilePath link_from = temp_dir_.path().Append(FPL("from_file"));
629 FilePath link_to = temp_dir_.path().Append(FPL("to_file"));
skerner@chromium.org559baa92010-05-13 00:13:57 +0900630 CreateTextFile(link_to, bogus_content);
631
gspencer@chromium.org4dcc02c2010-11-30 09:43:37 +0900632 ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
skerner@chromium.org559baa92010-05-13 00:13:57 +0900633 << "Failed to create file symlink.";
634
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900635 // Check that NormalizeFilePath sees the link.
636 ASSERT_TRUE(file_util::NormalizeFilePath(link_from, &normalized_path));
skerner@chromium.org559baa92010-05-13 00:13:57 +0900637 ASSERT_TRUE(link_to != link_from);
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900638 ASSERT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
639 ASSERT_EQ(link_to.BaseName().value(), normalized_path.BaseName().value());
skerner@chromium.org559baa92010-05-13 00:13:57 +0900640
641 // Link to a directory.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900642 link_from = temp_dir_.path().Append(FPL("from_dir"));
643 link_to = temp_dir_.path().Append(FPL("to_dir"));
skerner@chromium.org559baa92010-05-13 00:13:57 +0900644 file_util::CreateDirectory(link_to);
645
gspencer@chromium.org4dcc02c2010-11-30 09:43:37 +0900646 ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
skerner@chromium.org559baa92010-05-13 00:13:57 +0900647 << "Failed to create directory symlink.";
648
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900649 ASSERT_FALSE(file_util::NormalizeFilePath(link_from, &normalized_path))
650 << "Links to directories should return false.";
skerner@chromium.org559baa92010-05-13 00:13:57 +0900651
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900652 // Test that a loop in the links causes NormalizeFilePath() to return false.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900653 link_from = temp_dir_.path().Append(FPL("link_a"));
654 link_to = temp_dir_.path().Append(FPL("link_b"));
gspencer@chromium.org4dcc02c2010-11-30 09:43:37 +0900655 ASSERT_TRUE(file_util::CreateSymbolicLink(link_to, link_from))
skerner@chromium.org559baa92010-05-13 00:13:57 +0900656 << "Failed to create loop symlink a.";
gspencer@chromium.org4dcc02c2010-11-30 09:43:37 +0900657 ASSERT_TRUE(file_util::CreateSymbolicLink(link_from, link_to))
skerner@chromium.org559baa92010-05-13 00:13:57 +0900658 << "Failed to create loop symlink b.";
659
660 // Infinite loop!
skerner@chromium.org8bbe5be2010-06-10 07:56:48 +0900661 ASSERT_FALSE(file_util::NormalizeFilePath(link_from, &normalized_path));
skerner@chromium.org559baa92010-05-13 00:13:57 +0900662}
663#endif // defined(OS_POSIX)
664
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900665TEST_F(FileUtilTest, DeleteNonExistent) {
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900666 FilePath non_existent = temp_dir_.path().AppendASCII("bogus_file_dne.foobar");
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900667 ASSERT_FALSE(file_util::PathExists(non_existent));
zork@chromium.org61be4f42010-05-07 09:05:36 +0900668
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900669 EXPECT_TRUE(file_util::Delete(non_existent, false));
670 ASSERT_FALSE(file_util::PathExists(non_existent));
671 EXPECT_TRUE(file_util::Delete(non_existent, true));
672 ASSERT_FALSE(file_util::PathExists(non_existent));
673}
674
675TEST_F(FileUtilTest, DeleteFile) {
676 // Create a file
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900677 FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteFile 1.txt"));
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900678 CreateTextFile(file_name, bogus_content);
initial.commit3f4a7322008-07-27 06:49:38 +0900679 ASSERT_TRUE(file_util::PathExists(file_name));
680
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900681 // Make sure it's deleted
682 EXPECT_TRUE(file_util::Delete(file_name, false));
683 EXPECT_FALSE(file_util::PathExists(file_name));
zork@chromium.org61be4f42010-05-07 09:05:36 +0900684
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900685 // Test recursive case, create a new file
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900686 file_name = temp_dir_.path().Append(FPL("Test DeleteFile 2.txt"));
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900687 CreateTextFile(file_name, bogus_content);
688 ASSERT_TRUE(file_util::PathExists(file_name));
689
690 // Make sure it's deleted
691 EXPECT_TRUE(file_util::Delete(file_name, true));
692 EXPECT_FALSE(file_util::PathExists(file_name));
693}
694
695#if defined(OS_WIN)
696// Tests that the Delete function works for wild cards, especially
697// with the recursion flag. Also coincidentally tests PathExists.
698// TODO(erikkay): see if anyone's actually using this feature of the API
699TEST_F(FileUtilTest, DeleteWildCard) {
700 // Create a file and a directory
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900701 FilePath file_name = temp_dir_.path().Append(FPL("Test DeleteWildCard.txt"));
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900702 CreateTextFile(file_name, bogus_content);
703 ASSERT_TRUE(file_util::PathExists(file_name));
704
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900705 FilePath subdir_path = temp_dir_.path().Append(FPL("DeleteWildCardDir"));
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900706 file_util::CreateDirectory(subdir_path);
initial.commit3f4a7322008-07-27 06:49:38 +0900707 ASSERT_TRUE(file_util::PathExists(subdir_path));
708
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900709 // Create the wildcard path
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900710 FilePath directory_contents = temp_dir_.path();
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900711 directory_contents = directory_contents.Append(FPL("*"));
712
initial.commit3f4a7322008-07-27 06:49:38 +0900713 // Delete non-recursively and check that only the file is deleted
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900714 EXPECT_TRUE(file_util::Delete(directory_contents, false));
erikkay@google.comdfb51b22008-08-16 02:32:10 +0900715 EXPECT_FALSE(file_util::PathExists(file_name));
716 EXPECT_TRUE(file_util::PathExists(subdir_path));
thestig@chromium.orgafd8dd42010-05-07 06:56:40 +0900717
zork@chromium.org61be4f42010-05-07 09:05:36 +0900718 // Delete recursively and make sure all contents are deleted
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900719 EXPECT_TRUE(file_util::Delete(directory_contents, true));
thestig@chromium.orgafd8dd42010-05-07 06:56:40 +0900720 EXPECT_FALSE(file_util::PathExists(file_name));
zork@chromium.org61be4f42010-05-07 09:05:36 +0900721 EXPECT_FALSE(file_util::PathExists(subdir_path));
thestig@chromium.orgafd8dd42010-05-07 06:56:40 +0900722}
723
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900724// TODO(erikkay): see if anyone's actually using this feature of the API
725TEST_F(FileUtilTest, DeleteNonExistantWildCard) {
726 // Create a file and a directory
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900727 FilePath subdir_path =
728 temp_dir_.path().Append(FPL("DeleteNonExistantWildCard"));
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900729 file_util::CreateDirectory(subdir_path);
730 ASSERT_TRUE(file_util::PathExists(subdir_path));
731
732 // Create the wildcard path
733 FilePath directory_contents = subdir_path;
734 directory_contents = directory_contents.Append(FPL("*"));
735
736 // Delete non-recursively and check nothing got deleted
737 EXPECT_TRUE(file_util::Delete(directory_contents, false));
738 EXPECT_TRUE(file_util::PathExists(subdir_path));
739
740 // Delete recursively and check nothing got deleted
741 EXPECT_TRUE(file_util::Delete(directory_contents, true));
742 EXPECT_TRUE(file_util::PathExists(subdir_path));
743}
744#endif
745
746// Tests non-recursive Delete() for a directory.
747TEST_F(FileUtilTest, DeleteDirNonRecursive) {
748 // Create a subdirectory and put a file and two directories inside.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900749 FilePath test_subdir = temp_dir_.path().Append(FPL("DeleteDirNonRecursive"));
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900750 file_util::CreateDirectory(test_subdir);
751 ASSERT_TRUE(file_util::PathExists(test_subdir));
752
753 FilePath file_name = test_subdir.Append(FPL("Test DeleteDir.txt"));
754 CreateTextFile(file_name, bogus_content);
755 ASSERT_TRUE(file_util::PathExists(file_name));
756
757 FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
758 file_util::CreateDirectory(subdir_path1);
759 ASSERT_TRUE(file_util::PathExists(subdir_path1));
760
761 FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
762 file_util::CreateDirectory(subdir_path2);
763 ASSERT_TRUE(file_util::PathExists(subdir_path2));
764
765 // Delete non-recursively and check that the empty dir got deleted
766 EXPECT_TRUE(file_util::Delete(subdir_path2, false));
767 EXPECT_FALSE(file_util::PathExists(subdir_path2));
768
769 // Delete non-recursively and check that nothing got deleted
770 EXPECT_FALSE(file_util::Delete(test_subdir, false));
771 EXPECT_TRUE(file_util::PathExists(test_subdir));
772 EXPECT_TRUE(file_util::PathExists(file_name));
773 EXPECT_TRUE(file_util::PathExists(subdir_path1));
774}
775
776// Tests recursive Delete() for a directory.
777TEST_F(FileUtilTest, DeleteDirRecursive) {
778 // Create a subdirectory and put a file and two directories inside.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900779 FilePath test_subdir = temp_dir_.path().Append(FPL("DeleteDirRecursive"));
thestig@chromium.org1dad8c62010-05-08 03:58:45 +0900780 file_util::CreateDirectory(test_subdir);
781 ASSERT_TRUE(file_util::PathExists(test_subdir));
782
783 FilePath file_name = test_subdir.Append(FPL("Test DeleteDirRecursive.txt"));
784 CreateTextFile(file_name, bogus_content);
785 ASSERT_TRUE(file_util::PathExists(file_name));
786
787 FilePath subdir_path1 = test_subdir.Append(FPL("TestSubDir1"));
788 file_util::CreateDirectory(subdir_path1);
789 ASSERT_TRUE(file_util::PathExists(subdir_path1));
790
791 FilePath subdir_path2 = test_subdir.Append(FPL("TestSubDir2"));
792 file_util::CreateDirectory(subdir_path2);
793 ASSERT_TRUE(file_util::PathExists(subdir_path2));
794
795 // Delete recursively and check that the empty dir got deleted
796 EXPECT_TRUE(file_util::Delete(subdir_path2, true));
797 EXPECT_FALSE(file_util::PathExists(subdir_path2));
798
799 // Delete recursively and check that everything got deleted
800 EXPECT_TRUE(file_util::Delete(test_subdir, true));
801 EXPECT_FALSE(file_util::PathExists(file_name));
802 EXPECT_FALSE(file_util::PathExists(subdir_path1));
803 EXPECT_FALSE(file_util::PathExists(test_subdir));
804}
805
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +0900806TEST_F(FileUtilTest, MoveFileNew) {
807 // Create a file
808 FilePath file_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900809 temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +0900810 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
811 ASSERT_TRUE(file_util::PathExists(file_name_from));
812
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900813 // The destination.
814 FilePath file_name_to = temp_dir_.path().Append(
815 FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +0900816 ASSERT_FALSE(file_util::PathExists(file_name_to));
817
818 EXPECT_TRUE(file_util::Move(file_name_from, file_name_to));
819
820 // Check everything has been moved.
821 EXPECT_FALSE(file_util::PathExists(file_name_from));
822 EXPECT_TRUE(file_util::PathExists(file_name_to));
823}
824
825TEST_F(FileUtilTest, MoveFileExists) {
826 // Create a file
827 FilePath file_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900828 temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +0900829 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
830 ASSERT_TRUE(file_util::PathExists(file_name_from));
831
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900832 // The destination name.
833 FilePath file_name_to = temp_dir_.path().Append(
834 FILE_PATH_LITERAL("Move_Test_File_Destination.txt"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +0900835 CreateTextFile(file_name_to, L"Old file content");
836 ASSERT_TRUE(file_util::PathExists(file_name_to));
837
838 EXPECT_TRUE(file_util::Move(file_name_from, file_name_to));
839
840 // Check everything has been moved.
841 EXPECT_FALSE(file_util::PathExists(file_name_from));
842 EXPECT_TRUE(file_util::PathExists(file_name_to));
843 EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
844}
845
846TEST_F(FileUtilTest, MoveFileDirExists) {
847 // Create a file
848 FilePath file_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900849 temp_dir_.path().Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +0900850 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
851 ASSERT_TRUE(file_util::PathExists(file_name_from));
852
853 // The destination directory
854 FilePath dir_name_to =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900855 temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +0900856 file_util::CreateDirectory(dir_name_to);
857 ASSERT_TRUE(file_util::PathExists(dir_name_to));
858
859 EXPECT_FALSE(file_util::Move(file_name_from, dir_name_to));
860}
861
862
vandebo@chromium.org70cf3f12009-10-14 02:57:27 +0900863TEST_F(FileUtilTest, MoveNew) {
initial.commit3f4a7322008-07-27 06:49:38 +0900864 // Create a directory
evanm@google.com874d1672008-10-31 08:54:04 +0900865 FilePath dir_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900866 temp_dir_.path().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
evanm@google.com874d1672008-10-31 08:54:04 +0900867 file_util::CreateDirectory(dir_name_from);
initial.commit3f4a7322008-07-27 06:49:38 +0900868 ASSERT_TRUE(file_util::PathExists(dir_name_from));
869
870 // Create a file under the directory
evanm@google.com874d1672008-10-31 08:54:04 +0900871 FilePath file_name_from =
872 dir_name_from.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +0900873 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
874 ASSERT_TRUE(file_util::PathExists(file_name_from));
875
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900876 // Move the directory.
877 FilePath dir_name_to =
878 temp_dir_.path().Append(FILE_PATH_LITERAL("Move_To_Subdir"));
evanm@google.com874d1672008-10-31 08:54:04 +0900879 FilePath file_name_to =
880 dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +0900881
882 ASSERT_FALSE(file_util::PathExists(dir_name_to));
883
884 EXPECT_TRUE(file_util::Move(dir_name_from, dir_name_to));
885
886 // Check everything has been moved.
887 EXPECT_FALSE(file_util::PathExists(dir_name_from));
888 EXPECT_FALSE(file_util::PathExists(file_name_from));
889 EXPECT_TRUE(file_util::PathExists(dir_name_to));
890 EXPECT_TRUE(file_util::PathExists(file_name_to));
891}
892
vandebo@chromium.org70cf3f12009-10-14 02:57:27 +0900893TEST_F(FileUtilTest, MoveExist) {
894 // Create a directory
895 FilePath dir_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900896 temp_dir_.path().Append(FILE_PATH_LITERAL("Move_From_Subdir"));
vandebo@chromium.org70cf3f12009-10-14 02:57:27 +0900897 file_util::CreateDirectory(dir_name_from);
898 ASSERT_TRUE(file_util::PathExists(dir_name_from));
899
900 // Create a file under the directory
901 FilePath file_name_from =
902 dir_name_from.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
903 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
904 ASSERT_TRUE(file_util::PathExists(file_name_from));
905
906 // Move the directory
907 FilePath dir_name_exists =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900908 temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
vandebo@chromium.org70cf3f12009-10-14 02:57:27 +0900909
910 FilePath dir_name_to =
911 dir_name_exists.Append(FILE_PATH_LITERAL("Move_To_Subdir"));
912 FilePath file_name_to =
913 dir_name_to.Append(FILE_PATH_LITERAL("Move_Test_File.txt"));
914
915 // Create the destination directory.
916 file_util::CreateDirectory(dir_name_exists);
917 ASSERT_TRUE(file_util::PathExists(dir_name_exists));
918
919 EXPECT_TRUE(file_util::Move(dir_name_from, dir_name_to));
920
921 // Check everything has been moved.
922 EXPECT_FALSE(file_util::PathExists(dir_name_from));
923 EXPECT_FALSE(file_util::PathExists(file_name_from));
924 EXPECT_TRUE(file_util::PathExists(dir_name_to));
925 EXPECT_TRUE(file_util::PathExists(file_name_to));
926}
927
928TEST_F(FileUtilTest, CopyDirectoryRecursivelyNew) {
initial.commit3f4a7322008-07-27 06:49:38 +0900929 // Create a directory.
evanm@google.com874d1672008-10-31 08:54:04 +0900930 FilePath dir_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900931 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
evanm@google.com874d1672008-10-31 08:54:04 +0900932 file_util::CreateDirectory(dir_name_from);
initial.commit3f4a7322008-07-27 06:49:38 +0900933 ASSERT_TRUE(file_util::PathExists(dir_name_from));
934
935 // Create a file under the directory.
evanm@google.com874d1672008-10-31 08:54:04 +0900936 FilePath file_name_from =
937 dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +0900938 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
939 ASSERT_TRUE(file_util::PathExists(file_name_from));
940
941 // Create a subdirectory.
evanm@google.com874d1672008-10-31 08:54:04 +0900942 FilePath subdir_name_from =
943 dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
944 file_util::CreateDirectory(subdir_name_from);
initial.commit3f4a7322008-07-27 06:49:38 +0900945 ASSERT_TRUE(file_util::PathExists(subdir_name_from));
946
947 // Create a file under the subdirectory.
evanm@google.com874d1672008-10-31 08:54:04 +0900948 FilePath file_name2_from =
949 subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +0900950 CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
951 ASSERT_TRUE(file_util::PathExists(file_name2_from));
952
953 // Copy the directory recursively.
evanm@google.com874d1672008-10-31 08:54:04 +0900954 FilePath dir_name_to =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900955 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
evanm@google.com874d1672008-10-31 08:54:04 +0900956 FilePath file_name_to =
957 dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
958 FilePath subdir_name_to =
959 dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
960 FilePath file_name2_to =
961 subdir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +0900962
963 ASSERT_FALSE(file_util::PathExists(dir_name_to));
964
965 EXPECT_TRUE(file_util::CopyDirectory(dir_name_from, dir_name_to, true));
966
967 // Check everything has been copied.
968 EXPECT_TRUE(file_util::PathExists(dir_name_from));
969 EXPECT_TRUE(file_util::PathExists(file_name_from));
970 EXPECT_TRUE(file_util::PathExists(subdir_name_from));
971 EXPECT_TRUE(file_util::PathExists(file_name2_from));
972 EXPECT_TRUE(file_util::PathExists(dir_name_to));
973 EXPECT_TRUE(file_util::PathExists(file_name_to));
974 EXPECT_TRUE(file_util::PathExists(subdir_name_to));
975 EXPECT_TRUE(file_util::PathExists(file_name2_to));
976}
977
vandebo@chromium.org70cf3f12009-10-14 02:57:27 +0900978TEST_F(FileUtilTest, CopyDirectoryRecursivelyExists) {
979 // Create a directory.
980 FilePath dir_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +0900981 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
vandebo@chromium.org70cf3f12009-10-14 02:57:27 +0900982 file_util::CreateDirectory(dir_name_from);
983 ASSERT_TRUE(file_util::PathExists(dir_name_from));
984
985 // Create a file under the directory.
986 FilePath file_name_from =
987 dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
988 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
989 ASSERT_TRUE(file_util::PathExists(file_name_from));
990
991 // Create a subdirectory.
992 FilePath subdir_name_from =
993 dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
994 file_util::CreateDirectory(subdir_name_from);
995 ASSERT_TRUE(file_util::PathExists(subdir_name_from));
996
997 // Create a file under the subdirectory.
998 FilePath file_name2_from =
999 subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1000 CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
1001 ASSERT_TRUE(file_util::PathExists(file_name2_from));
1002
1003 // Copy the directory recursively.
1004 FilePath dir_name_exists =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001005 temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
vandebo@chromium.org70cf3f12009-10-14 02:57:27 +09001006
1007 FilePath dir_name_to =
1008 dir_name_exists.Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
1009 FilePath file_name_to =
1010 dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1011 FilePath subdir_name_to =
1012 dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
1013 FilePath file_name2_to =
1014 subdir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1015
1016 // Create the destination directory.
1017 file_util::CreateDirectory(dir_name_exists);
1018 ASSERT_TRUE(file_util::PathExists(dir_name_exists));
1019
1020 EXPECT_TRUE(file_util::CopyDirectory(dir_name_from, dir_name_exists, true));
1021
1022 // Check everything has been copied.
1023 EXPECT_TRUE(file_util::PathExists(dir_name_from));
1024 EXPECT_TRUE(file_util::PathExists(file_name_from));
1025 EXPECT_TRUE(file_util::PathExists(subdir_name_from));
1026 EXPECT_TRUE(file_util::PathExists(file_name2_from));
1027 EXPECT_TRUE(file_util::PathExists(dir_name_to));
1028 EXPECT_TRUE(file_util::PathExists(file_name_to));
1029 EXPECT_TRUE(file_util::PathExists(subdir_name_to));
1030 EXPECT_TRUE(file_util::PathExists(file_name2_to));
1031}
1032
1033TEST_F(FileUtilTest, CopyDirectoryNew) {
initial.commit3f4a7322008-07-27 06:49:38 +09001034 // Create a directory.
evanm@google.com874d1672008-10-31 08:54:04 +09001035 FilePath dir_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001036 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
evanm@google.com874d1672008-10-31 08:54:04 +09001037 file_util::CreateDirectory(dir_name_from);
initial.commit3f4a7322008-07-27 06:49:38 +09001038 ASSERT_TRUE(file_util::PathExists(dir_name_from));
1039
1040 // Create a file under the directory.
evanm@google.com874d1672008-10-31 08:54:04 +09001041 FilePath file_name_from =
1042 dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +09001043 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1044 ASSERT_TRUE(file_util::PathExists(file_name_from));
1045
1046 // Create a subdirectory.
evanm@google.com874d1672008-10-31 08:54:04 +09001047 FilePath subdir_name_from =
1048 dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
1049 file_util::CreateDirectory(subdir_name_from);
initial.commit3f4a7322008-07-27 06:49:38 +09001050 ASSERT_TRUE(file_util::PathExists(subdir_name_from));
1051
1052 // Create a file under the subdirectory.
evanm@google.com874d1672008-10-31 08:54:04 +09001053 FilePath file_name2_from =
1054 subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +09001055 CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
1056 ASSERT_TRUE(file_util::PathExists(file_name2_from));
1057
1058 // Copy the directory not recursively.
evanm@google.com874d1672008-10-31 08:54:04 +09001059 FilePath dir_name_to =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001060 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
evanm@google.com874d1672008-10-31 08:54:04 +09001061 FilePath file_name_to =
1062 dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1063 FilePath subdir_name_to =
1064 dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
initial.commit3f4a7322008-07-27 06:49:38 +09001065
1066 ASSERT_FALSE(file_util::PathExists(dir_name_to));
1067
1068 EXPECT_TRUE(file_util::CopyDirectory(dir_name_from, dir_name_to, false));
1069
1070 // Check everything has been copied.
1071 EXPECT_TRUE(file_util::PathExists(dir_name_from));
1072 EXPECT_TRUE(file_util::PathExists(file_name_from));
1073 EXPECT_TRUE(file_util::PathExists(subdir_name_from));
1074 EXPECT_TRUE(file_util::PathExists(file_name2_from));
1075 EXPECT_TRUE(file_util::PathExists(dir_name_to));
1076 EXPECT_TRUE(file_util::PathExists(file_name_to));
1077 EXPECT_FALSE(file_util::PathExists(subdir_name_to));
1078}
1079
vandebo@chromium.org70cf3f12009-10-14 02:57:27 +09001080TEST_F(FileUtilTest, CopyDirectoryExists) {
1081 // Create a directory.
1082 FilePath dir_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001083 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
vandebo@chromium.org70cf3f12009-10-14 02:57:27 +09001084 file_util::CreateDirectory(dir_name_from);
1085 ASSERT_TRUE(file_util::PathExists(dir_name_from));
1086
1087 // Create a file under the directory.
1088 FilePath file_name_from =
1089 dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1090 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1091 ASSERT_TRUE(file_util::PathExists(file_name_from));
1092
1093 // Create a subdirectory.
1094 FilePath subdir_name_from =
1095 dir_name_from.Append(FILE_PATH_LITERAL("Subdir"));
1096 file_util::CreateDirectory(subdir_name_from);
1097 ASSERT_TRUE(file_util::PathExists(subdir_name_from));
1098
1099 // Create a file under the subdirectory.
1100 FilePath file_name2_from =
1101 subdir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1102 CreateTextFile(file_name2_from, L"Gooooooooooooooooooooogle");
1103 ASSERT_TRUE(file_util::PathExists(file_name2_from));
1104
1105 // Copy the directory not recursively.
1106 FilePath dir_name_to =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001107 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_To_Subdir"));
vandebo@chromium.org70cf3f12009-10-14 02:57:27 +09001108 FilePath file_name_to =
1109 dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1110 FilePath subdir_name_to =
1111 dir_name_to.Append(FILE_PATH_LITERAL("Subdir"));
1112
1113 // Create the destination directory.
1114 file_util::CreateDirectory(dir_name_to);
1115 ASSERT_TRUE(file_util::PathExists(dir_name_to));
1116
1117 EXPECT_TRUE(file_util::CopyDirectory(dir_name_from, dir_name_to, false));
1118
1119 // Check everything has been copied.
1120 EXPECT_TRUE(file_util::PathExists(dir_name_from));
1121 EXPECT_TRUE(file_util::PathExists(file_name_from));
1122 EXPECT_TRUE(file_util::PathExists(subdir_name_from));
1123 EXPECT_TRUE(file_util::PathExists(file_name2_from));
1124 EXPECT_TRUE(file_util::PathExists(dir_name_to));
1125 EXPECT_TRUE(file_util::PathExists(file_name_to));
1126 EXPECT_FALSE(file_util::PathExists(subdir_name_to));
1127}
1128
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +09001129TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToNew) {
1130 // Create a file
1131 FilePath file_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001132 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +09001133 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1134 ASSERT_TRUE(file_util::PathExists(file_name_from));
1135
1136 // The destination name
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001137 FilePath file_name_to = temp_dir_.path().Append(
1138 FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +09001139 ASSERT_FALSE(file_util::PathExists(file_name_to));
1140
1141 EXPECT_TRUE(file_util::CopyDirectory(file_name_from, file_name_to, true));
1142
1143 // Check the has been copied
1144 EXPECT_TRUE(file_util::PathExists(file_name_to));
1145}
1146
1147TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExisting) {
1148 // Create a file
1149 FilePath file_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001150 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +09001151 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1152 ASSERT_TRUE(file_util::PathExists(file_name_from));
1153
1154 // The destination name
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001155 FilePath file_name_to = temp_dir_.path().Append(
1156 FILE_PATH_LITERAL("Copy_Test_File_Destination.txt"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +09001157 CreateTextFile(file_name_to, L"Old file content");
1158 ASSERT_TRUE(file_util::PathExists(file_name_to));
1159
1160 EXPECT_TRUE(file_util::CopyDirectory(file_name_from, file_name_to, true));
1161
1162 // Check the has been copied
1163 EXPECT_TRUE(file_util::PathExists(file_name_to));
1164 EXPECT_TRUE(L"Gooooooooooooooooooooogle" == ReadTextFile(file_name_to));
1165}
1166
1167TEST_F(FileUtilTest, CopyFileWithCopyDirectoryRecursiveToExistingDirectory) {
1168 // Create a file
1169 FilePath file_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001170 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +09001171 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1172 ASSERT_TRUE(file_util::PathExists(file_name_from));
1173
1174 // The destination
1175 FilePath dir_name_to =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001176 temp_dir_.path().Append(FILE_PATH_LITERAL("Destination"));
vandebo@chromium.orgc0cf77e2009-10-15 10:11:44 +09001177 file_util::CreateDirectory(dir_name_to);
1178 ASSERT_TRUE(file_util::PathExists(dir_name_to));
1179 FilePath file_name_to =
1180 dir_name_to.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
1181
1182 EXPECT_TRUE(file_util::CopyDirectory(file_name_from, dir_name_to, true));
1183
1184 // Check the has been copied
1185 EXPECT_TRUE(file_util::PathExists(file_name_to));
1186}
1187
initial.commit3f4a7322008-07-27 06:49:38 +09001188TEST_F(FileUtilTest, CopyFile) {
1189 // Create a directory
evanm@google.com874d1672008-10-31 08:54:04 +09001190 FilePath dir_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001191 temp_dir_.path().Append(FILE_PATH_LITERAL("Copy_From_Subdir"));
evanm@google.com874d1672008-10-31 08:54:04 +09001192 file_util::CreateDirectory(dir_name_from);
initial.commit3f4a7322008-07-27 06:49:38 +09001193 ASSERT_TRUE(file_util::PathExists(dir_name_from));
1194
1195 // Create a file under the directory
evanm@google.com874d1672008-10-31 08:54:04 +09001196 FilePath file_name_from =
1197 dir_name_from.Append(FILE_PATH_LITERAL("Copy_Test_File.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +09001198 const std::wstring file_contents(L"Gooooooooooooooooooooogle");
1199 CreateTextFile(file_name_from, file_contents);
1200 ASSERT_TRUE(file_util::PathExists(file_name_from));
1201
1202 // Copy the file.
evanm@google.com874d1672008-10-31 08:54:04 +09001203 FilePath dest_file = dir_name_from.Append(FILE_PATH_LITERAL("DestFile.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +09001204 ASSERT_TRUE(file_util::CopyFile(file_name_from, dest_file));
mmoss@google.com733df6b2008-09-12 01:09:11 +09001205
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001206 // Copy the file to another location using '..' in the path.
evan@chromium.org1543ad32009-08-27 05:00:14 +09001207 FilePath dest_file2(dir_name_from);
1208 dest_file2 = dest_file2.AppendASCII("..");
1209 dest_file2 = dest_file2.AppendASCII("DestFile.txt");
1210 ASSERT_TRUE(file_util::CopyFile(file_name_from, dest_file2));
1211
1212 FilePath dest_file2_test(dir_name_from);
1213 dest_file2_test = dest_file2_test.DirName();
1214 dest_file2_test = dest_file2_test.AppendASCII("DestFile.txt");
initial.commit3f4a7322008-07-27 06:49:38 +09001215
1216 // Check everything has been copied.
1217 EXPECT_TRUE(file_util::PathExists(file_name_from));
1218 EXPECT_TRUE(file_util::PathExists(dest_file));
1219 const std::wstring read_contents = ReadTextFile(dest_file);
1220 EXPECT_EQ(file_contents, read_contents);
evan@chromium.org1543ad32009-08-27 05:00:14 +09001221 EXPECT_TRUE(file_util::PathExists(dest_file2_test));
1222 EXPECT_TRUE(file_util::PathExists(dest_file2));
initial.commit3f4a7322008-07-27 06:49:38 +09001223}
1224
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001225// TODO(erikkay): implement
erikkay@google.com014161d2008-08-16 02:45:13 +09001226#if defined(OS_WIN)
initial.commit3f4a7322008-07-27 06:49:38 +09001227TEST_F(FileUtilTest, GetFileCreationLocalTime) {
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001228 FilePath file_name = temp_dir_.path().Append(L"Test File.txt");
initial.commit3f4a7322008-07-27 06:49:38 +09001229
1230 SYSTEMTIME start_time;
1231 GetLocalTime(&start_time);
1232 Sleep(100);
1233 CreateTextFile(file_name, L"New file!");
1234 Sleep(100);
1235 SYSTEMTIME end_time;
1236 GetLocalTime(&end_time);
1237
1238 SYSTEMTIME file_creation_time;
evanm@google.com874d1672008-10-31 08:54:04 +09001239 file_util::GetFileCreationLocalTime(file_name.value(), &file_creation_time);
initial.commit3f4a7322008-07-27 06:49:38 +09001240
1241 FILETIME start_filetime;
1242 SystemTimeToFileTime(&start_time, &start_filetime);
1243 FILETIME end_filetime;
1244 SystemTimeToFileTime(&end_time, &end_filetime);
1245 FILETIME file_creation_filetime;
1246 SystemTimeToFileTime(&file_creation_time, &file_creation_filetime);
1247
1248 EXPECT_EQ(-1, CompareFileTime(&start_filetime, &file_creation_filetime)) <<
1249 "start time: " << FileTimeAsUint64(start_filetime) << ", " <<
1250 "creation time: " << FileTimeAsUint64(file_creation_filetime);
1251
1252 EXPECT_EQ(-1, CompareFileTime(&file_creation_filetime, &end_filetime)) <<
1253 "creation time: " << FileTimeAsUint64(file_creation_filetime) << ", " <<
1254 "end time: " << FileTimeAsUint64(end_filetime);
1255
evanm@google.com874d1672008-10-31 08:54:04 +09001256 ASSERT_TRUE(DeleteFile(file_name.value().c_str()));
initial.commit3f4a7322008-07-27 06:49:38 +09001257}
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001258#endif
initial.commit3f4a7322008-07-27 06:49:38 +09001259
erikkay@google.comf2406842008-08-21 00:59:49 +09001260// file_util winds up using autoreleased objects on the Mac, so this needs
evanm@google.com874d1672008-10-31 08:54:04 +09001261// to be a PlatformTest.
erikkay@google.comf2406842008-08-21 00:59:49 +09001262typedef PlatformTest ReadOnlyFileUtilTest;
initial.commit3f4a7322008-07-27 06:49:38 +09001263
erikkay@google.comf2406842008-08-21 00:59:49 +09001264TEST_F(ReadOnlyFileUtilTest, ContentsEqual) {
evanm@google.com874d1672008-10-31 08:54:04 +09001265 FilePath data_dir;
initial.commit3f4a7322008-07-27 06:49:38 +09001266 ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &data_dir));
evanm@google.com874d1672008-10-31 08:54:04 +09001267 data_dir = data_dir.Append(FILE_PATH_LITERAL("base"))
1268 .Append(FILE_PATH_LITERAL("data"))
1269 .Append(FILE_PATH_LITERAL("file_util_unittest"));
initial.commit3f4a7322008-07-27 06:49:38 +09001270 ASSERT_TRUE(file_util::PathExists(data_dir));
1271
evanm@google.com874d1672008-10-31 08:54:04 +09001272 FilePath original_file =
1273 data_dir.Append(FILE_PATH_LITERAL("original.txt"));
1274 FilePath same_file =
1275 data_dir.Append(FILE_PATH_LITERAL("same.txt"));
1276 FilePath same_length_file =
1277 data_dir.Append(FILE_PATH_LITERAL("same_length.txt"));
1278 FilePath different_file =
1279 data_dir.Append(FILE_PATH_LITERAL("different.txt"));
1280 FilePath different_first_file =
1281 data_dir.Append(FILE_PATH_LITERAL("different_first.txt"));
1282 FilePath different_last_file =
1283 data_dir.Append(FILE_PATH_LITERAL("different_last.txt"));
1284 FilePath empty1_file =
1285 data_dir.Append(FILE_PATH_LITERAL("empty1.txt"));
1286 FilePath empty2_file =
1287 data_dir.Append(FILE_PATH_LITERAL("empty2.txt"));
1288 FilePath shortened_file =
1289 data_dir.Append(FILE_PATH_LITERAL("shortened.txt"));
1290 FilePath binary_file =
1291 data_dir.Append(FILE_PATH_LITERAL("binary_file.bin"));
1292 FilePath binary_file_same =
1293 data_dir.Append(FILE_PATH_LITERAL("binary_file_same.bin"));
1294 FilePath binary_file_diff =
1295 data_dir.Append(FILE_PATH_LITERAL("binary_file_diff.bin"));
initial.commit3f4a7322008-07-27 06:49:38 +09001296
1297 EXPECT_TRUE(file_util::ContentsEqual(original_file, original_file));
1298 EXPECT_TRUE(file_util::ContentsEqual(original_file, same_file));
1299 EXPECT_FALSE(file_util::ContentsEqual(original_file, same_length_file));
1300 EXPECT_FALSE(file_util::ContentsEqual(original_file, different_file));
thakis@chromium.org506f0912009-12-02 07:14:22 +09001301 EXPECT_FALSE(file_util::ContentsEqual(
1302 FilePath(FILE_PATH_LITERAL("bogusname")),
1303 FilePath(FILE_PATH_LITERAL("bogusname"))));
initial.commit3f4a7322008-07-27 06:49:38 +09001304 EXPECT_FALSE(file_util::ContentsEqual(original_file, different_first_file));
1305 EXPECT_FALSE(file_util::ContentsEqual(original_file, different_last_file));
1306 EXPECT_TRUE(file_util::ContentsEqual(empty1_file, empty2_file));
1307 EXPECT_FALSE(file_util::ContentsEqual(original_file, shortened_file));
1308 EXPECT_FALSE(file_util::ContentsEqual(shortened_file, original_file));
1309 EXPECT_TRUE(file_util::ContentsEqual(binary_file, binary_file_same));
1310 EXPECT_FALSE(file_util::ContentsEqual(binary_file, binary_file_diff));
1311}
1312
mark@chromium.org95c9ec92009-06-27 06:17:24 +09001313TEST_F(ReadOnlyFileUtilTest, TextContentsEqual) {
1314 FilePath data_dir;
1315 ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &data_dir));
1316 data_dir = data_dir.Append(FILE_PATH_LITERAL("base"))
1317 .Append(FILE_PATH_LITERAL("data"))
1318 .Append(FILE_PATH_LITERAL("file_util_unittest"));
1319 ASSERT_TRUE(file_util::PathExists(data_dir));
1320
1321 FilePath original_file =
1322 data_dir.Append(FILE_PATH_LITERAL("original.txt"));
1323 FilePath same_file =
1324 data_dir.Append(FILE_PATH_LITERAL("same.txt"));
1325 FilePath crlf_file =
1326 data_dir.Append(FILE_PATH_LITERAL("crlf.txt"));
1327 FilePath shortened_file =
1328 data_dir.Append(FILE_PATH_LITERAL("shortened.txt"));
1329 FilePath different_file =
1330 data_dir.Append(FILE_PATH_LITERAL("different.txt"));
1331 FilePath different_first_file =
1332 data_dir.Append(FILE_PATH_LITERAL("different_first.txt"));
1333 FilePath different_last_file =
1334 data_dir.Append(FILE_PATH_LITERAL("different_last.txt"));
1335 FilePath first1_file =
1336 data_dir.Append(FILE_PATH_LITERAL("first1.txt"));
1337 FilePath first2_file =
1338 data_dir.Append(FILE_PATH_LITERAL("first2.txt"));
1339 FilePath empty1_file =
1340 data_dir.Append(FILE_PATH_LITERAL("empty1.txt"));
1341 FilePath empty2_file =
1342 data_dir.Append(FILE_PATH_LITERAL("empty2.txt"));
1343 FilePath blank_line_file =
1344 data_dir.Append(FILE_PATH_LITERAL("blank_line.txt"));
1345 FilePath blank_line_crlf_file =
1346 data_dir.Append(FILE_PATH_LITERAL("blank_line_crlf.txt"));
1347
1348 EXPECT_TRUE(file_util::TextContentsEqual(original_file, same_file));
1349 EXPECT_TRUE(file_util::TextContentsEqual(original_file, crlf_file));
1350 EXPECT_FALSE(file_util::TextContentsEqual(original_file, shortened_file));
1351 EXPECT_FALSE(file_util::TextContentsEqual(original_file, different_file));
1352 EXPECT_FALSE(file_util::TextContentsEqual(original_file,
1353 different_first_file));
1354 EXPECT_FALSE(file_util::TextContentsEqual(original_file,
1355 different_last_file));
1356 EXPECT_FALSE(file_util::TextContentsEqual(first1_file, first2_file));
1357 EXPECT_TRUE(file_util::TextContentsEqual(empty1_file, empty2_file));
1358 EXPECT_FALSE(file_util::TextContentsEqual(original_file, empty1_file));
1359 EXPECT_TRUE(file_util::TextContentsEqual(blank_line_file,
1360 blank_line_crlf_file));
1361}
1362
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001363// We don't need equivalent functionality outside of Windows.
erikkay@google.com014161d2008-08-16 02:45:13 +09001364#if defined(OS_WIN)
initial.commit3f4a7322008-07-27 06:49:38 +09001365TEST_F(FileUtilTest, ResolveShortcutTest) {
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001366 FilePath target_file = temp_dir_.path().Append(L"Target.txt");
initial.commit3f4a7322008-07-27 06:49:38 +09001367 CreateTextFile(target_file, L"This is the target.");
1368
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001369 FilePath link_file = temp_dir_.path().Append(L"Link.lnk");
initial.commit3f4a7322008-07-27 06:49:38 +09001370
1371 HRESULT result;
1372 IShellLink *shell = NULL;
1373 IPersistFile *persist = NULL;
1374
1375 CoInitialize(NULL);
1376 // Temporarily create a shortcut for test
1377 result = CoCreateInstance(CLSID_ShellLink, NULL,
1378 CLSCTX_INPROC_SERVER, IID_IShellLink,
1379 reinterpret_cast<LPVOID*>(&shell));
1380 EXPECT_TRUE(SUCCEEDED(result));
1381 result = shell->QueryInterface(IID_IPersistFile,
1382 reinterpret_cast<LPVOID*>(&persist));
1383 EXPECT_TRUE(SUCCEEDED(result));
evanm@google.com874d1672008-10-31 08:54:04 +09001384 result = shell->SetPath(target_file.value().c_str());
initial.commit3f4a7322008-07-27 06:49:38 +09001385 EXPECT_TRUE(SUCCEEDED(result));
1386 result = shell->SetDescription(L"ResolveShortcutTest");
1387 EXPECT_TRUE(SUCCEEDED(result));
evanm@google.com874d1672008-10-31 08:54:04 +09001388 result = persist->Save(link_file.value().c_str(), TRUE);
initial.commit3f4a7322008-07-27 06:49:38 +09001389 EXPECT_TRUE(SUCCEEDED(result));
1390 if (persist)
1391 persist->Release();
1392 if (shell)
1393 shell->Release();
1394
1395 bool is_solved;
evan@chromium.orga4899042009-08-25 10:51:44 +09001396 is_solved = file_util::ResolveShortcut(&link_file);
initial.commit3f4a7322008-07-27 06:49:38 +09001397 EXPECT_TRUE(is_solved);
1398 std::wstring contents;
evan@chromium.orga4899042009-08-25 10:51:44 +09001399 contents = ReadTextFile(link_file);
initial.commit3f4a7322008-07-27 06:49:38 +09001400 EXPECT_EQ(L"This is the target.", contents);
1401
ericroman@google.comdbff4f52008-08-19 01:00:38 +09001402 // Cleaning
evanm@google.com874d1672008-10-31 08:54:04 +09001403 DeleteFile(target_file.value().c_str());
evan@chromium.orga4899042009-08-25 10:51:44 +09001404 DeleteFile(link_file.value().c_str());
initial.commit3f4a7322008-07-27 06:49:38 +09001405 CoUninitialize();
1406}
1407
1408TEST_F(FileUtilTest, CreateShortcutTest) {
1409 const wchar_t file_contents[] = L"This is another target.";
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001410 FilePath target_file = temp_dir_.path().Append(L"Target1.txt");
initial.commit3f4a7322008-07-27 06:49:38 +09001411 CreateTextFile(target_file, file_contents);
1412
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001413 FilePath link_file = temp_dir_.path().Append(L"Link1.lnk");
initial.commit3f4a7322008-07-27 06:49:38 +09001414
1415 CoInitialize(NULL);
evanm@google.com874d1672008-10-31 08:54:04 +09001416 EXPECT_TRUE(file_util::CreateShortcutLink(target_file.value().c_str(),
1417 link_file.value().c_str(),
xiyuan@chromium.orgd9e9bb42009-11-19 18:18:50 +09001418 NULL, NULL, NULL, NULL, 0, NULL));
evan@chromium.orga4899042009-08-25 10:51:44 +09001419 FilePath resolved_name = link_file;
initial.commit3f4a7322008-07-27 06:49:38 +09001420 EXPECT_TRUE(file_util::ResolveShortcut(&resolved_name));
evan@chromium.orga4899042009-08-25 10:51:44 +09001421 std::wstring read_contents = ReadTextFile(resolved_name);
initial.commit3f4a7322008-07-27 06:49:38 +09001422 EXPECT_EQ(file_contents, read_contents);
1423
evanm@google.com874d1672008-10-31 08:54:04 +09001424 DeleteFile(target_file.value().c_str());
1425 DeleteFile(link_file.value().c_str());
initial.commit3f4a7322008-07-27 06:49:38 +09001426 CoUninitialize();
1427}
huanr@chromium.org7f2c6af2009-03-12 03:37:48 +09001428
1429TEST_F(FileUtilTest, CopyAndDeleteDirectoryTest) {
1430 // Create a directory
1431 FilePath dir_name_from =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001432 temp_dir_.path().Append(FILE_PATH_LITERAL("CopyAndDelete_From_Subdir"));
huanr@chromium.org7f2c6af2009-03-12 03:37:48 +09001433 file_util::CreateDirectory(dir_name_from);
1434 ASSERT_TRUE(file_util::PathExists(dir_name_from));
1435
1436 // Create a file under the directory
1437 FilePath file_name_from =
1438 dir_name_from.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
1439 CreateTextFile(file_name_from, L"Gooooooooooooooooooooogle");
1440 ASSERT_TRUE(file_util::PathExists(file_name_from));
1441
1442 // Move the directory by using CopyAndDeleteDirectory
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001443 FilePath dir_name_to = temp_dir_.path().Append(
huanr@chromium.org7f2c6af2009-03-12 03:37:48 +09001444 FILE_PATH_LITERAL("CopyAndDelete_To_Subdir"));
1445 FilePath file_name_to =
1446 dir_name_to.Append(FILE_PATH_LITERAL("CopyAndDelete_Test_File.txt"));
1447
1448 ASSERT_FALSE(file_util::PathExists(dir_name_to));
1449
1450 EXPECT_TRUE(file_util::CopyAndDeleteDirectory(dir_name_from, dir_name_to));
1451
1452 // Check everything has been moved.
1453 EXPECT_FALSE(file_util::PathExists(dir_name_from));
1454 EXPECT_FALSE(file_util::PathExists(file_name_from));
1455 EXPECT_TRUE(file_util::PathExists(dir_name_to));
1456 EXPECT_TRUE(file_util::PathExists(file_name_to));
1457}
tkent@chromium.org8da14162009-10-09 16:33:39 +09001458
1459TEST_F(FileUtilTest, GetTempDirTest) {
1460 static const TCHAR* kTmpKey = _T("TMP");
1461 static const TCHAR* kTmpValues[] = {
1462 _T(""), _T("C:"), _T("C:\\"), _T("C:\\tmp"), _T("C:\\tmp\\")
1463 };
1464 // Save the original $TMP.
1465 size_t original_tmp_size;
1466 TCHAR* original_tmp;
1467 ASSERT_EQ(0, ::_tdupenv_s(&original_tmp, &original_tmp_size, kTmpKey));
1468 // original_tmp may be NULL.
1469
1470 for (unsigned int i = 0; i < arraysize(kTmpValues); ++i) {
1471 FilePath path;
1472 ::_tputenv_s(kTmpKey, kTmpValues[i]);
1473 file_util::GetTempDir(&path);
1474 EXPECT_TRUE(path.IsAbsolute()) << "$TMP=" << kTmpValues[i] <<
1475 " result=" << path.value();
1476 }
1477
1478 // Restore the original $TMP.
1479 if (original_tmp) {
1480 ::_tputenv_s(kTmpKey, original_tmp);
1481 free(original_tmp);
1482 } else {
1483 ::_tputenv_s(kTmpKey, _T(""));
1484 }
1485}
1486#endif // OS_WIN
initial.commit3f4a7322008-07-27 06:49:38 +09001487
erikkay@chromium.org18f0dde2009-08-19 01:07:55 +09001488TEST_F(FileUtilTest, CreateTemporaryFileTest) {
1489 FilePath temp_files[3];
jrg@chromium.orgd505c3a2009-02-04 09:58:39 +09001490 for (int i = 0; i < 3; i++) {
erikkay@chromium.org18f0dde2009-08-19 01:07:55 +09001491 ASSERT_TRUE(file_util::CreateTemporaryFile(&(temp_files[i])));
jrg@chromium.orgd505c3a2009-02-04 09:58:39 +09001492 EXPECT_TRUE(file_util::PathExists(temp_files[i]));
1493 EXPECT_FALSE(file_util::DirectoryExists(temp_files[i]));
1494 }
1495 for (int i = 0; i < 3; i++)
1496 EXPECT_FALSE(temp_files[i] == temp_files[(i+1)%3]);
1497 for (int i = 0; i < 3; i++)
1498 EXPECT_TRUE(file_util::Delete(temp_files[i], false));
1499}
1500
erikkay@chromium.org18f0dde2009-08-19 01:07:55 +09001501TEST_F(FileUtilTest, CreateAndOpenTemporaryFileTest) {
jrg@chromium.orgd505c3a2009-02-04 09:58:39 +09001502 FilePath names[3];
1503 FILE *fps[3];
1504 int i;
1505
1506 // Create; make sure they are open and exist.
1507 for (i = 0; i < 3; ++i) {
1508 fps[i] = file_util::CreateAndOpenTemporaryFile(&(names[i]));
1509 ASSERT_TRUE(fps[i]);
1510 EXPECT_TRUE(file_util::PathExists(names[i]));
1511 }
1512
1513 // Make sure all names are unique.
1514 for (i = 0; i < 3; ++i) {
1515 EXPECT_FALSE(names[i] == names[(i+1)%3]);
1516 }
1517
1518 // Close and delete.
1519 for (i = 0; i < 3; ++i) {
1520 EXPECT_TRUE(file_util::CloseFile(fps[i]));
1521 EXPECT_TRUE(file_util::Delete(names[i], false));
1522 }
initial.commit3f4a7322008-07-27 06:49:38 +09001523}
1524
1525TEST_F(FileUtilTest, CreateNewTempDirectoryTest) {
evan@chromium.org1543ad32009-08-27 05:00:14 +09001526 FilePath temp_dir;
1527 ASSERT_TRUE(file_util::CreateNewTempDirectory(FilePath::StringType(),
1528 &temp_dir));
mmoss@google.com733df6b2008-09-12 01:09:11 +09001529 EXPECT_TRUE(file_util::PathExists(temp_dir));
1530 EXPECT_TRUE(file_util::Delete(temp_dir, false));
initial.commit3f4a7322008-07-27 06:49:38 +09001531}
1532
skerner@chromium.orge4432392010-05-01 02:00:09 +09001533TEST_F(FileUtilTest, CreateNewTemporaryDirInDirTest) {
1534 FilePath new_dir;
1535 ASSERT_TRUE(file_util::CreateTemporaryDirInDir(
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001536 temp_dir_.path(),
skerner@chromium.orge4432392010-05-01 02:00:09 +09001537 FILE_PATH_LITERAL("CreateNewTemporaryDirInDirTest"),
skerner@chromium.orgbd112ab2010-06-30 16:19:11 +09001538 &new_dir));
skerner@chromium.orge4432392010-05-01 02:00:09 +09001539 EXPECT_TRUE(file_util::PathExists(new_dir));
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001540 EXPECT_TRUE(temp_dir_.path().IsParent(new_dir));
skerner@chromium.orge4432392010-05-01 02:00:09 +09001541 EXPECT_TRUE(file_util::Delete(new_dir, false));
1542}
1543
jrg@chromium.orgd505c3a2009-02-04 09:58:39 +09001544TEST_F(FileUtilTest, GetShmemTempDirTest) {
1545 FilePath dir;
1546 EXPECT_TRUE(file_util::GetShmemTempDir(&dir));
1547 EXPECT_TRUE(file_util::DirectoryExists(dir));
1548}
1549
initial.commit3f4a7322008-07-27 06:49:38 +09001550TEST_F(FileUtilTest, CreateDirectoryTest) {
evanm@google.com874d1672008-10-31 08:54:04 +09001551 FilePath test_root =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001552 temp_dir_.path().Append(FILE_PATH_LITERAL("create_directory_test"));
erikkay@google.com014161d2008-08-16 02:45:13 +09001553#if defined(OS_WIN)
evanm@google.com874d1672008-10-31 08:54:04 +09001554 FilePath test_path =
1555 test_root.Append(FILE_PATH_LITERAL("dir\\tree\\likely\\doesnt\\exist\\"));
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001556#elif defined(OS_POSIX)
evanm@google.com874d1672008-10-31 08:54:04 +09001557 FilePath test_path =
1558 test_root.Append(FILE_PATH_LITERAL("dir/tree/likely/doesnt/exist/"));
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001559#endif
mmoss@google.com733df6b2008-09-12 01:09:11 +09001560
1561 EXPECT_FALSE(file_util::PathExists(test_path));
1562 EXPECT_TRUE(file_util::CreateDirectory(test_path));
1563 EXPECT_TRUE(file_util::PathExists(test_path));
1564 // CreateDirectory returns true if the DirectoryExists returns true.
1565 EXPECT_TRUE(file_util::CreateDirectory(test_path));
1566
1567 // Doesn't work to create it on top of a non-dir
evanm@google.com874d1672008-10-31 08:54:04 +09001568 test_path = test_path.Append(FILE_PATH_LITERAL("foobar.txt"));
mmoss@google.com733df6b2008-09-12 01:09:11 +09001569 EXPECT_FALSE(file_util::PathExists(test_path));
1570 CreateTextFile(test_path, L"test file");
1571 EXPECT_TRUE(file_util::PathExists(test_path));
1572 EXPECT_FALSE(file_util::CreateDirectory(test_path));
1573
1574 EXPECT_TRUE(file_util::Delete(test_root, true));
1575 EXPECT_FALSE(file_util::PathExists(test_root));
1576 EXPECT_FALSE(file_util::PathExists(test_path));
joi@chromium.org9cd6dd22009-11-27 23:54:41 +09001577
1578 // Verify assumptions made by the Windows implementation:
1579 // 1. The current directory always exists.
1580 // 2. The root directory always exists.
1581 ASSERT_TRUE(file_util::DirectoryExists(
1582 FilePath(FilePath::kCurrentDirectory)));
1583 FilePath top_level = test_root;
1584 while (top_level != top_level.DirName()) {
1585 top_level = top_level.DirName();
1586 }
1587 ASSERT_TRUE(file_util::DirectoryExists(top_level));
1588
1589 // Given these assumptions hold, it should be safe to
1590 // test that "creating" these directories succeeds.
1591 EXPECT_TRUE(file_util::CreateDirectory(
1592 FilePath(FilePath::kCurrentDirectory)));
1593 EXPECT_TRUE(file_util::CreateDirectory(top_level));
huanr@chromium.org57c9dc32009-12-18 05:42:40 +09001594
1595#if defined(OS_WIN)
1596 FilePath invalid_drive(FILE_PATH_LITERAL("o:\\"));
1597 FilePath invalid_path =
1598 invalid_drive.Append(FILE_PATH_LITERAL("some\\inaccessible\\dir"));
1599 if (!file_util::PathExists(invalid_drive)) {
1600 EXPECT_FALSE(file_util::CreateDirectory(invalid_path));
1601 }
1602#endif
mmoss@google.com733df6b2008-09-12 01:09:11 +09001603}
1604
1605TEST_F(FileUtilTest, DetectDirectoryTest) {
1606 // Check a directory
evanm@google.com874d1672008-10-31 08:54:04 +09001607 FilePath test_root =
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001608 temp_dir_.path().Append(FILE_PATH_LITERAL("detect_directory_test"));
mmoss@google.com733df6b2008-09-12 01:09:11 +09001609 EXPECT_FALSE(file_util::PathExists(test_root));
1610 EXPECT_TRUE(file_util::CreateDirectory(test_root));
1611 EXPECT_TRUE(file_util::PathExists(test_root));
1612 EXPECT_TRUE(file_util::DirectoryExists(test_root));
1613
1614 // Check a file
evanm@google.com874d1672008-10-31 08:54:04 +09001615 FilePath test_path =
1616 test_root.Append(FILE_PATH_LITERAL("foobar.txt"));
mmoss@google.com733df6b2008-09-12 01:09:11 +09001617 EXPECT_FALSE(file_util::PathExists(test_path));
1618 CreateTextFile(test_path, L"test file");
1619 EXPECT_TRUE(file_util::PathExists(test_path));
1620 EXPECT_FALSE(file_util::DirectoryExists(test_path));
1621 EXPECT_TRUE(file_util::Delete(test_path, false));
1622
1623 EXPECT_TRUE(file_util::Delete(test_root, true));
initial.commit3f4a7322008-07-27 06:49:38 +09001624}
1625
initial.commit3f4a7322008-07-27 06:49:38 +09001626TEST_F(FileUtilTest, FileEnumeratorTest) {
1627 // Test an empty directory.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001628 file_util::FileEnumerator f0(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
avi@google.com5cb79352008-12-11 23:55:12 +09001629 EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
1630 EXPECT_EQ(f0.Next().value(), FILE_PATH_LITERAL(""));
initial.commit3f4a7322008-07-27 06:49:38 +09001631
yuzo@chromium.org2da0f822009-06-09 14:57:38 +09001632 // Test an empty directory, non-recursively, including "..".
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001633 file_util::FileEnumerator f0_dotdot(temp_dir_.path(), false,
yuzo@chromium.org2da0f822009-06-09 14:57:38 +09001634 static_cast<file_util::FileEnumerator::FILE_TYPE>(
1635 FILES_AND_DIRECTORIES | file_util::FileEnumerator::INCLUDE_DOT_DOT));
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001636 EXPECT_EQ(temp_dir_.path().Append(FILE_PATH_LITERAL("..")).value(),
yuzo@chromium.org2da0f822009-06-09 14:57:38 +09001637 f0_dotdot.Next().value());
1638 EXPECT_EQ(FILE_PATH_LITERAL(""),
1639 f0_dotdot.Next().value());
1640
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001641 // create the directories
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001642 FilePath dir1 = temp_dir_.path().Append(FILE_PATH_LITERAL("dir1"));
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001643 EXPECT_TRUE(file_util::CreateDirectory(dir1));
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001644 FilePath dir2 = temp_dir_.path().Append(FILE_PATH_LITERAL("dir2"));
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001645 EXPECT_TRUE(file_util::CreateDirectory(dir2));
evanm@google.com874d1672008-10-31 08:54:04 +09001646 FilePath dir2inner = dir2.Append(FILE_PATH_LITERAL("inner"));
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001647 EXPECT_TRUE(file_util::CreateDirectory(dir2inner));
evanm@google.com874d1672008-10-31 08:54:04 +09001648
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001649 // create the files
evanm@google.com874d1672008-10-31 08:54:04 +09001650 FilePath dir2file = dir2.Append(FILE_PATH_LITERAL("dir2file.txt"));
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001651 CreateTextFile(dir2file, L"");
evanm@google.com874d1672008-10-31 08:54:04 +09001652 FilePath dir2innerfile = dir2inner.Append(FILE_PATH_LITERAL("innerfile.txt"));
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001653 CreateTextFile(dir2innerfile, L"");
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001654 FilePath file1 = temp_dir_.path().Append(FILE_PATH_LITERAL("file1.txt"));
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001655 CreateTextFile(file1, L"");
evanm@google.com874d1672008-10-31 08:54:04 +09001656 FilePath file2_rel =
1657 dir2.Append(FilePath::kParentDirectory)
1658 .Append(FILE_PATH_LITERAL("file2.txt"));
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001659 CreateTextFile(file2_rel, L"");
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001660 FilePath file2_abs = temp_dir_.path().Append(FILE_PATH_LITERAL("file2.txt"));
initial.commit3f4a7322008-07-27 06:49:38 +09001661
1662 // Only enumerate files.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001663 file_util::FileEnumerator f1(temp_dir_.path(), true,
initial.commit3f4a7322008-07-27 06:49:38 +09001664 file_util::FileEnumerator::FILES);
1665 FindResultCollector c1(f1);
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001666 EXPECT_TRUE(c1.HasFile(file1));
1667 EXPECT_TRUE(c1.HasFile(file2_abs));
1668 EXPECT_TRUE(c1.HasFile(dir2file));
1669 EXPECT_TRUE(c1.HasFile(dir2innerfile));
1670 EXPECT_EQ(c1.size(), 4);
initial.commit3f4a7322008-07-27 06:49:38 +09001671
1672 // Only enumerate directories.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001673 file_util::FileEnumerator f2(temp_dir_.path(), true,
initial.commit3f4a7322008-07-27 06:49:38 +09001674 file_util::FileEnumerator::DIRECTORIES);
1675 FindResultCollector c2(f2);
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001676 EXPECT_TRUE(c2.HasFile(dir1));
1677 EXPECT_TRUE(c2.HasFile(dir2));
1678 EXPECT_TRUE(c2.HasFile(dir2inner));
1679 EXPECT_EQ(c2.size(), 3);
initial.commit3f4a7322008-07-27 06:49:38 +09001680
tim@chromium.org989d0972008-10-16 11:42:45 +09001681 // Only enumerate directories non-recursively.
1682 file_util::FileEnumerator f2_non_recursive(
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001683 temp_dir_.path(), false, file_util::FileEnumerator::DIRECTORIES);
tim@chromium.org989d0972008-10-16 11:42:45 +09001684 FindResultCollector c2_non_recursive(f2_non_recursive);
1685 EXPECT_TRUE(c2_non_recursive.HasFile(dir1));
1686 EXPECT_TRUE(c2_non_recursive.HasFile(dir2));
1687 EXPECT_EQ(c2_non_recursive.size(), 2);
1688
yuzo@chromium.org2da0f822009-06-09 14:57:38 +09001689 // Only enumerate directories, non-recursively, including "..".
1690 file_util::FileEnumerator f2_dotdot(
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001691 temp_dir_.path(), false,
yuzo@chromium.org2da0f822009-06-09 14:57:38 +09001692 static_cast<file_util::FileEnumerator::FILE_TYPE>(
1693 file_util::FileEnumerator::DIRECTORIES |
1694 file_util::FileEnumerator::INCLUDE_DOT_DOT));
1695 FindResultCollector c2_dotdot(f2_dotdot);
1696 EXPECT_TRUE(c2_dotdot.HasFile(dir1));
1697 EXPECT_TRUE(c2_dotdot.HasFile(dir2));
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001698 EXPECT_TRUE(c2_dotdot.HasFile(
1699 temp_dir_.path().Append(FILE_PATH_LITERAL(".."))));
yuzo@chromium.org2da0f822009-06-09 14:57:38 +09001700 EXPECT_EQ(c2_dotdot.size(), 3);
1701
initial.commit3f4a7322008-07-27 06:49:38 +09001702 // Enumerate files and directories.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001703 file_util::FileEnumerator f3(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
initial.commit3f4a7322008-07-27 06:49:38 +09001704 FindResultCollector c3(f3);
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001705 EXPECT_TRUE(c3.HasFile(dir1));
1706 EXPECT_TRUE(c3.HasFile(dir2));
1707 EXPECT_TRUE(c3.HasFile(file1));
1708 EXPECT_TRUE(c3.HasFile(file2_abs));
1709 EXPECT_TRUE(c3.HasFile(dir2file));
1710 EXPECT_TRUE(c3.HasFile(dir2inner));
1711 EXPECT_TRUE(c3.HasFile(dir2innerfile));
1712 EXPECT_EQ(c3.size(), 7);
initial.commit3f4a7322008-07-27 06:49:38 +09001713
1714 // Non-recursive operation.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001715 file_util::FileEnumerator f4(temp_dir_.path(), false, FILES_AND_DIRECTORIES);
initial.commit3f4a7322008-07-27 06:49:38 +09001716 FindResultCollector c4(f4);
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001717 EXPECT_TRUE(c4.HasFile(dir2));
1718 EXPECT_TRUE(c4.HasFile(dir2));
1719 EXPECT_TRUE(c4.HasFile(file1));
1720 EXPECT_TRUE(c4.HasFile(file2_abs));
1721 EXPECT_EQ(c4.size(), 4);
initial.commit3f4a7322008-07-27 06:49:38 +09001722
1723 // Enumerate with a pattern.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001724 file_util::FileEnumerator f5(temp_dir_.path(), true, FILES_AND_DIRECTORIES,
avi@google.com5cb79352008-12-11 23:55:12 +09001725 FILE_PATH_LITERAL("dir*"));
initial.commit3f4a7322008-07-27 06:49:38 +09001726 FindResultCollector c5(f5);
erikkay@google.comdfb51b22008-08-16 02:32:10 +09001727 EXPECT_TRUE(c5.HasFile(dir1));
1728 EXPECT_TRUE(c5.HasFile(dir2));
1729 EXPECT_TRUE(c5.HasFile(dir2file));
1730 EXPECT_TRUE(c5.HasFile(dir2inner));
1731 EXPECT_TRUE(c5.HasFile(dir2innerfile));
1732 EXPECT_EQ(c5.size(), 5);
initial.commit3f4a7322008-07-27 06:49:38 +09001733
1734 // Make sure the destructor closes the find handle while in the middle of a
1735 // query to allow TearDown to delete the directory.
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001736 file_util::FileEnumerator f6(temp_dir_.path(), true, FILES_AND_DIRECTORIES);
avi@google.com5cb79352008-12-11 23:55:12 +09001737 EXPECT_FALSE(f6.Next().value().empty()); // Should have found something
1738 // (we don't care what).
initial.commit3f4a7322008-07-27 06:49:38 +09001739}
license.botf003cfe2008-08-24 09:55:55 +09001740
aa@chromium.orga4dbdf22009-01-10 07:14:27 +09001741TEST_F(FileUtilTest, Contains) {
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001742 FilePath data_dir =
1743 temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
aa@chromium.orga4dbdf22009-01-10 07:14:27 +09001744
1745 // Create a fresh, empty copy of this directory.
rvargas@google.com5a0ae3b2009-01-31 10:19:57 +09001746 if (file_util::PathExists(data_dir)) {
1747 ASSERT_TRUE(file_util::Delete(data_dir, true));
1748 }
aa@chromium.orga4dbdf22009-01-10 07:14:27 +09001749 ASSERT_TRUE(file_util::CreateDirectory(data_dir));
1750
1751 FilePath foo(data_dir.Append(FILE_PATH_LITERAL("foo")));
1752 FilePath bar(foo.Append(FILE_PATH_LITERAL("bar.txt")));
1753 FilePath baz(data_dir.Append(FILE_PATH_LITERAL("baz.txt")));
1754 FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
1755
1756 // Annoyingly, the directories must actually exist in order for realpath(),
1757 // which Contains() relies on in posix, to work.
1758 ASSERT_TRUE(file_util::CreateDirectory(foo));
1759 std::string data("hello");
phajdan.jr@chromium.orgf9908a72009-04-04 02:17:58 +09001760 ASSERT_TRUE(file_util::WriteFile(bar, data.c_str(), data.length()));
1761 ASSERT_TRUE(file_util::WriteFile(baz, data.c_str(), data.length()));
1762 ASSERT_TRUE(file_util::WriteFile(foobar, data.c_str(), data.length()));
aa@chromium.orga4dbdf22009-01-10 07:14:27 +09001763
1764 EXPECT_TRUE(file_util::ContainsPath(foo, bar));
1765 EXPECT_FALSE(file_util::ContainsPath(foo, baz));
1766 EXPECT_FALSE(file_util::ContainsPath(foo, foobar));
1767 EXPECT_FALSE(file_util::ContainsPath(foo, foo));
1768
evan@chromium.org875bb6e2009-12-29 09:32:52 +09001769 // Platform-specific concerns.
aa@chromium.orga4dbdf22009-01-10 07:14:27 +09001770 FilePath foo_caps(data_dir.Append(FILE_PATH_LITERAL("FOO")));
1771#if defined(OS_WIN)
1772 EXPECT_TRUE(file_util::ContainsPath(foo,
1773 foo_caps.Append(FILE_PATH_LITERAL("bar.txt"))));
jrg@chromium.orgd505c3a2009-02-04 09:58:39 +09001774 EXPECT_TRUE(file_util::ContainsPath(foo,
aa@chromium.orga4dbdf22009-01-10 07:14:27 +09001775 FilePath(foo.value() + FILE_PATH_LITERAL("/bar.txt"))));
evan@chromium.org875bb6e2009-12-29 09:32:52 +09001776#elif defined(OS_MACOSX)
1777 // We can't really do this test on OS X since the case-sensitivity of the
1778 // filesystem is configurable.
1779#elif defined(OS_POSIX)
aa@chromium.orga4dbdf22009-01-10 07:14:27 +09001780 EXPECT_FALSE(file_util::ContainsPath(foo,
1781 foo_caps.Append(FILE_PATH_LITERAL("bar.txt"))));
aa@chromium.orga4dbdf22009-01-10 07:14:27 +09001782#endif
1783}
1784
dumi@chromium.orgc941a182010-09-24 08:28:22 +09001785TEST_F(FileUtilTest, TouchFile) {
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001786 FilePath data_dir =
1787 temp_dir_.path().Append(FILE_PATH_LITERAL("FilePathTest"));
jochen@chromium.orga6879772010-02-18 19:02:26 +09001788
1789 // Create a fresh, empty copy of this directory.
1790 if (file_util::PathExists(data_dir)) {
1791 ASSERT_TRUE(file_util::Delete(data_dir, true));
1792 }
1793 ASSERT_TRUE(file_util::CreateDirectory(data_dir));
1794
1795 FilePath foobar(data_dir.Append(FILE_PATH_LITERAL("foobar.txt")));
1796 std::string data("hello");
1797 ASSERT_TRUE(file_util::WriteFile(foobar, data.c_str(), data.length()));
1798
dumi@chromium.orgc941a182010-09-24 08:28:22 +09001799 base::Time access_time;
1800 // This timestamp is divisible by one day (in local timezone),
1801 // to make it work on FAT too.
1802 ASSERT_TRUE(base::Time::FromString(L"Wed, 16 Nov 1994, 00:00:00",
1803 &access_time));
1804
jochen@chromium.orga6879772010-02-18 19:02:26 +09001805 base::Time modification_time;
1806 // Note that this timestamp is divisible by two (seconds) - FAT stores
1807 // modification times with 2s resolution.
1808 ASSERT_TRUE(base::Time::FromString(L"Tue, 15 Nov 1994, 12:45:26 GMT",
1809 &modification_time));
dumi@chromium.orgc941a182010-09-24 08:28:22 +09001810
1811 ASSERT_TRUE(file_util::TouchFile(foobar, access_time, modification_time));
dumi@chromium.org97ae2612010-09-03 11:28:37 +09001812 base::PlatformFileInfo file_info;
jochen@chromium.orga6879772010-02-18 19:02:26 +09001813 ASSERT_TRUE(file_util::GetFileInfo(foobar, &file_info));
dumi@chromium.orgc941a182010-09-24 08:28:22 +09001814 EXPECT_EQ(file_info.last_accessed.ToInternalValue(),
1815 access_time.ToInternalValue());
1816 EXPECT_EQ(file_info.last_modified.ToInternalValue(),
1817 modification_time.ToInternalValue());
jochen@chromium.orga6879772010-02-18 19:02:26 +09001818}
1819
tfarina@chromium.org34828222010-05-26 10:40:12 +09001820TEST_F(FileUtilTest, IsDirectoryEmpty) {
phajdan.jr@chromium.org8fe305d2010-09-16 05:40:47 +09001821 FilePath empty_dir = temp_dir_.path().Append(FILE_PATH_LITERAL("EmptyDir"));
tfarina@chromium.org34828222010-05-26 10:40:12 +09001822
1823 ASSERT_FALSE(file_util::PathExists(empty_dir));
1824
1825 ASSERT_TRUE(file_util::CreateDirectory(empty_dir));
1826
1827 EXPECT_TRUE(file_util::IsDirectoryEmpty(empty_dir));
1828
1829 FilePath foo(empty_dir.Append(FILE_PATH_LITERAL("foo.txt")));
1830 std::string bar("baz");
1831 ASSERT_TRUE(file_util::WriteFile(foo, bar.c_str(), bar.length()));
1832
1833 EXPECT_FALSE(file_util::IsDirectoryEmpty(empty_dir));
1834}
1835
mark@chromium.org17684802008-09-10 09:16:28 +09001836} // namespace