base/files/file_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.h"
   6 #include "base/files/file_util.h"
   7 #include "base/files/scoped_temp_dir.h"
   8 #include "base/time/time.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 using base::File;
  12 using base::FilePath;
  13
  14 TEST(FileTest, Create) {
  15   base::ScopedTempDir temp_dir;
  16   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  17   FilePath file_path = temp_dir.path().AppendASCII("create_file_1");
  18
  19   {
  20     // Don't create a File at all.
  21     File file;
  22     EXPECT_FALSE(file.IsValid());
  23     EXPECT_EQ(base::File::FILE_ERROR_FAILED, file.error_details());
  24
  25     File file2(base::File::FILE_ERROR_TOO_MANY_OPENED);
  26     EXPECT_FALSE(file2.IsValid());
  27     EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, file2.error_details());
  28   }
  29
  30   {
  31     // Open a file that doesn't exist.
  32     File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
  33     EXPECT_FALSE(file.IsValid());
  34     EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, file.error_details());
  35   }
  36
  37   {
  38     // Open or create a file.
  39     File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ);
  40     EXPECT_TRUE(file.IsValid());
  41     EXPECT_TRUE(file.created());
  42     EXPECT_EQ(base::File::FILE_OK, file.error_details());
  43   }
  44
  45   {
  46     // Open an existing file.
  47     File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
  48     EXPECT_TRUE(file.IsValid());
  49     EXPECT_FALSE(file.created());
  50     EXPECT_EQ(base::File::FILE_OK, file.error_details());
  51
  52     // This time verify closing the file.
  53     file.Close();
  54     EXPECT_FALSE(file.IsValid());
  55   }
  56
  57   {
  58     // Open an existing file through Initialize
  59     File file;
  60     file.Initialize(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
  61     EXPECT_TRUE(file.IsValid());
  62     EXPECT_FALSE(file.created());
  63     EXPECT_EQ(base::File::FILE_OK, file.error_details());
  64
  65     // This time verify closing the file.
  66     file.Close();
  67     EXPECT_FALSE(file.IsValid());
  68   }
  69
  70   {
  71     // Create a file that exists.
  72     File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_READ);
  73     EXPECT_FALSE(file.IsValid());
  74     EXPECT_FALSE(file.created());
  75     EXPECT_EQ(base::File::FILE_ERROR_EXISTS, file.error_details());
  76   }
  77
  78   {
  79     // Create or overwrite a file.
  80     File file(file_path,
  81               base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
  82     EXPECT_TRUE(file.IsValid());
  83     EXPECT_TRUE(file.created());
  84     EXPECT_EQ(base::File::FILE_OK, file.error_details());
  85   }
  86
  87   {
  88     // Create a delete-on-close file.
  89     file_path = temp_dir.path().AppendASCII("create_file_2");
  90     File file(file_path,
  91               base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ |
  92                   base::File::FLAG_DELETE_ON_CLOSE);
  93     EXPECT_TRUE(file.IsValid());
  94     EXPECT_TRUE(file.created());
  95     EXPECT_EQ(base::File::FILE_OK, file.error_details());
  96   }
  97
  98   EXPECT_FALSE(base::PathExists(file_path));
  99 }
 100
 101 TEST(FileTest, Async) {
 102   base::ScopedTempDir temp_dir;
 103   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 104   FilePath file_path = temp_dir.path().AppendASCII("create_file");
 105
 106   {
 107     File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_ASYNC);
 108     EXPECT_TRUE(file.IsValid());
 109     EXPECT_TRUE(file.async());
 110   }
 111
 112   {
 113     File file(file_path, base::File::FLAG_OPEN_ALWAYS);
 114     EXPECT_TRUE(file.IsValid());
 115     EXPECT_FALSE(file.async());
 116   }
 117 }
 118
 119 TEST(FileTest, DeleteOpenFile) {
 120   base::ScopedTempDir temp_dir;
 121   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 122   FilePath file_path = temp_dir.path().AppendASCII("create_file_1");
 123
 124   // Create a file.
 125   File file(file_path,
 126             base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ |
 127                 base::File::FLAG_SHARE_DELETE);
 128   EXPECT_TRUE(file.IsValid());
 129   EXPECT_TRUE(file.created());
 130   EXPECT_EQ(base::File::FILE_OK, file.error_details());
 131
 132   // Open an existing file and mark it as delete on close.
 133   File same_file(file_path,
 134                  base::File::FLAG_OPEN | base::File::FLAG_DELETE_ON_CLOSE |
 135                      base::File::FLAG_READ);
 136   EXPECT_TRUE(file.IsValid());
 137   EXPECT_FALSE(same_file.created());
 138   EXPECT_EQ(base::File::FILE_OK, same_file.error_details());
 139
 140   // Close both handles and check that the file is gone.
 141   file.Close();
 142   same_file.Close();
 143   EXPECT_FALSE(base::PathExists(file_path));
 144 }
 145
 146 TEST(FileTest, ReadWrite) {
 147   base::ScopedTempDir temp_dir;
 148   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 149   FilePath file_path = temp_dir.path().AppendASCII("read_write_file");
 150   File file(file_path,
 151             base::File::FLAG_CREATE | base::File::FLAG_READ |
 152                 base::File::FLAG_WRITE);
 153   ASSERT_TRUE(file.IsValid());
 154
 155   char data_to_write[] = "test";
 156   const int kTestDataSize = 4;
 157
 158   // Write 0 bytes to the file.
 159   int bytes_written = file.Write(0, data_to_write, 0);
 160   EXPECT_EQ(0, bytes_written);
 161
 162   // Write "test" to the file.
 163   bytes_written = file.Write(0, data_to_write, kTestDataSize);
 164   EXPECT_EQ(kTestDataSize, bytes_written);
 165
 166   // Read from EOF.
 167   char data_read_1[32];
 168   int bytes_read = file.Read(kTestDataSize, data_read_1, kTestDataSize);
 169   EXPECT_EQ(0, bytes_read);
 170
 171   // Read from somewhere in the middle of the file.
 172   const int kPartialReadOffset = 1;
 173   bytes_read = file.Read(kPartialReadOffset, data_read_1, kTestDataSize);
 174   EXPECT_EQ(kTestDataSize - kPartialReadOffset, bytes_read);
 175   for (int i = 0; i < bytes_read; i++)
 176     EXPECT_EQ(data_to_write[i + kPartialReadOffset], data_read_1[i]);
 177
 178   // Read 0 bytes.
 179   bytes_read = file.Read(0, data_read_1, 0);
 180   EXPECT_EQ(0, bytes_read);
 181
 182   // Read the entire file.
 183   bytes_read = file.Read(0, data_read_1, kTestDataSize);
 184   EXPECT_EQ(kTestDataSize, bytes_read);
 185   for (int i = 0; i < bytes_read; i++)
 186     EXPECT_EQ(data_to_write[i], data_read_1[i]);
 187
 188   // Read again, but using the trivial native wrapper.
 189   bytes_read = file.ReadNoBestEffort(0, data_read_1, kTestDataSize);
 190   EXPECT_LE(bytes_read, kTestDataSize);
 191   for (int i = 0; i < bytes_read; i++)
 192     EXPECT_EQ(data_to_write[i], data_read_1[i]);
 193
 194   // Write past the end of the file.
 195   const int kOffsetBeyondEndOfFile = 10;
 196   const int kPartialWriteLength = 2;
 197   bytes_written = file.Write(kOffsetBeyondEndOfFile,
 198                              data_to_write, kPartialWriteLength);
 199   EXPECT_EQ(kPartialWriteLength, bytes_written);
 200
 201   // Make sure the file was extended.
 202   int64 file_size = 0;
 203   EXPECT_TRUE(GetFileSize(file_path, &file_size));
 204   EXPECT_EQ(kOffsetBeyondEndOfFile + kPartialWriteLength, file_size);
 205
 206   // Make sure the file was zero-padded.
 207   char data_read_2[32];
 208   bytes_read = file.Read(0, data_read_2, static_cast<int>(file_size));
 209   EXPECT_EQ(file_size, bytes_read);
 210   for (int i = 0; i < kTestDataSize; i++)
 211     EXPECT_EQ(data_to_write[i], data_read_2[i]);
 212   for (int i = kTestDataSize; i < kOffsetBeyondEndOfFile; i++)
 213     EXPECT_EQ(0, data_read_2[i]);
 214   for (int i = kOffsetBeyondEndOfFile; i < file_size; i++)
 215     EXPECT_EQ(data_to_write[i - kOffsetBeyondEndOfFile], data_read_2[i]);
 216 }
 217
 218 TEST(FileTest, Append) {
 219   base::ScopedTempDir temp_dir;
 220   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 221   FilePath file_path = temp_dir.path().AppendASCII("append_file");
 222   File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_APPEND);
 223   ASSERT_TRUE(file.IsValid());
 224
 225   char data_to_write[] = "test";
 226   const int kTestDataSize = 4;
 227
 228   // Write 0 bytes to the file.
 229   int bytes_written = file.Write(0, data_to_write, 0);
 230   EXPECT_EQ(0, bytes_written);
 231
 232   // Write "test" to the file.
 233   bytes_written = file.Write(0, data_to_write, kTestDataSize);
 234   EXPECT_EQ(kTestDataSize, bytes_written);
 235
 236   file.Close();
 237   File file2(file_path,
 238              base::File::FLAG_OPEN | base::File::FLAG_READ |
 239                  base::File::FLAG_APPEND);
 240   ASSERT_TRUE(file2.IsValid());
 241
 242   // Test passing the file around.
 243   file = file2.Pass();
 244   EXPECT_FALSE(file2.IsValid());
 245   ASSERT_TRUE(file.IsValid());
 246
 247   char append_data_to_write[] = "78";
 248   const int kAppendDataSize = 2;
 249
 250   // Append "78" to the file.
 251   bytes_written = file.Write(0, append_data_to_write, kAppendDataSize);
 252   EXPECT_EQ(kAppendDataSize, bytes_written);
 253
 254   // Read the entire file.
 255   char data_read_1[32];
 256   int bytes_read = file.Read(0, data_read_1,
 257                              kTestDataSize + kAppendDataSize);
 258   EXPECT_EQ(kTestDataSize + kAppendDataSize, bytes_read);
 259   for (int i = 0; i < kTestDataSize; i++)
 260     EXPECT_EQ(data_to_write[i], data_read_1[i]);
 261   for (int i = 0; i < kAppendDataSize; i++)
 262     EXPECT_EQ(append_data_to_write[i], data_read_1[kTestDataSize + i]);
 263 }
 264
 265
 266 TEST(FileTest, Length) {
 267   base::ScopedTempDir temp_dir;
 268   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 269   FilePath file_path = temp_dir.path().AppendASCII("truncate_file");
 270   File file(file_path,
 271             base::File::FLAG_CREATE | base::File::FLAG_READ |
 272                 base::File::FLAG_WRITE);
 273   ASSERT_TRUE(file.IsValid());
 274   EXPECT_EQ(0, file.GetLength());
 275
 276   // Write "test" to the file.
 277   char data_to_write[] = "test";
 278   int kTestDataSize = 4;
 279   int bytes_written = file.Write(0, data_to_write, kTestDataSize);
 280   EXPECT_EQ(kTestDataSize, bytes_written);
 281
 282   // Extend the file.
 283   const int kExtendedFileLength = 10;
 284   int64 file_size = 0;
 285   EXPECT_TRUE(file.SetLength(kExtendedFileLength));
 286   EXPECT_EQ(kExtendedFileLength, file.GetLength());
 287   EXPECT_TRUE(GetFileSize(file_path, &file_size));
 288   EXPECT_EQ(kExtendedFileLength, file_size);
 289
 290   // Make sure the file was zero-padded.
 291   char data_read[32];
 292   int bytes_read = file.Read(0, data_read, static_cast<int>(file_size));
 293   EXPECT_EQ(file_size, bytes_read);
 294   for (int i = 0; i < kTestDataSize; i++)
 295     EXPECT_EQ(data_to_write[i], data_read[i]);
 296   for (int i = kTestDataSize; i < file_size; i++)
 297     EXPECT_EQ(0, data_read[i]);
 298
 299   // Truncate the file.
 300   const int kTruncatedFileLength = 2;
 301   EXPECT_TRUE(file.SetLength(kTruncatedFileLength));
 302   EXPECT_EQ(kTruncatedFileLength, file.GetLength());
 303   EXPECT_TRUE(GetFileSize(file_path, &file_size));
 304   EXPECT_EQ(kTruncatedFileLength, file_size);
 305
 306   // Make sure the file was truncated.
 307   bytes_read = file.Read(0, data_read, kTestDataSize);
 308   EXPECT_EQ(file_size, bytes_read);
 309   for (int i = 0; i < file_size; i++)
 310     EXPECT_EQ(data_to_write[i], data_read[i]);
 311 }
 312
 313 // Flakily fails: http://crbug.com/86494
 314 #if defined(OS_ANDROID)
 315 TEST(FileTest, TouchGetInfo) {
 316 #else
 317 TEST(FileTest, DISABLED_TouchGetInfo) {
 318 #endif
 319   base::ScopedTempDir temp_dir;
 320   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 321   File file(temp_dir.path().AppendASCII("touch_get_info_file"),
 322             base::File::FLAG_CREATE | base::File::FLAG_WRITE |
 323                 base::File::FLAG_WRITE_ATTRIBUTES);
 324   ASSERT_TRUE(file.IsValid());
 325
 326   // Get info for a newly created file.
 327   base::File::Info info;
 328   EXPECT_TRUE(file.GetInfo(&info));
 329
 330   // Add 2 seconds to account for possible rounding errors on
 331   // filesystems that use a 1s or 2s timestamp granularity.
 332   base::Time now = base::Time::Now() + base::TimeDelta::FromSeconds(2);
 333   EXPECT_EQ(0, info.size);
 334   EXPECT_FALSE(info.is_directory);
 335   EXPECT_FALSE(info.is_symbolic_link);
 336   EXPECT_LE(info.last_accessed.ToInternalValue(), now.ToInternalValue());
 337   EXPECT_LE(info.last_modified.ToInternalValue(), now.ToInternalValue());
 338   EXPECT_LE(info.creation_time.ToInternalValue(), now.ToInternalValue());
 339   base::Time creation_time = info.creation_time;
 340
 341   // Write "test" to the file.
 342   char data[] = "test";
 343   const int kTestDataSize = 4;
 344   int bytes_written = file.Write(0, data, kTestDataSize);
 345   EXPECT_EQ(kTestDataSize, bytes_written);
 346
 347   // Change the last_accessed and last_modified dates.
 348   // It's best to add values that are multiples of 2 (in seconds)
 349   // to the current last_accessed and last_modified times, because
 350   // FATxx uses a 2s timestamp granularity.
 351   base::Time new_last_accessed =
 352       info.last_accessed + base::TimeDelta::FromSeconds(234);
 353   base::Time new_last_modified =
 354       info.last_modified + base::TimeDelta::FromMinutes(567);
 355
 356   EXPECT_TRUE(file.SetTimes(new_last_accessed, new_last_modified));
 357
 358   // Make sure the file info was updated accordingly.
 359   EXPECT_TRUE(file.GetInfo(&info));
 360   EXPECT_EQ(info.size, kTestDataSize);
 361   EXPECT_FALSE(info.is_directory);
 362   EXPECT_FALSE(info.is_symbolic_link);
 363
 364   // ext2/ext3 and HPS/HPS+ seem to have a timestamp granularity of 1s.
 365 #if defined(OS_POSIX)
 366   EXPECT_EQ(info.last_accessed.ToTimeVal().tv_sec,
 367             new_last_accessed.ToTimeVal().tv_sec);
 368   EXPECT_EQ(info.last_modified.ToTimeVal().tv_sec,
 369             new_last_modified.ToTimeVal().tv_sec);
 370 #else
 371   EXPECT_EQ(info.last_accessed.ToInternalValue(),
 372             new_last_accessed.ToInternalValue());
 373   EXPECT_EQ(info.last_modified.ToInternalValue(),
 374             new_last_modified.ToInternalValue());
 375 #endif
 376
 377   EXPECT_EQ(info.creation_time.ToInternalValue(),
 378             creation_time.ToInternalValue());
 379 }
 380
 381 TEST(FileTest, ReadAtCurrentPosition) {
 382   base::ScopedTempDir temp_dir;
 383   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 384   FilePath file_path = temp_dir.path().AppendASCII("read_at_current_position");
 385   File file(file_path,
 386             base::File::FLAG_CREATE | base::File::FLAG_READ |
 387                 base::File::FLAG_WRITE);
 388   EXPECT_TRUE(file.IsValid());
 389
 390   const char kData[] = "test";
 391   const int kDataSize = sizeof(kData) - 1;
 392   EXPECT_EQ(kDataSize, file.Write(0, kData, kDataSize));
 393
 394   EXPECT_EQ(0, file.Seek(base::File::FROM_BEGIN, 0));
 395
 396   char buffer[kDataSize];
 397   int first_chunk_size = kDataSize / 2;
 398   EXPECT_EQ(first_chunk_size, file.ReadAtCurrentPos(buffer, first_chunk_size));
 399   EXPECT_EQ(kDataSize - first_chunk_size,
 400             file.ReadAtCurrentPos(buffer + first_chunk_size,
 401                                   kDataSize - first_chunk_size));
 402   EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData));
 403 }
 404
 405 TEST(FileTest, WriteAtCurrentPosition) {
 406   base::ScopedTempDir temp_dir;
 407   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 408   FilePath file_path = temp_dir.path().AppendASCII("write_at_current_position");
 409   File file(file_path,
 410             base::File::FLAG_CREATE | base::File::FLAG_READ |
 411                 base::File::FLAG_WRITE);
 412   EXPECT_TRUE(file.IsValid());
 413
 414   const char kData[] = "test";
 415   const int kDataSize = sizeof(kData) - 1;
 416
 417   int first_chunk_size = kDataSize / 2;
 418   EXPECT_EQ(first_chunk_size, file.WriteAtCurrentPos(kData, first_chunk_size));
 419   EXPECT_EQ(kDataSize - first_chunk_size,
 420             file.WriteAtCurrentPos(kData + first_chunk_size,
 421                                    kDataSize - first_chunk_size));
 422
 423   char buffer[kDataSize];
 424   EXPECT_EQ(kDataSize, file.Read(0, buffer, kDataSize));
 425   EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData));
 426 }
 427
 428 TEST(FileTest, Seek) {
 429   base::ScopedTempDir temp_dir;
 430   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 431   FilePath file_path = temp_dir.path().AppendASCII("seek_file");
 432   File file(file_path,
 433             base::File::FLAG_CREATE | base::File::FLAG_READ |
 434                 base::File::FLAG_WRITE);
 435   ASSERT_TRUE(file.IsValid());
 436
 437   const int64 kOffset = 10;
 438   EXPECT_EQ(kOffset, file.Seek(base::File::FROM_BEGIN, kOffset));
 439   EXPECT_EQ(2 * kOffset, file.Seek(base::File::FROM_CURRENT, kOffset));
 440   EXPECT_EQ(kOffset, file.Seek(base::File::FROM_CURRENT, -kOffset));
 441   EXPECT_TRUE(file.SetLength(kOffset * 2));
 442   EXPECT_EQ(kOffset, file.Seek(base::File::FROM_END, -kOffset));
 443 }
 444
 445 #if defined(OS_WIN)
 446 TEST(FileTest, GetInfoForDirectory) {
 447   base::ScopedTempDir temp_dir;
 448   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 449   FilePath empty_dir = temp_dir.path().Append(FILE_PATH_LITERAL("gpfi_test"));
 450   ASSERT_TRUE(CreateDirectory(empty_dir));
 451
 452   base::File dir(
 453       ::CreateFile(empty_dir.value().c_str(),
 454                    FILE_ALL_ACCESS,
 455                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 456                    NULL,
 457                    OPEN_EXISTING,
 458                    FILE_FLAG_BACKUP_SEMANTICS,  // Needed to open a directory.
 459                    NULL));
 460   ASSERT_TRUE(dir.IsValid());
 461
 462   base::File::Info info;
 463   EXPECT_TRUE(dir.GetInfo(&info));
 464   EXPECT_TRUE(info.is_directory);
 465   EXPECT_FALSE(info.is_symbolic_link);
 466   EXPECT_EQ(0, info.size);
 467 }
 468 #endif  // defined(OS_WIN)