| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <set> | |
| 6 | |
| 7 #include "base/file_util.h" | |
| 8 #include "base/files/file.h" | |
| 9 #include "base/files/file_path.h" | |
| 10 #include "base/files/scoped_temp_dir.h" | |
| 11 #include "testing/gtest/include/gtest/gtest.h" | |
| 12 #include "webkit/browser/fileapi/native_file_util.h" | |
| 13 | |
| 14 namespace fileapi { | |
| 15 | |
| 16 class NativeFileUtilTest : public testing::Test { | |
| 17 public: | |
| 18 NativeFileUtilTest() {} | |
| 19 | |
| 20 virtual void SetUp() { | |
| 21 ASSERT_TRUE(data_dir_.CreateUniqueTempDir()); | |
| 22 } | |
| 23 | |
| 24 protected: | |
| 25 base::FilePath Path() { | |
| 26 return data_dir_.path(); | |
| 27 } | |
| 28 | |
| 29 base::FilePath Path(const char* file_name) { | |
| 30 return data_dir_.path().AppendASCII(file_name); | |
| 31 } | |
| 32 | |
| 33 bool FileExists(const base::FilePath& path) { | |
| 34 return base::PathExists(path) && | |
| 35 !base::DirectoryExists(path); | |
| 36 } | |
| 37 | |
| 38 int64 GetSize(const base::FilePath& path) { | |
| 39 base::File::Info info; | |
| 40 base::GetFileInfo(path, &info); | |
| 41 return info.size; | |
| 42 } | |
| 43 | |
| 44 private: | |
| 45 base::ScopedTempDir data_dir_; | |
| 46 | |
| 47 DISALLOW_COPY_AND_ASSIGN(NativeFileUtilTest); | |
| 48 }; | |
| 49 | |
| 50 TEST_F(NativeFileUtilTest, CreateCloseAndDeleteFile) { | |
| 51 base::FilePath file_name = Path("test_file"); | |
| 52 int flags = base::File::FLAG_WRITE | base::File::FLAG_ASYNC; | |
| 53 base::File file = | |
| 54 NativeFileUtil::CreateOrOpen(file_name, base::File::FLAG_CREATE | flags); | |
| 55 ASSERT_TRUE(file.IsValid()); | |
| 56 ASSERT_TRUE(file.created()); | |
| 57 | |
| 58 EXPECT_TRUE(base::PathExists(file_name)); | |
| 59 EXPECT_TRUE(NativeFileUtil::PathExists(file_name)); | |
| 60 EXPECT_EQ(0, GetSize(file_name)); | |
| 61 file.Close(); | |
| 62 | |
| 63 file = NativeFileUtil::CreateOrOpen(file_name, base::File::FLAG_OPEN | flags); | |
| 64 ASSERT_TRUE(file.IsValid()); | |
| 65 ASSERT_FALSE(file.created()); | |
| 66 file.Close(); | |
| 67 | |
| 68 ASSERT_EQ(base::File::FILE_OK, | |
| 69 NativeFileUtil::DeleteFile(file_name)); | |
| 70 EXPECT_FALSE(base::PathExists(file_name)); | |
| 71 EXPECT_FALSE(NativeFileUtil::PathExists(file_name)); | |
| 72 } | |
| 73 | |
| 74 TEST_F(NativeFileUtilTest, EnsureFileExists) { | |
| 75 base::FilePath file_name = Path("foobar"); | |
| 76 bool created = false; | |
| 77 ASSERT_EQ(base::File::FILE_OK, | |
| 78 NativeFileUtil::EnsureFileExists(file_name, &created)); | |
| 79 ASSERT_TRUE(created); | |
| 80 | |
| 81 EXPECT_TRUE(FileExists(file_name)); | |
| 82 EXPECT_EQ(0, GetSize(file_name)); | |
| 83 | |
| 84 ASSERT_EQ(base::File::FILE_OK, | |
| 85 NativeFileUtil::EnsureFileExists(file_name, &created)); | |
| 86 EXPECT_FALSE(created); | |
| 87 } | |
| 88 | |
| 89 TEST_F(NativeFileUtilTest, CreateAndDeleteDirectory) { | |
| 90 base::FilePath dir_name = Path("test_dir"); | |
| 91 ASSERT_EQ(base::File::FILE_OK, | |
| 92 NativeFileUtil::CreateDirectory(dir_name, | |
| 93 false /* exclusive */, | |
| 94 false /* recursive */)); | |
| 95 | |
| 96 EXPECT_TRUE(NativeFileUtil::DirectoryExists(dir_name)); | |
| 97 EXPECT_TRUE(base::DirectoryExists(dir_name)); | |
| 98 | |
| 99 ASSERT_EQ(base::File::FILE_ERROR_EXISTS, | |
| 100 NativeFileUtil::CreateDirectory(dir_name, | |
| 101 true /* exclusive */, | |
| 102 false /* recursive */)); | |
| 103 | |
| 104 ASSERT_EQ(base::File::FILE_OK, | |
| 105 NativeFileUtil::DeleteDirectory(dir_name)); | |
| 106 EXPECT_FALSE(base::DirectoryExists(dir_name)); | |
| 107 EXPECT_FALSE(NativeFileUtil::DirectoryExists(dir_name)); | |
| 108 } | |
| 109 | |
| 110 TEST_F(NativeFileUtilTest, TouchFileAndGetFileInfo) { | |
| 111 base::FilePath file_name = Path("test_file"); | |
| 112 base::File::Info native_info; | |
| 113 ASSERT_EQ(base::File::FILE_ERROR_NOT_FOUND, | |
| 114 NativeFileUtil::GetFileInfo(file_name, &native_info)); | |
| 115 | |
| 116 bool created = false; | |
| 117 ASSERT_EQ(base::File::FILE_OK, | |
| 118 NativeFileUtil::EnsureFileExists(file_name, &created)); | |
| 119 ASSERT_TRUE(created); | |
| 120 | |
| 121 base::File::Info info; | |
| 122 ASSERT_TRUE(base::GetFileInfo(file_name, &info)); | |
| 123 ASSERT_EQ(base::File::FILE_OK, | |
| 124 NativeFileUtil::GetFileInfo(file_name, &native_info)); | |
| 125 ASSERT_EQ(info.size, native_info.size); | |
| 126 ASSERT_EQ(info.is_directory, native_info.is_directory); | |
| 127 ASSERT_EQ(info.is_symbolic_link, native_info.is_symbolic_link); | |
| 128 ASSERT_EQ(info.last_modified, native_info.last_modified); | |
| 129 ASSERT_EQ(info.last_accessed, native_info.last_accessed); | |
| 130 ASSERT_EQ(info.creation_time, native_info.creation_time); | |
| 131 | |
| 132 const base::Time new_accessed = | |
| 133 info.last_accessed + base::TimeDelta::FromHours(10); | |
| 134 const base::Time new_modified = | |
| 135 info.last_modified + base::TimeDelta::FromHours(5); | |
| 136 | |
| 137 EXPECT_EQ(base::File::FILE_OK, | |
| 138 NativeFileUtil::Touch(file_name, | |
| 139 new_accessed, new_modified)); | |
| 140 | |
| 141 ASSERT_TRUE(base::GetFileInfo(file_name, &info)); | |
| 142 EXPECT_EQ(new_accessed, info.last_accessed); | |
| 143 EXPECT_EQ(new_modified, info.last_modified); | |
| 144 } | |
| 145 | |
| 146 TEST_F(NativeFileUtilTest, CreateFileEnumerator) { | |
| 147 base::FilePath path_1 = Path("dir1"); | |
| 148 base::FilePath path_2 = Path("file1"); | |
| 149 base::FilePath path_11 = Path("dir1").AppendASCII("file11"); | |
| 150 base::FilePath path_12 = Path("dir1").AppendASCII("dir12"); | |
| 151 base::FilePath path_121 = | |
| 152 Path("dir1").AppendASCII("dir12").AppendASCII("file121"); | |
| 153 ASSERT_EQ(base::File::FILE_OK, | |
| 154 NativeFileUtil::CreateDirectory(path_1, false, false)); | |
| 155 bool created = false; | |
| 156 ASSERT_EQ(base::File::FILE_OK, | |
| 157 NativeFileUtil::EnsureFileExists(path_2, &created)); | |
| 158 ASSERT_EQ(base::File::FILE_OK, | |
| 159 NativeFileUtil::EnsureFileExists(path_11, &created)); | |
| 160 ASSERT_EQ(base::File::FILE_OK, | |
| 161 NativeFileUtil::CreateDirectory(path_12, false, false)); | |
| 162 ASSERT_EQ(base::File::FILE_OK, | |
| 163 NativeFileUtil::EnsureFileExists(path_121, &created)); | |
| 164 | |
| 165 { | |
| 166 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator = | |
| 167 NativeFileUtil::CreateFileEnumerator(Path(), false); | |
| 168 std::set<base::FilePath> set; | |
| 169 set.insert(path_1); | |
| 170 set.insert(path_2); | |
| 171 for (base::FilePath path = enumerator->Next(); !path.empty(); | |
| 172 path = enumerator->Next()) | |
| 173 EXPECT_EQ(1U, set.erase(path)); | |
| 174 EXPECT_TRUE(set.empty()); | |
| 175 } | |
| 176 | |
| 177 { | |
| 178 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator = | |
| 179 NativeFileUtil::CreateFileEnumerator(Path(), true); | |
| 180 std::set<base::FilePath> set; | |
| 181 set.insert(path_1); | |
| 182 set.insert(path_2); | |
| 183 set.insert(path_11); | |
| 184 set.insert(path_12); | |
| 185 set.insert(path_121); | |
| 186 for (base::FilePath path = enumerator->Next(); !path.empty(); | |
| 187 path = enumerator->Next()) | |
| 188 EXPECT_EQ(1U, set.erase(path)); | |
| 189 EXPECT_TRUE(set.empty()); | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 TEST_F(NativeFileUtilTest, Truncate) { | |
| 194 base::FilePath file_name = Path("truncated"); | |
| 195 bool created = false; | |
| 196 ASSERT_EQ(base::File::FILE_OK, | |
| 197 NativeFileUtil::EnsureFileExists(file_name, &created)); | |
| 198 ASSERT_TRUE(created); | |
| 199 | |
| 200 ASSERT_EQ(base::File::FILE_OK, | |
| 201 NativeFileUtil::Truncate(file_name, 1020)); | |
| 202 | |
| 203 EXPECT_TRUE(FileExists(file_name)); | |
| 204 EXPECT_EQ(1020, GetSize(file_name)); | |
| 205 } | |
| 206 | |
| 207 TEST_F(NativeFileUtilTest, CopyFile) { | |
| 208 base::FilePath from_file = Path("fromfile"); | |
| 209 base::FilePath to_file1 = Path("tofile1"); | |
| 210 base::FilePath to_file2 = Path("tofile2"); | |
| 211 const NativeFileUtil::CopyOrMoveMode nosync = NativeFileUtil::COPY_NOSYNC; | |
| 212 const NativeFileUtil::CopyOrMoveMode sync = NativeFileUtil::COPY_SYNC; | |
| 213 bool created = false; | |
| 214 ASSERT_EQ(base::File::FILE_OK, | |
| 215 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 216 ASSERT_TRUE(created); | |
| 217 | |
| 218 ASSERT_EQ(base::File::FILE_OK, | |
| 219 NativeFileUtil::Truncate(from_file, 1020)); | |
| 220 | |
| 221 EXPECT_TRUE(FileExists(from_file)); | |
| 222 EXPECT_EQ(1020, GetSize(from_file)); | |
| 223 | |
| 224 ASSERT_EQ(base::File::FILE_OK, | |
| 225 NativeFileUtil::CopyOrMoveFile( | |
| 226 from_file, to_file1, FileSystemOperation::OPTION_NONE, nosync)); | |
| 227 | |
| 228 ASSERT_EQ(base::File::FILE_OK, | |
| 229 NativeFileUtil::CopyOrMoveFile( | |
| 230 from_file, to_file2, FileSystemOperation::OPTION_NONE, sync)); | |
| 231 | |
| 232 EXPECT_TRUE(FileExists(from_file)); | |
| 233 EXPECT_EQ(1020, GetSize(from_file)); | |
| 234 EXPECT_TRUE(FileExists(to_file1)); | |
| 235 EXPECT_EQ(1020, GetSize(to_file1)); | |
| 236 EXPECT_TRUE(FileExists(to_file2)); | |
| 237 EXPECT_EQ(1020, GetSize(to_file2)); | |
| 238 | |
| 239 base::FilePath dir = Path("dir"); | |
| 240 ASSERT_EQ(base::File::FILE_OK, | |
| 241 NativeFileUtil::CreateDirectory(dir, false, false)); | |
| 242 ASSERT_TRUE(base::DirectoryExists(dir)); | |
| 243 base::FilePath to_dir_file = dir.AppendASCII("file"); | |
| 244 ASSERT_EQ(base::File::FILE_OK, | |
| 245 NativeFileUtil::CopyOrMoveFile( | |
| 246 from_file, to_dir_file, | |
| 247 FileSystemOperation::OPTION_NONE, nosync)); | |
| 248 EXPECT_TRUE(FileExists(to_dir_file)); | |
| 249 EXPECT_EQ(1020, GetSize(to_dir_file)); | |
| 250 | |
| 251 // Following tests are error checking. | |
| 252 // Source doesn't exist. | |
| 253 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, | |
| 254 NativeFileUtil::CopyOrMoveFile( | |
| 255 Path("nonexists"), Path("file"), | |
| 256 FileSystemOperation::OPTION_NONE, nosync)); | |
| 257 | |
| 258 // Source is not a file. | |
| 259 EXPECT_EQ(base::File::FILE_ERROR_NOT_A_FILE, | |
| 260 NativeFileUtil::CopyOrMoveFile( | |
| 261 dir, Path("file"), FileSystemOperation::OPTION_NONE, nosync)); | |
| 262 // Destination is not a file. | |
| 263 EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION, | |
| 264 NativeFileUtil::CopyOrMoveFile( | |
| 265 from_file, dir, FileSystemOperation::OPTION_NONE, nosync)); | |
| 266 // Destination's parent doesn't exist. | |
| 267 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, | |
| 268 NativeFileUtil::CopyOrMoveFile( | |
| 269 from_file, Path("nodir").AppendASCII("file"), | |
| 270 FileSystemOperation::OPTION_NONE, nosync)); | |
| 271 // Destination's parent is a file. | |
| 272 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, | |
| 273 NativeFileUtil::CopyOrMoveFile( | |
| 274 from_file, Path("tofile1").AppendASCII("file"), | |
| 275 FileSystemOperation::OPTION_NONE, nosync)); | |
| 276 } | |
| 277 | |
| 278 TEST_F(NativeFileUtilTest, MoveFile) { | |
| 279 base::FilePath from_file = Path("fromfile"); | |
| 280 base::FilePath to_file = Path("tofile"); | |
| 281 const NativeFileUtil::CopyOrMoveMode move = NativeFileUtil::MOVE; | |
| 282 bool created = false; | |
| 283 ASSERT_EQ(base::File::FILE_OK, | |
| 284 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 285 ASSERT_TRUE(created); | |
| 286 | |
| 287 ASSERT_EQ(base::File::FILE_OK, NativeFileUtil::Truncate(from_file, 1020)); | |
| 288 | |
| 289 EXPECT_TRUE(FileExists(from_file)); | |
| 290 EXPECT_EQ(1020, GetSize(from_file)); | |
| 291 | |
| 292 ASSERT_EQ(base::File::FILE_OK, | |
| 293 NativeFileUtil::CopyOrMoveFile( | |
| 294 from_file, to_file, FileSystemOperation::OPTION_NONE, move)); | |
| 295 | |
| 296 EXPECT_FALSE(FileExists(from_file)); | |
| 297 EXPECT_TRUE(FileExists(to_file)); | |
| 298 EXPECT_EQ(1020, GetSize(to_file)); | |
| 299 | |
| 300 ASSERT_EQ(base::File::FILE_OK, | |
| 301 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 302 ASSERT_TRUE(FileExists(from_file)); | |
| 303 ASSERT_EQ(base::File::FILE_OK, NativeFileUtil::Truncate(from_file, 1020)); | |
| 304 | |
| 305 base::FilePath dir = Path("dir"); | |
| 306 ASSERT_EQ(base::File::FILE_OK, | |
| 307 NativeFileUtil::CreateDirectory(dir, false, false)); | |
| 308 ASSERT_TRUE(base::DirectoryExists(dir)); | |
| 309 base::FilePath to_dir_file = dir.AppendASCII("file"); | |
| 310 ASSERT_EQ(base::File::FILE_OK, | |
| 311 NativeFileUtil::CopyOrMoveFile( | |
| 312 from_file, to_dir_file, | |
| 313 FileSystemOperation::OPTION_NONE, move)); | |
| 314 EXPECT_FALSE(FileExists(from_file)); | |
| 315 EXPECT_TRUE(FileExists(to_dir_file)); | |
| 316 EXPECT_EQ(1020, GetSize(to_dir_file)); | |
| 317 | |
| 318 // Following is error checking. | |
| 319 // Source doesn't exist. | |
| 320 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, | |
| 321 NativeFileUtil::CopyOrMoveFile( | |
| 322 Path("nonexists"), Path("file"), | |
| 323 FileSystemOperation::OPTION_NONE, move)); | |
| 324 | |
| 325 // Source is not a file. | |
| 326 EXPECT_EQ(base::File::FILE_ERROR_NOT_A_FILE, | |
| 327 NativeFileUtil::CopyOrMoveFile( | |
| 328 dir, Path("file"), FileSystemOperation::OPTION_NONE, move)); | |
| 329 ASSERT_EQ(base::File::FILE_OK, | |
| 330 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 331 ASSERT_TRUE(FileExists(from_file)); | |
| 332 // Destination is not a file. | |
| 333 EXPECT_EQ(base::File::FILE_ERROR_INVALID_OPERATION, | |
| 334 NativeFileUtil::CopyOrMoveFile( | |
| 335 from_file, dir, FileSystemOperation::OPTION_NONE, move)); | |
| 336 | |
| 337 ASSERT_EQ(base::File::FILE_OK, | |
| 338 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 339 ASSERT_TRUE(FileExists(from_file)); | |
| 340 // Destination's parent doesn't exist. | |
| 341 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, | |
| 342 NativeFileUtil::CopyOrMoveFile( | |
| 343 from_file, Path("nodir").AppendASCII("file"), | |
| 344 FileSystemOperation::OPTION_NONE, move)); | |
| 345 // Destination's parent is a file. | |
| 346 EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, | |
| 347 NativeFileUtil::CopyOrMoveFile( | |
| 348 from_file, Path("tofile1").AppendASCII("file"), | |
| 349 FileSystemOperation::OPTION_NONE, move)); | |
| 350 } | |
| 351 | |
| 352 TEST_F(NativeFileUtilTest, PreserveLastModified) { | |
| 353 base::FilePath from_file = Path("fromfile"); | |
| 354 base::FilePath to_file1 = Path("tofile1"); | |
| 355 base::FilePath to_file2 = Path("tofile2"); | |
| 356 base::FilePath to_file3 = Path("tofile3"); | |
| 357 bool created = false; | |
| 358 ASSERT_EQ(base::File::FILE_OK, | |
| 359 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 360 ASSERT_TRUE(created); | |
| 361 EXPECT_TRUE(FileExists(from_file)); | |
| 362 | |
| 363 base::File::Info file_info1; | |
| 364 ASSERT_EQ(base::File::FILE_OK, | |
| 365 NativeFileUtil::GetFileInfo(from_file, &file_info1)); | |
| 366 | |
| 367 // Test for copy (nosync). | |
| 368 ASSERT_EQ(base::File::FILE_OK, | |
| 369 NativeFileUtil::CopyOrMoveFile( | |
| 370 from_file, to_file1, | |
| 371 FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED, | |
| 372 NativeFileUtil::COPY_NOSYNC)); | |
| 373 | |
| 374 base::File::Info file_info2; | |
| 375 ASSERT_TRUE(FileExists(to_file1)); | |
| 376 ASSERT_EQ(base::File::FILE_OK, | |
| 377 NativeFileUtil::GetFileInfo(to_file1, &file_info2)); | |
| 378 EXPECT_EQ(file_info1.last_modified, file_info2.last_modified); | |
| 379 | |
| 380 // Test for copy (sync). | |
| 381 ASSERT_EQ(base::File::FILE_OK, | |
| 382 NativeFileUtil::CopyOrMoveFile( | |
| 383 from_file, to_file2, | |
| 384 FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED, | |
| 385 NativeFileUtil::COPY_SYNC)); | |
| 386 | |
| 387 ASSERT_TRUE(FileExists(to_file2)); | |
| 388 ASSERT_EQ(base::File::FILE_OK, | |
| 389 NativeFileUtil::GetFileInfo(to_file1, &file_info2)); | |
| 390 EXPECT_EQ(file_info1.last_modified, file_info2.last_modified); | |
| 391 | |
| 392 // Test for move. | |
| 393 ASSERT_EQ(base::File::FILE_OK, | |
| 394 NativeFileUtil::CopyOrMoveFile( | |
| 395 from_file, to_file3, | |
| 396 FileSystemOperation::OPTION_PRESERVE_LAST_MODIFIED, | |
| 397 NativeFileUtil::MOVE)); | |
| 398 | |
| 399 ASSERT_TRUE(FileExists(to_file3)); | |
| 400 ASSERT_EQ(base::File::FILE_OK, | |
| 401 NativeFileUtil::GetFileInfo(to_file2, &file_info2)); | |
| 402 EXPECT_EQ(file_info1.last_modified, file_info2.last_modified); | |
| 403 } | |
| 404 | |
| 405 } // namespace fileapi | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 253753007:
Move all remaining fileapi and quota unit tests from webkit/ to content/ (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src