| 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 "base/files/file_path.h" | |
| 6 #include "base/files/scoped_temp_dir.h" | |
| 7 #include "base/platform_file.h" | |
| 8 #include "testing/gtest/include/gtest/gtest.h" | |
| 9 #include "webkit/fileapi/native_file_util.h" | |
| 10 | |
| 11 namespace fileapi { | |
| 12 | |
| 13 class NativeFileUtilTest : public testing::Test { | |
| 14 public: | |
| 15 NativeFileUtilTest() {} | |
| 16 | |
| 17 virtual void SetUp() { | |
| 18 ASSERT_TRUE(data_dir_.CreateUniqueTempDir()); | |
| 19 } | |
| 20 | |
| 21 protected: | |
| 22 base::FilePath Path() { | |
| 23 return data_dir_.path(); | |
| 24 } | |
| 25 | |
| 26 base::FilePath Path(const char* file_name) { | |
| 27 return data_dir_.path().AppendASCII(file_name); | |
| 28 } | |
| 29 | |
| 30 bool FileExists(const base::FilePath& path) { | |
| 31 return file_util::PathExists(path) && | |
| 32 !file_util::DirectoryExists(path); | |
| 33 } | |
| 34 | |
| 35 int64 GetSize(const base::FilePath& path) { | |
| 36 base::PlatformFileInfo info; | |
| 37 file_util::GetFileInfo(path, &info); | |
| 38 return info.size; | |
| 39 } | |
| 40 | |
| 41 private: | |
| 42 base::ScopedTempDir data_dir_; | |
| 43 | |
| 44 DISALLOW_COPY_AND_ASSIGN(NativeFileUtilTest); | |
| 45 }; | |
| 46 | |
| 47 TEST_F(NativeFileUtilTest, CreateCloseAndDeleteFile) { | |
| 48 base::FilePath file_name = Path("test_file"); | |
| 49 base::PlatformFile file_handle; | |
| 50 bool created = false; | |
| 51 int flags = base::PLATFORM_FILE_WRITE | base::PLATFORM_FILE_ASYNC; | |
| 52 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 53 NativeFileUtil::CreateOrOpen(file_name, | |
| 54 base::PLATFORM_FILE_CREATE | flags, | |
| 55 &file_handle, &created)); | |
| 56 ASSERT_TRUE(created); | |
| 57 | |
| 58 EXPECT_TRUE(file_util::PathExists(file_name)); | |
| 59 EXPECT_TRUE(NativeFileUtil::PathExists(file_name)); | |
| 60 EXPECT_EQ(0, GetSize(file_name)); | |
| 61 EXPECT_NE(base::kInvalidPlatformFileValue, file_handle); | |
| 62 | |
| 63 ASSERT_EQ(base::PLATFORM_FILE_OK, NativeFileUtil::Close(file_handle)); | |
| 64 | |
| 65 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 66 NativeFileUtil::CreateOrOpen(file_name, | |
| 67 base::PLATFORM_FILE_OPEN | flags, | |
| 68 &file_handle, &created)); | |
| 69 ASSERT_FALSE(created); | |
| 70 ASSERT_EQ(base::PLATFORM_FILE_OK, NativeFileUtil::Close(file_handle)); | |
| 71 | |
| 72 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 73 NativeFileUtil::DeleteFile(file_name)); | |
| 74 EXPECT_FALSE(file_util::PathExists(file_name)); | |
| 75 EXPECT_FALSE(NativeFileUtil::PathExists(file_name)); | |
| 76 } | |
| 77 | |
| 78 TEST_F(NativeFileUtilTest, EnsureFileExists) { | |
| 79 base::FilePath file_name = Path("foobar"); | |
| 80 bool created = false; | |
| 81 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 82 NativeFileUtil::EnsureFileExists(file_name, &created)); | |
| 83 ASSERT_TRUE(created); | |
| 84 | |
| 85 EXPECT_TRUE(FileExists(file_name)); | |
| 86 EXPECT_EQ(0, GetSize(file_name)); | |
| 87 | |
| 88 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 89 NativeFileUtil::EnsureFileExists(file_name, &created)); | |
| 90 EXPECT_FALSE(created); | |
| 91 } | |
| 92 | |
| 93 TEST_F(NativeFileUtilTest, CreateAndDeleteDirectory) { | |
| 94 base::FilePath dir_name = Path("test_dir"); | |
| 95 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 96 NativeFileUtil::CreateDirectory(dir_name, | |
| 97 false /* exclusive */, | |
| 98 false /* recursive */)); | |
| 99 | |
| 100 EXPECT_TRUE(NativeFileUtil::DirectoryExists(dir_name)); | |
| 101 EXPECT_TRUE(file_util::DirectoryExists(dir_name)); | |
| 102 | |
| 103 ASSERT_EQ(base::PLATFORM_FILE_ERROR_EXISTS, | |
| 104 NativeFileUtil::CreateDirectory(dir_name, | |
| 105 true /* exclusive */, | |
| 106 false /* recursive */)); | |
| 107 | |
| 108 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 109 NativeFileUtil::DeleteDirectory (dir_name)); | |
| 110 EXPECT_FALSE(file_util::DirectoryExists(dir_name)); | |
| 111 EXPECT_FALSE(NativeFileUtil::DirectoryExists(dir_name)); | |
| 112 } | |
| 113 | |
| 114 TEST_F(NativeFileUtilTest, TouchFileAndGetFileInfo) { | |
| 115 base::FilePath file_name = Path("test_file"); | |
| 116 base::PlatformFileInfo native_info; | |
| 117 ASSERT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, | |
| 118 NativeFileUtil::GetFileInfo(file_name, &native_info)); | |
| 119 | |
| 120 bool created = false; | |
| 121 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 122 NativeFileUtil::EnsureFileExists(file_name, &created)); | |
| 123 ASSERT_TRUE(created); | |
| 124 | |
| 125 base::PlatformFileInfo info; | |
| 126 ASSERT_TRUE(file_util::GetFileInfo(file_name, &info)); | |
| 127 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 128 NativeFileUtil::GetFileInfo(file_name, &native_info)); | |
| 129 ASSERT_EQ(info.size, native_info.size); | |
| 130 ASSERT_EQ(info.is_directory, native_info.is_directory); | |
| 131 ASSERT_EQ(info.is_symbolic_link, native_info.is_symbolic_link); | |
| 132 ASSERT_EQ(info.last_modified, native_info.last_modified); | |
| 133 ASSERT_EQ(info.last_accessed, native_info.last_accessed); | |
| 134 ASSERT_EQ(info.creation_time, native_info.creation_time); | |
| 135 | |
| 136 const base::Time new_accessed = | |
| 137 info.last_accessed + base::TimeDelta::FromHours(10); | |
| 138 const base::Time new_modified = | |
| 139 info.last_modified + base::TimeDelta::FromHours(5); | |
| 140 | |
| 141 EXPECT_EQ(base::PLATFORM_FILE_OK, | |
| 142 NativeFileUtil::Touch(file_name, | |
| 143 new_accessed, new_modified)); | |
| 144 | |
| 145 ASSERT_TRUE(file_util::GetFileInfo(file_name, &info)); | |
| 146 EXPECT_EQ(new_accessed, info.last_accessed); | |
| 147 EXPECT_EQ(new_modified, info.last_modified); | |
| 148 } | |
| 149 | |
| 150 TEST_F(NativeFileUtilTest, CreateFileEnumerator) { | |
| 151 base::FilePath path_1 = Path("dir1"); | |
| 152 base::FilePath path_2 = Path("file1"); | |
| 153 base::FilePath path_11 = Path("dir1").AppendASCII("file11"); | |
| 154 base::FilePath path_12 = Path("dir1").AppendASCII("dir12"); | |
| 155 base::FilePath path_121 = | |
| 156 Path("dir1").AppendASCII("dir12").AppendASCII("file121"); | |
| 157 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 158 NativeFileUtil::CreateDirectory(path_1, false, false)); | |
| 159 bool created = false; | |
| 160 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 161 NativeFileUtil::EnsureFileExists(path_2, &created)); | |
| 162 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 163 NativeFileUtil::EnsureFileExists(path_11, &created)); | |
| 164 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 165 NativeFileUtil::CreateDirectory(path_12, false, false)); | |
| 166 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 167 NativeFileUtil::EnsureFileExists(path_121, &created)); | |
| 168 | |
| 169 { | |
| 170 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator = | |
| 171 NativeFileUtil::CreateFileEnumerator(Path(), false); | |
| 172 std::set<base::FilePath> set; | |
| 173 set.insert(path_1); | |
| 174 set.insert(path_2); | |
| 175 for (base::FilePath path = enumerator->Next(); !path.empty(); | |
| 176 path = enumerator->Next()) | |
| 177 EXPECT_EQ(1U, set.erase(path)); | |
| 178 EXPECT_TRUE(set.empty()); | |
| 179 } | |
| 180 | |
| 181 { | |
| 182 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator> enumerator = | |
| 183 NativeFileUtil::CreateFileEnumerator(Path(), true); | |
| 184 std::set<base::FilePath> set; | |
| 185 set.insert(path_1); | |
| 186 set.insert(path_2); | |
| 187 set.insert(path_11); | |
| 188 set.insert(path_12); | |
| 189 set.insert(path_121); | |
| 190 for (base::FilePath path = enumerator->Next(); !path.empty(); | |
| 191 path = enumerator->Next()) | |
| 192 EXPECT_EQ(1U, set.erase(path)); | |
| 193 EXPECT_TRUE(set.empty()); | |
| 194 } | |
| 195 } | |
| 196 | |
| 197 TEST_F(NativeFileUtilTest, Truncate) { | |
| 198 base::FilePath file_name = Path("truncated"); | |
| 199 bool created = false; | |
| 200 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 201 NativeFileUtil::EnsureFileExists(file_name, &created)); | |
| 202 ASSERT_TRUE(created); | |
| 203 | |
| 204 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 205 NativeFileUtil::Truncate(file_name, 1020)); | |
| 206 | |
| 207 EXPECT_TRUE(FileExists(file_name)); | |
| 208 EXPECT_EQ(1020, GetSize(file_name)); | |
| 209 } | |
| 210 | |
| 211 TEST_F(NativeFileUtilTest, CopyFile) { | |
| 212 base::FilePath from_file = Path("fromfile"); | |
| 213 base::FilePath to_file1 = Path("tofile1"); | |
| 214 base::FilePath to_file2 = Path("tofile2"); | |
| 215 bool created = false; | |
| 216 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 217 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 218 ASSERT_TRUE(created); | |
| 219 | |
| 220 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 221 NativeFileUtil::Truncate(from_file, 1020)); | |
| 222 | |
| 223 EXPECT_TRUE(FileExists(from_file)); | |
| 224 EXPECT_EQ(1020, GetSize(from_file)); | |
| 225 | |
| 226 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 227 NativeFileUtil::CopyOrMoveFile(from_file, to_file1, true)); | |
| 228 | |
| 229 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 230 NativeFileUtil::CopyOrMoveFile(from_file, to_file2, true)); | |
| 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::PLATFORM_FILE_OK, | |
| 241 NativeFileUtil::CreateDirectory(dir, false, false)); | |
| 242 ASSERT_TRUE(file_util::DirectoryExists(dir)); | |
| 243 base::FilePath to_dir_file = dir.AppendASCII("file"); | |
| 244 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 245 NativeFileUtil::CopyOrMoveFile(from_file, to_dir_file, true)); | |
| 246 EXPECT_TRUE(FileExists(to_dir_file)); | |
| 247 EXPECT_EQ(1020, GetSize(to_dir_file)); | |
| 248 | |
| 249 // Following tests are error checking. | |
| 250 // Source doesn't exist. | |
| 251 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, | |
| 252 NativeFileUtil::CopyOrMoveFile(Path("nonexists"), Path("file"), | |
| 253 true)); | |
| 254 | |
| 255 // Source is not a file. | |
| 256 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_FILE, | |
| 257 NativeFileUtil::CopyOrMoveFile(dir, Path("file"), true)); | |
| 258 // Destination is not a file. | |
| 259 EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, | |
| 260 NativeFileUtil::CopyOrMoveFile(from_file, dir, true)); | |
| 261 // Destination's parent doesn't exist. | |
| 262 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, | |
| 263 NativeFileUtil::CopyOrMoveFile(from_file, | |
| 264 Path("nodir").AppendASCII("file"), | |
| 265 true)); | |
| 266 // Destination's parent is a file. | |
| 267 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, | |
| 268 NativeFileUtil::CopyOrMoveFile(from_file, | |
| 269 Path("tofile1").AppendASCII("file"), | |
| 270 true)); | |
| 271 } | |
| 272 | |
| 273 TEST_F(NativeFileUtilTest, MoveFile) { | |
| 274 base::FilePath from_file = Path("fromfile"); | |
| 275 base::FilePath to_file = Path("tofile"); | |
| 276 bool created = false; | |
| 277 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 278 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 279 ASSERT_TRUE(created); | |
| 280 | |
| 281 ASSERT_EQ(base::PLATFORM_FILE_OK, NativeFileUtil::Truncate(from_file, 1020)); | |
| 282 | |
| 283 EXPECT_TRUE(FileExists(from_file)); | |
| 284 EXPECT_EQ(1020, GetSize(from_file)); | |
| 285 | |
| 286 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 287 NativeFileUtil::CopyOrMoveFile(from_file, to_file, false)); | |
| 288 | |
| 289 EXPECT_FALSE(FileExists(from_file)); | |
| 290 EXPECT_TRUE(FileExists(to_file)); | |
| 291 EXPECT_EQ(1020, GetSize(to_file)); | |
| 292 | |
| 293 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 294 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 295 ASSERT_TRUE(FileExists(from_file)); | |
| 296 ASSERT_EQ(base::PLATFORM_FILE_OK, NativeFileUtil::Truncate(from_file, 1020)); | |
| 297 | |
| 298 base::FilePath dir = Path("dir"); | |
| 299 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 300 NativeFileUtil::CreateDirectory(dir, false, false)); | |
| 301 ASSERT_TRUE(file_util::DirectoryExists(dir)); | |
| 302 base::FilePath to_dir_file = dir.AppendASCII("file"); | |
| 303 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 304 NativeFileUtil::CopyOrMoveFile(from_file, to_dir_file, false)); | |
| 305 EXPECT_FALSE(FileExists(from_file)); | |
| 306 EXPECT_TRUE(FileExists(to_dir_file)); | |
| 307 EXPECT_EQ(1020, GetSize(to_dir_file)); | |
| 308 | |
| 309 // Following is error checking. | |
| 310 // Source doesn't exist. | |
| 311 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, | |
| 312 NativeFileUtil::CopyOrMoveFile(Path("nonexists"), Path("file"), | |
| 313 false)); | |
| 314 | |
| 315 // Source is not a file. | |
| 316 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_A_FILE, | |
| 317 NativeFileUtil::CopyOrMoveFile(dir, Path("file"), false)); | |
| 318 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 319 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 320 ASSERT_TRUE(FileExists(from_file)); | |
| 321 // Destination is not a file. | |
| 322 EXPECT_EQ(base::PLATFORM_FILE_ERROR_INVALID_OPERATION, | |
| 323 NativeFileUtil::CopyOrMoveFile(from_file, dir, false)); | |
| 324 | |
| 325 ASSERT_EQ(base::PLATFORM_FILE_OK, | |
| 326 NativeFileUtil::EnsureFileExists(from_file, &created)); | |
| 327 ASSERT_TRUE(FileExists(from_file)); | |
| 328 // Destination's parent doesn't exist. | |
| 329 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, | |
| 330 NativeFileUtil::CopyOrMoveFile(from_file, | |
| 331 Path("nodir").AppendASCII("file"), | |
| 332 false)); | |
| 333 // Destination's parent is a file. | |
| 334 EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, | |
| 335 NativeFileUtil::CopyOrMoveFile(from_file, | |
| 336 Path("tofile1").AppendASCII("file"), | |
| 337 false)); | |
| 338 } | |
| 339 | |
| 340 } // namespace fileapi | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 14895013:
Move webkit/fileapi/file_system_mount_point_provider.h to webkit/browser/fileapi (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src