base/files/file_util_proxy_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/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