| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "base/file_util_proxy.h" | |
| 6 | |
| 7 #include <map> | |
| 8 | |
| 9 #include "base/bind.h" | |
| 10 #include "base/files/scoped_temp_dir.h" | |
| 11 #include "base/logging.h" | |
| 12 #include "base/memory/weak_ptr.h" | |
| 13 #include "base/message_loop.h" | |
| 14 #include "base/platform_file.h" | |
| 15 #include "base/threading/thread.h" | |
| 16 #include "testing/gtest/include/gtest/gtest.h" | |
| 17 | |
| 18 namespace base { | |
| 19 | |
| 20 class FileUtilProxyTest : public testing::Test { | |
| 21 public: | |
| 22 FileUtilProxyTest() | |
| 23 : message_loop_(MessageLoop::TYPE_IO), | |
| 24 file_thread_("FileUtilProxyTestFileThread"), | |
| 25 error_(PLATFORM_FILE_OK), | |
| 26 created_(false), | |
| 27 file_(kInvalidPlatformFileValue), | |
| 28 bytes_written_(-1), | |
| 29 weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {} | |
| 30 | |
| 31 virtual void SetUp() OVERRIDE { | |
| 32 ASSERT_TRUE(dir_.CreateUniqueTempDir()); | |
| 33 ASSERT_TRUE(file_thread_.Start()); | |
| 34 } | |
| 35 | |
| 36 virtual void TearDown() OVERRIDE { | |
| 37 if (file_ != kInvalidPlatformFileValue) | |
| 38 ClosePlatformFile(file_); | |
| 39 } | |
| 40 | |
| 41 void DidFinish(PlatformFileError error) { | |
| 42 error_ = error; | |
| 43 MessageLoop::current()->QuitWhenIdle(); | |
| 44 } | |
| 45 | |
| 46 void DidCreateOrOpen(PlatformFileError error, | |
| 47 PassPlatformFile file, | |
| 48 bool created) { | |
| 49 error_ = error; | |
| 50 file_ = file.ReleaseValue(); | |
| 51 created_ = created; | |
| 52 MessageLoop::current()->QuitWhenIdle(); | |
| 53 } | |
| 54 | |
| 55 void DidCreateTemporary(PlatformFileError error, | |
| 56 PassPlatformFile file, | |
| 57 const FilePath& path) { | |
| 58 error_ = error; | |
| 59 file_ = file.ReleaseValue(); | |
| 60 path_ = path; | |
| 61 MessageLoop::current()->QuitWhenIdle(); | |
| 62 } | |
| 63 | |
| 64 void DidGetFileInfo(PlatformFileError error, | |
| 65 const PlatformFileInfo& file_info) { | |
| 66 error_ = error; | |
| 67 file_info_ = file_info; | |
| 68 MessageLoop::current()->QuitWhenIdle(); | |
| 69 } | |
| 70 | |
| 71 void DidRead(PlatformFileError error, | |
| 72 const char* data, | |
| 73 int bytes_read) { | |
| 74 error_ = error; | |
| 75 buffer_.resize(bytes_read); | |
| 76 memcpy(&buffer_[0], data, bytes_read); | |
| 77 MessageLoop::current()->QuitWhenIdle(); | |
| 78 } | |
| 79 | |
| 80 void DidWrite(PlatformFileError error, | |
| 81 int bytes_written) { | |
| 82 error_ = error; | |
| 83 bytes_written_ = bytes_written; | |
| 84 MessageLoop::current()->QuitWhenIdle(); | |
| 85 } | |
| 86 | |
| 87 protected: | |
| 88 PlatformFile GetTestPlatformFile(int flags) { | |
| 89 if (file_ != kInvalidPlatformFileValue) | |
| 90 return file_; | |
| 91 bool created; | |
| 92 PlatformFileError error; | |
| 93 file_ = CreatePlatformFile(test_path(), flags, &created, &error); | |
| 94 EXPECT_EQ(PLATFORM_FILE_OK, error); | |
| 95 EXPECT_NE(kInvalidPlatformFileValue, file_); | |
| 96 return file_; | |
| 97 } | |
| 98 | |
| 99 TaskRunner* file_task_runner() const { | |
| 100 return file_thread_.message_loop_proxy().get(); | |
| 101 } | |
| 102 const FilePath& test_dir_path() const { return dir_.path(); } | |
| 103 const FilePath test_path() const { return dir_.path().AppendASCII("test"); } | |
| 104 | |
| 105 MessageLoop message_loop_; | |
| 106 Thread file_thread_; | |
| 107 | |
| 108 ScopedTempDir dir_; | |
| 109 PlatformFileError error_; | |
| 110 bool created_; | |
| 111 PlatformFile file_; | |
| 112 FilePath path_; | |
| 113 PlatformFileInfo file_info_; | |
| 114 std::vector<char> buffer_; | |
| 115 int bytes_written_; | |
| 116 WeakPtrFactory<FileUtilProxyTest> weak_factory_; | |
| 117 }; | |
| 118 | |
| 119 TEST_F(FileUtilProxyTest, CreateOrOpen_Create) { | |
| 120 FileUtilProxy::CreateOrOpen( | |
| 121 file_task_runner(), | |
| 122 test_path(), | |
| 123 PLATFORM_FILE_CREATE | PLATFORM_FILE_READ, | |
| 124 Bind(&FileUtilProxyTest::DidCreateOrOpen, weak_factory_.GetWeakPtr())); | |
| 125 MessageLoop::current()->Run(); | |
| 126 | |
| 127 EXPECT_EQ(PLATFORM_FILE_OK, error_); | |
| 128 EXPECT_TRUE(created_); | |
| 129 EXPECT_NE(kInvalidPlatformFileValue, file_); | |
| 130 EXPECT_TRUE(file_util::PathExists(test_path())); | |
| 131 } | |
| 132 | |
| 133 TEST_F(FileUtilProxyTest, CreateOrOpen_Open) { | |
| 134 // Creates a file. | |
| 135 file_util::WriteFile(test_path(), NULL, 0); | |
| 136 ASSERT_TRUE(file_util::PathExists(test_path())); | |
| 137 | |
| 138 // Opens the created file. | |
| 139 FileUtilProxy::CreateOrOpen( | |
| 140 file_task_runner(), | |
| 141 test_path(), | |
| 142 PLATFORM_FILE_OPEN | PLATFORM_FILE_READ, | |
| 143 Bind(&FileUtilProxyTest::DidCreateOrOpen, weak_factory_.GetWeakPtr())); | |
| 144 MessageLoop::current()->Run(); | |
| 145 | |
| 146 EXPECT_EQ(PLATFORM_FILE_OK, error_); | |
| 147 EXPECT_FALSE(created_); | |
| 148 EXPECT_NE(kInvalidPlatformFileValue, file_); | |
| 149 } | |
| 150 | |
| 151 TEST_F(FileUtilProxyTest, CreateOrOpen_OpenNonExistent) { | |
| 152 FileUtilProxy::CreateOrOpen( | |
| 153 file_task_runner(), | |
| 154 test_path(), | |
| 155 PLATFORM_FILE_OPEN | PLATFORM_FILE_READ, | |
| 156 Bind(&FileUtilProxyTest::DidCreateOrOpen, weak_factory_.GetWeakPtr())); | |
| 157 MessageLoop::current()->Run(); | |
| 158 EXPECT_EQ(PLATFORM_FILE_ERROR_NOT_FOUND, error_); | |
| 159 EXPECT_FALSE(created_); | |
| 160 EXPECT_EQ(kInvalidPlatformFileValue, file_); | |
| 161 EXPECT_FALSE(file_util::PathExists(test_path())); | |
| 162 } | |
| 163 | |
| 164 TEST_F(FileUtilProxyTest, Close) { | |
| 165 // Creates a file. | |
| 166 PlatformFile file = GetTestPlatformFile( | |
| 167 PLATFORM_FILE_CREATE | PLATFORM_FILE_WRITE); | |
| 168 | |
| 169 #if defined(OS_WIN) | |
| 170 // This fails on Windows if the file is not closed. | |
| 171 EXPECT_FALSE(file_util::Move(test_path(), | |
| 172 test_dir_path().AppendASCII("new"))); | |
| 173 #endif | |
| 174 | |
| 175 FileUtilProxy::Close( | |
| 176 file_task_runner(), | |
| 177 file, | |
| 178 Bind(&FileUtilProxyTest::DidFinish, weak_factory_.GetWeakPtr())); | |
| 179 MessageLoop::current()->Run(); | |
| 180 EXPECT_EQ(PLATFORM_FILE_OK, error_); | |
| 181 | |
| 182 // Now it should pass on all platforms. | |
| 183 EXPECT_TRUE(file_util::Move(test_path(), test_dir_path().AppendASCII("new"))); | |
| 184 } | |
| 185 | |
| 186 TEST_F(FileUtilProxyTest, CreateTemporary) { | |
| 187 FileUtilProxy::CreateTemporary( | |
| 188 file_task_runner(), 0 /* additional_file_flags */, | |
| 189 Bind(&FileUtilProxyTest::DidCreateTemporary, weak_factory_.GetWeakPtr())); | |
| 190 MessageLoop::current()->Run(); | |
| 191 EXPECT_EQ(PLATFORM_FILE_OK, error_); | |
| 192 EXPECT_TRUE(file_util::PathExists(path_)); | |
| 193 EXPECT_NE(kInvalidPlatformFileValue, file_); | |
| 194 | |
| 195 // The file should be writable. | |
| 196 #if defined(OS_WIN) | |
| 197 HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); | |
| 198 OVERLAPPED overlapped = {0}; | |
| 199 overlapped.hEvent = hEvent; | |
| 200 DWORD bytes_written; | |
| 201 if (!::WriteFile(file_, "test", 4, &bytes_written, &overlapped)) { | |
| 202 // Temporary file is created with ASYNC flag, so WriteFile may return 0 | |
| 203 // with ERROR_IO_PENDING. | |
| 204 EXPECT_EQ(ERROR_IO_PENDING, GetLastError()); | |
| 205 GetOverlappedResult(file_, &overlapped, &bytes_written, TRUE); | |
| 206 } | |
| 207 EXPECT_EQ(4, bytes_written); | |
| 208 #else | |
| 209 // On POSIX ASYNC flag does not affect synchronous read/write behavior. | |
| 210 EXPECT_EQ(4, WritePlatformFile(file_, 0, "test", 4)); | |
| 211 #endif | |
| 212 EXPECT_TRUE(ClosePlatformFile(file_)); | |
| 213 file_ = kInvalidPlatformFileValue; | |
| 214 | |
| 215 // Make sure the written data can be read from the returned path. | |
| 216 std::string data; | |
| 217 EXPECT_TRUE(file_util::ReadFileToString(path_, &data)); | |
| 218 EXPECT_EQ("test", data); | |
| 219 | |
| 220 // Make sure we can & do delete the created file to prevent leaks on the bots. | |
| 221 EXPECT_TRUE(file_util::Delete(path_, false)); | |
| 222 } | |
| 223 | |
| 224 TEST_F(FileUtilProxyTest, GetFileInfo_File) { | |
| 225 // Setup. | |
| 226 ASSERT_EQ(4, file_util::WriteFile(test_path(), "test", 4)); | |
| 227 PlatformFileInfo expected_info; | |
| 228 file_util::GetFileInfo(test_path(), &expected_info); | |
| 229 | |
| 230 // Run. | |
| 231 FileUtilProxy::GetFileInfo( | |
| 232 file_task_runner(), | |
| 233 test_path(), | |
| 234 Bind(&FileUtilProxyTest::DidGetFileInfo, weak_factory_.GetWeakPtr())); | |
| 235 MessageLoop::current()->Run(); | |
| 236 | |
| 237 // Verify. | |
| 238 EXPECT_EQ(PLATFORM_FILE_OK, error_); | |
| 239 EXPECT_EQ(expected_info.size, file_info_.size); | |
| 240 EXPECT_EQ(expected_info.is_directory, file_info_.is_directory); | |
| 241 EXPECT_EQ(expected_info.is_symbolic_link, file_info_.is_symbolic_link); | |
| 242 EXPECT_EQ(expected_info.last_modified, file_info_.last_modified); | |
| 243 EXPECT_EQ(expected_info.last_accessed, file_info_.last_accessed); | |
| 244 EXPECT_EQ(expected_info.creation_time, file_info_.creation_time); | |
| 245 } | |
| 246 | |
| 247 TEST_F(FileUtilProxyTest, GetFileInfo_Directory) { | |
| 248 // Setup. | |
| 249 ASSERT_TRUE(file_util::CreateDirectory(test_path())); | |
| 250 PlatformFileInfo expected_info; | |
| 251 file_util::GetFileInfo(test_path(), &expected_info); | |
| 252 | |
| 253 // Run. | |
| 254 FileUtilProxy::GetFileInfo( | |
| 255 file_task_runner(), | |
| 256 test_path(), | |
| 257 Bind(&FileUtilProxyTest::DidGetFileInfo, weak_factory_.GetWeakPtr())); | |
| 258 MessageLoop::current()->Run(); | |
| 259 | |
| 260 // Verify. | |
| 261 EXPECT_EQ(PLATFORM_FILE_OK, error_); | |
| 262 EXPECT_EQ(expected_info.size, file_info_.size); | |
| 263 EXPECT_EQ(expected_info.is_directory, file_info_.is_directory); | |
| 264 EXPECT_EQ(expected_info.is_symbolic_link, file_info_.is_symbolic_link); | |
| 265 EXPECT_EQ(expected_info.last_modified, file_info_.last_modified); | |
| 266 EXPECT_EQ(expected_info.last_accessed, file_info_.last_accessed); | |
| 267 EXPECT_EQ(expected_info.creation_time, file_info_.creation_time); | |
| 268 } | |
| 269 | |
| 270 TEST_F(FileUtilProxyTest, Read) { | |
| 271 // Setup. | |
| 272 const char expected_data[] = "bleh"; | |
| 273 int expected_bytes = arraysize(expected_data); | |
| 274 ASSERT_EQ(expected_bytes, | |
| 275 file_util::WriteFile(test_path(), expected_data, expected_bytes)); | |
| 276 | |
| 277 // Run. | |
| 278 FileUtilProxy::Read( | |
| 279 file_task_runner(), | |
| 280 GetTestPlatformFile(PLATFORM_FILE_OPEN | PLATFORM_FILE_READ), | |
| 281 0, // offset | |
| 282 128, | |
| 283 Bind(&FileUtilProxyTest::DidRead, weak_factory_.GetWeakPtr())); | |
| 284 MessageLoop::current()->Run(); | |
| 285 | |
| 286 // Verify. | |
| 287 EXPECT_EQ(PLATFORM_FILE_OK, error_); | |
| 288 EXPECT_EQ(expected_bytes, static_cast<int>(buffer_.size())); | |
| 289 for (size_t i = 0; i < buffer_.size(); ++i) { | |
| 290 EXPECT_EQ(expected_data[i], buffer_[i]); | |
| 291 } | |
| 292 } | |
| 293 | |
| 294 TEST_F(FileUtilProxyTest, WriteAndFlush) { | |
| 295 const char data[] = "foo!"; | |
| 296 int data_bytes = ARRAYSIZE_UNSAFE(data); | |
| 297 PlatformFile file = GetTestPlatformFile( | |
| 298 PLATFORM_FILE_CREATE | PLATFORM_FILE_WRITE); | |
| 299 | |
| 300 FileUtilProxy::Write( | |
| 301 file_task_runner(), | |
| 302 file, | |
| 303 0, // offset | |
| 304 data, | |
| 305 data_bytes, | |
| 306 Bind(&FileUtilProxyTest::DidWrite, weak_factory_.GetWeakPtr())); | |
| 307 MessageLoop::current()->Run(); | |
| 308 EXPECT_EQ(PLATFORM_FILE_OK, error_); | |
| 309 EXPECT_EQ(data_bytes, bytes_written_); | |
| 310 | |
| 311 // Flush the written data. (So that the following read should always | |
| 312 // succeed. On some platforms it may work with or without this flush.) | |
| 313 FileUtilProxy::Flush( | |
| 314 file_task_runner(), | |
| 315 file, | |
| 316 Bind(&FileUtilProxyTest::DidFinish, weak_factory_.GetWeakPtr())); | |
| 317 MessageLoop::current()->Run(); | |
| 318 EXPECT_EQ(PLATFORM_FILE_OK, error_); | |
| 319 | |
| 320 // Verify the written data. | |
| 321 char buffer[10]; | |
| 322 EXPECT_EQ(data_bytes, file_util::ReadFile(test_path(), buffer, data_bytes)); | |
| 323 for (int i = 0; i < data_bytes; ++i) { | |
| 324 EXPECT_EQ(data[i], buffer[i]); | |
| 325 } | |
| 326 } | |
| 327 | |
| 328 TEST_F(FileUtilProxyTest, Touch) { | |
| 329 Time last_accessed_time = Time::Now() - TimeDelta::FromDays(12345); | |
| 330 Time last_modified_time = Time::Now() - TimeDelta::FromHours(98765); | |
| 331 | |
| 332 FileUtilProxy::Touch( | |
| 333 file_task_runner(), | |
| 334 GetTestPlatformFile(PLATFORM_FILE_CREATE | | |
| 335 PLATFORM_FILE_WRITE | | |
| 336 PLATFORM_FILE_WRITE_ATTRIBUTES), | |
| 337 last_accessed_time, | |
| 338 last_modified_time, | |
| 339 Bind(&FileUtilProxyTest::DidFinish, weak_factory_.GetWeakPtr())); | |
| 340 MessageLoop::current()->Run(); | |
| 341 EXPECT_EQ(PLATFORM_FILE_OK, error_); | |
| 342 | |
| 343 PlatformFileInfo info; | |
| 344 file_util::GetFileInfo(test_path(), &info); | |
| 345 | |
| 346 // The returned values may only have the seconds precision, so we cast | |
| 347 // the double values to int here. | |
| 348 EXPECT_EQ(static_cast<int>(last_modified_time.ToDoubleT()), | |
| 349 static_cast<int>(info.last_modified.ToDoubleT())); | |
| 350 EXPECT_EQ(static_cast<int>(last_accessed_time.ToDoubleT()), | |
| 351 static_cast<int>(info.last_accessed.ToDoubleT())); | |
| 352 } | |
| 353 | |
| 354 TEST_F(FileUtilProxyTest, Truncate_Shrink) { | |
| 355 // Setup. | |
| 356 const char kTestData[] = "0123456789"; | |
| 357 ASSERT_EQ(10, file_util::WriteFile(test_path(), kTestData, 10)); | |
| 358 PlatformFileInfo info; | |
| 359 file_util::GetFileInfo(test_path(), &info); | |
| 360 ASSERT_EQ(10, info.size); | |
| 361 | |
| 362 // Run. | |
| 363 FileUtilProxy::Truncate( | |
| 364 file_task_runner(), | |
| 365 GetTestPlatformFile(PLATFORM_FILE_OPEN | PLATFORM_FILE_WRITE), | |
| 366 7, | |
| 367 Bind(&FileUtilProxyTest::DidFinish, weak_factory_.GetWeakPtr())); | |
| 368 MessageLoop::current()->Run(); | |
| 369 | |
| 370 // Verify. | |
| 371 file_util::GetFileInfo(test_path(), &info); | |
| 372 ASSERT_EQ(7, info.size); | |
| 373 | |
| 374 char buffer[7]; | |
| 375 EXPECT_EQ(7, file_util::ReadFile(test_path(), buffer, 7)); | |
| 376 int i = 0; | |
| 377 for (; i < 7; ++i) | |
| 378 EXPECT_EQ(kTestData[i], buffer[i]); | |
| 379 } | |
| 380 | |
| 381 TEST_F(FileUtilProxyTest, Truncate_Expand) { | |
| 382 // Setup. | |
| 383 const char kTestData[] = "9876543210"; | |
| 384 ASSERT_EQ(10, file_util::WriteFile(test_path(), kTestData, 10)); | |
| 385 PlatformFileInfo info; | |
| 386 file_util::GetFileInfo(test_path(), &info); | |
| 387 ASSERT_EQ(10, info.size); | |
| 388 | |
| 389 // Run. | |
| 390 FileUtilProxy::Truncate( | |
| 391 file_task_runner(), | |
| 392 GetTestPlatformFile(PLATFORM_FILE_OPEN | PLATFORM_FILE_WRITE), | |
| 393 53, | |
| 394 Bind(&FileUtilProxyTest::DidFinish, weak_factory_.GetWeakPtr())); | |
| 395 MessageLoop::current()->Run(); | |
| 396 | |
| 397 // Verify. | |
| 398 file_util::GetFileInfo(test_path(), &info); | |
| 399 ASSERT_EQ(53, info.size); | |
| 400 | |
| 401 char buffer[53]; | |
| 402 EXPECT_EQ(53, file_util::ReadFile(test_path(), buffer, 53)); | |
| 403 int i = 0; | |
| 404 for (; i < 10; ++i) | |
| 405 EXPECT_EQ(kTestData[i], buffer[i]); | |
| 406 for (; i < 53; ++i) | |
| 407 EXPECT_EQ(0, buffer[i]); | |
| 408 } | |
| 409 | |
| 410 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 12035111:
Move file_util_proxy to base/files. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src