blob: e81663c6598421e5cd5acf563f0283a2429b680d [file] [log] [blame]
// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/files/file.h"
#include <stdint.h>
#include <utility>
#include "base/files/file_util.h"
#include "base/files/memory_mapped_file.h"
#include "base/files/scoped_temp_dir.h"
#include "base/strings/string_util.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "build/buildflag.h"
#include "testing/gtest/include/gtest/gtest.h"
#if BUILDFLAG(ENABLE_BASE_TRACING)
#include "third_party/perfetto/include/perfetto/test/traced_value_test_support.h" // no-presubmit-check nogncheck
#endif // BUILDFLAG(ENABLE_BASE_TRACING)
#if BUILDFLAG(IS_WIN)
#include <windows.h>
#include "base/environment.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/gtest_util.h"
#endif
using base::File;
using base::FilePath;
TEST(FileTest, Create) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("create_file_1");
{
// Don't create a File at all.
File file;
EXPECT_FALSE(file.IsValid());
EXPECT_EQ(base::File::FILE_ERROR_FAILED, file.error_details());
File file2(base::File::FILE_ERROR_TOO_MANY_OPENED);
EXPECT_FALSE(file2.IsValid());
EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED, file2.error_details());
}
{
// Open a file that doesn't exist.
File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
EXPECT_FALSE(file.IsValid());
EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, file.error_details());
EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, base::File::GetLastFileError());
}
{
// Open or create a file.
File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ);
EXPECT_TRUE(file.IsValid());
EXPECT_TRUE(file.created());
EXPECT_EQ(base::File::FILE_OK, file.error_details());
}
{
// Open an existing file.
File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
EXPECT_TRUE(file.IsValid());
EXPECT_FALSE(file.created());
EXPECT_EQ(base::File::FILE_OK, file.error_details());
// This time verify closing the file.
file.Close();
EXPECT_FALSE(file.IsValid());
}
{
// Open an existing file through Initialize
File file;
file.Initialize(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
EXPECT_TRUE(file.IsValid());
EXPECT_FALSE(file.created());
EXPECT_EQ(base::File::FILE_OK, file.error_details());
// This time verify closing the file.
file.Close();
EXPECT_FALSE(file.IsValid());
}
#if !defined(STARBOARD)
{
// Create a file that exists.
File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_READ);
EXPECT_FALSE(file.IsValid());
EXPECT_FALSE(file.created());
EXPECT_EQ(base::File::FILE_ERROR_EXISTS, file.error_details());
EXPECT_EQ(base::File::FILE_ERROR_EXISTS, base::File::GetLastFileError());
}
#endif
{
// Create or overwrite a file.
File file(file_path,
base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
EXPECT_TRUE(file.IsValid());
EXPECT_TRUE(file.created());
EXPECT_EQ(base::File::FILE_OK, file.error_details());
}
#if !defined(STARBOARD)
{
// Create a delete-on-close file.
file_path = temp_dir.GetPath().AppendASCII("create_file_2");
File file(file_path,
base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ |
base::File::FLAG_DELETE_ON_CLOSE);
EXPECT_TRUE(file.IsValid());
EXPECT_TRUE(file.created());
EXPECT_EQ(base::File::FILE_OK, file.error_details());
}
EXPECT_FALSE(base::PathExists(file_path));
#endif // !defined(STARBOARD)
}
#if !defined(STARBOARD)
TEST(FileTest, SelfSwap) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("create_file_1");
File file(file_path,
base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_DELETE_ON_CLOSE);
std::swap(file, file);
EXPECT_TRUE(file.IsValid());
}
#endif // !defined(STARBOARD)
TEST(FileTest, Async) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("create_file");
{
#if defined(STARBOARD)
File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_ASYNC
| base::File::FLAG_READ);
#else
File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_ASYNC);
#endif
EXPECT_TRUE(file.IsValid());
EXPECT_TRUE(file.async());
}
{
#if defined(STARBOARD)
File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ);
#else
File file(file_path, base::File::FLAG_OPEN_ALWAYS);
#endif
EXPECT_TRUE(file.IsValid());
EXPECT_FALSE(file.async());
}
}
#if !defined(STARBOARD)
TEST(FileTest, DeleteOpenFile) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("create_file_1");
// Create a file.
File file(file_path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ |
base::File::FLAG_WIN_SHARE_DELETE);
EXPECT_TRUE(file.IsValid());
EXPECT_TRUE(file.created());
EXPECT_EQ(base::File::FILE_OK, file.error_details());
// Open an existing file and mark it as delete on close.
File same_file(file_path,
base::File::FLAG_OPEN | base::File::FLAG_DELETE_ON_CLOSE |
base::File::FLAG_READ);
EXPECT_TRUE(file.IsValid());
EXPECT_FALSE(same_file.created());
EXPECT_EQ(base::File::FILE_OK, same_file.error_details());
// Close both handles and check that the file is gone.
file.Close();
same_file.Close();
EXPECT_FALSE(base::PathExists(file_path));
}
#endif // !defined(STARBOARD)
TEST(FileTest, ReadWrite) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("read_write_file");
File file(file_path,
base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE);
ASSERT_TRUE(file.IsValid());
char data_to_write[] = "test";
const int kTestDataSize = 4;
// Write 0 bytes to the file.
int bytes_written = file.Write(0, data_to_write, 0);
EXPECT_EQ(0, bytes_written);
// Write 0 bytes, with buf=nullptr.
bytes_written = file.Write(0, nullptr, 0);
EXPECT_EQ(0, bytes_written);
// Write "test" to the file.
bytes_written = file.Write(0, data_to_write, kTestDataSize);
EXPECT_EQ(kTestDataSize, bytes_written);
// Read from EOF.
char data_read_1[32];
int bytes_read = file.Read(kTestDataSize, data_read_1, kTestDataSize);
EXPECT_EQ(0, bytes_read);
// Read from somewhere in the middle of the file.
const int kPartialReadOffset = 1;
bytes_read = file.Read(kPartialReadOffset, data_read_1, kTestDataSize);
EXPECT_EQ(kTestDataSize - kPartialReadOffset, bytes_read);
for (int i = 0; i < bytes_read; i++)
EXPECT_EQ(data_to_write[i + kPartialReadOffset], data_read_1[i]);
// Read 0 bytes.
bytes_read = file.Read(0, data_read_1, 0);
EXPECT_EQ(0, bytes_read);
// Read the entire file.
bytes_read = file.Read(0, data_read_1, kTestDataSize);
EXPECT_EQ(kTestDataSize, bytes_read);
for (int i = 0; i < bytes_read; i++)
EXPECT_EQ(data_to_write[i], data_read_1[i]);
// Read again, but using the trivial native wrapper.
bytes_read = file.ReadNoBestEffort(0, data_read_1, kTestDataSize);
EXPECT_LE(bytes_read, kTestDataSize);
for (int i = 0; i < bytes_read; i++)
EXPECT_EQ(data_to_write[i], data_read_1[i]);
// Write past the end of the file.
const int kOffsetBeyondEndOfFile = 10;
const int kPartialWriteLength = 2;
bytes_written = file.Write(kOffsetBeyondEndOfFile,
data_to_write, kPartialWriteLength);
EXPECT_EQ(kPartialWriteLength, bytes_written);
// Make sure the file was extended.
int64_t file_size = 0;
EXPECT_TRUE(GetFileSize(file_path, &file_size));
EXPECT_EQ(kOffsetBeyondEndOfFile + kPartialWriteLength, file_size);
// Make sure the file was zero-padded.
char data_read_2[32];
bytes_read = file.Read(0, data_read_2, static_cast<int>(file_size));
EXPECT_EQ(file_size, bytes_read);
for (int i = 0; i < kTestDataSize; i++)
EXPECT_EQ(data_to_write[i], data_read_2[i]);
for (int i = kTestDataSize; i < kOffsetBeyondEndOfFile; i++)
EXPECT_EQ(0, data_read_2[i]);
for (int i = kOffsetBeyondEndOfFile; i < file_size; i++)
EXPECT_EQ(data_to_write[i - kOffsetBeyondEndOfFile], data_read_2[i]);
}
TEST(FileTest, GetLastFileError) {
#if defined(STARBOARD)
SetLastFileError(File::Error::FILE_ERROR_ACCESS_DENIED);
#elif BUILDFLAG(IS_WIN)
::SetLastError(ERROR_ACCESS_DENIED);
#else
errno = EACCES;
#endif
EXPECT_EQ(File::FILE_ERROR_ACCESS_DENIED, File::GetLastFileError());
base::ScopedTempDir temp_dir;
EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath nonexistent_path(temp_dir.GetPath().AppendASCII("nonexistent"));
File file(nonexistent_path, File::FLAG_OPEN | File::FLAG_READ);
File::Error last_error = File::GetLastFileError();
EXPECT_FALSE(file.IsValid());
EXPECT_EQ(File::FILE_ERROR_NOT_FOUND, file.error_details());
EXPECT_EQ(File::FILE_ERROR_NOT_FOUND, last_error);
}
TEST(FileTest, Append) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("append_file");
File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_APPEND);
ASSERT_TRUE(file.IsValid());
char data_to_write[] = "test";
const int kTestDataSize = 4;
// Write 0 bytes to the file.
int bytes_written = file.Write(0, data_to_write, 0);
EXPECT_EQ(0, bytes_written);
// Write 0 bytes, with buf=nullptr.
bytes_written = file.Write(0, nullptr, 0);
EXPECT_EQ(0, bytes_written);
// Write "test" to the file.
bytes_written = file.Write(0, data_to_write, kTestDataSize);
EXPECT_EQ(kTestDataSize, bytes_written);
file.Close();
File file2(file_path,
base::File::FLAG_OPEN | base::File::FLAG_READ |
base::File::FLAG_APPEND);
ASSERT_TRUE(file2.IsValid());
// Test passing the file around.
file = std::move(file2);
EXPECT_FALSE(file2.IsValid());
ASSERT_TRUE(file.IsValid());
char append_data_to_write[] = "78";
const int kAppendDataSize = 2;
// Append "78" to the file.
bytes_written = file.Write(0, append_data_to_write, kAppendDataSize);
EXPECT_EQ(kAppendDataSize, bytes_written);
// Read the entire file.
char data_read_1[32];
int bytes_read = file.Read(0, data_read_1,
kTestDataSize + kAppendDataSize);
EXPECT_EQ(kTestDataSize + kAppendDataSize, bytes_read);
for (int i = 0; i < kTestDataSize; i++)
EXPECT_EQ(data_to_write[i], data_read_1[i]);
for (int i = 0; i < kAppendDataSize; i++)
EXPECT_EQ(append_data_to_write[i], data_read_1[kTestDataSize + i]);
}
TEST(FileTest, Length) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("truncate_file");
File file(file_path,
base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE);
ASSERT_TRUE(file.IsValid());
EXPECT_EQ(0, file.GetLength());
// Write "test" to the file.
char data_to_write[] = "test";
int kTestDataSize = 4;
int bytes_written = file.Write(0, data_to_write, kTestDataSize);
EXPECT_EQ(kTestDataSize, bytes_written);
// Extend the file.
const int kExtendedFileLength = 10;
int64_t file_size = 0;
EXPECT_TRUE(file.SetLength(kExtendedFileLength));
EXPECT_EQ(kExtendedFileLength, file.GetLength());
EXPECT_TRUE(GetFileSize(file_path, &file_size));
EXPECT_EQ(kExtendedFileLength, file_size);
// Make sure the file was zero-padded.
char data_read[32];
int bytes_read = file.Read(0, data_read, static_cast<int>(file_size));
EXPECT_EQ(file_size, bytes_read);
for (int i = 0; i < kTestDataSize; i++)
EXPECT_EQ(data_to_write[i], data_read[i]);
for (int i = kTestDataSize; i < file_size; i++)
EXPECT_EQ(0, data_read[i]);
// Truncate the file.
const int kTruncatedFileLength = 2;
EXPECT_TRUE(file.SetLength(kTruncatedFileLength));
EXPECT_EQ(kTruncatedFileLength, file.GetLength());
EXPECT_TRUE(GetFileSize(file_path, &file_size));
EXPECT_EQ(kTruncatedFileLength, file_size);
// Make sure the file was truncated.
bytes_read = file.Read(0, data_read, kTestDataSize);
EXPECT_EQ(file_size, bytes_read);
for (int i = 0; i < file_size; i++)
EXPECT_EQ(data_to_write[i], data_read[i]);
#if !BUILDFLAG(IS_FUCHSIA) // Fuchsia doesn't seem to support big files.
// Expand the file past the 4 GB limit.
const int64_t kBigFileLength = 5'000'000'000;
EXPECT_TRUE(file.SetLength(kBigFileLength));
EXPECT_EQ(kBigFileLength, file.GetLength());
EXPECT_TRUE(GetFileSize(file_path, &file_size));
EXPECT_EQ(kBigFileLength, file_size);
#endif
// Close the file and reopen with base::File::FLAG_CREATE_ALWAYS, and make
// sure the file is empty (old file was overridden).
file.Close();
file.Initialize(file_path,
base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
EXPECT_EQ(0, file.GetLength());
}
// Flakily fails: http://crbug.com/86494
#if BUILDFLAG(IS_ANDROID)
TEST(FileTest, TouchGetInfo) {
#else
TEST(FileTest, DISABLED_TouchGetInfo) {
#endif
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
File file(temp_dir.GetPath().AppendASCII("touch_get_info_file"),
base::File::FLAG_CREATE | base::File::FLAG_WRITE |
base::File::FLAG_WRITE_ATTRIBUTES);
ASSERT_TRUE(file.IsValid());
// Get info for a newly created file.
base::File::Info info;
EXPECT_TRUE(file.GetInfo(&info));
// Add 2 seconds to account for possible rounding errors on
// filesystems that use a 1s or 2s timestamp granularity.
base::Time now = base::Time::Now() + base::Seconds(2);
EXPECT_EQ(0, info.size);
EXPECT_FALSE(info.is_directory);
EXPECT_FALSE(info.is_symbolic_link);
EXPECT_LE(info.last_accessed.ToInternalValue(), now.ToInternalValue());
EXPECT_LE(info.last_modified.ToInternalValue(), now.ToInternalValue());
EXPECT_LE(info.creation_time.ToInternalValue(), now.ToInternalValue());
base::Time creation_time = info.creation_time;
// Write "test" to the file.
char data[] = "test";
const int kTestDataSize = 4;
int bytes_written = file.Write(0, data, kTestDataSize);
EXPECT_EQ(kTestDataSize, bytes_written);
// Change the last_accessed and last_modified dates.
// It's best to add values that are multiples of 2 (in seconds)
// to the current last_accessed and last_modified times, because
// FATxx uses a 2s timestamp granularity.
base::Time new_last_accessed = info.last_accessed + base::Seconds(234);
base::Time new_last_modified = info.last_modified + base::Minutes(567);
EXPECT_TRUE(file.SetTimes(new_last_accessed, new_last_modified));
// Make sure the file info was updated accordingly.
EXPECT_TRUE(file.GetInfo(&info));
EXPECT_EQ(info.size, kTestDataSize);
EXPECT_FALSE(info.is_directory);
EXPECT_FALSE(info.is_symbolic_link);
// ext2/ext3 and HPS/HPS+ seem to have a timestamp granularity of 1s.
#if BUILDFLAG(IS_POSIX) && !defined(STARBOARD)
EXPECT_EQ(info.last_accessed.ToTimeVal().tv_sec,
new_last_accessed.ToTimeVal().tv_sec);
EXPECT_EQ(info.last_modified.ToTimeVal().tv_sec,
new_last_modified.ToTimeVal().tv_sec);
#else
EXPECT_EQ(info.last_accessed.ToInternalValue(),
new_last_accessed.ToInternalValue());
EXPECT_EQ(info.last_modified.ToInternalValue(),
new_last_modified.ToInternalValue());
#endif
EXPECT_EQ(info.creation_time.ToInternalValue(),
creation_time.ToInternalValue());
}
// Test we can retrieve the file's creation time through File::GetInfo().
TEST(FileTest, GetInfoForCreationTime) {
int64_t before_creation_time_s =
base::Time::Now().ToDeltaSinceWindowsEpoch().InSeconds();
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("test_file");
File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE);
EXPECT_TRUE(file.IsValid());
int64_t after_creation_time_s =
base::Time::Now().ToDeltaSinceWindowsEpoch().InSeconds();
base::File::Info info;
EXPECT_TRUE(file.GetInfo(&info));
EXPECT_GE(info.creation_time.ToDeltaSinceWindowsEpoch().InSeconds(),
before_creation_time_s);
EXPECT_LE(info.creation_time.ToDeltaSinceWindowsEpoch().InSeconds(),
after_creation_time_s);
}
TEST(FileTest, ReadAtCurrentPosition) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path =
temp_dir.GetPath().AppendASCII("read_at_current_position");
File file(file_path,
base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE);
EXPECT_TRUE(file.IsValid());
const char kData[] = "test";
const int kDataSize = sizeof(kData) - 1;
EXPECT_EQ(kDataSize, file.Write(0, kData, kDataSize));
EXPECT_EQ(0, file.Seek(base::File::FROM_BEGIN, 0));
char buffer[kDataSize];
int first_chunk_size = kDataSize / 2;
EXPECT_EQ(first_chunk_size, file.ReadAtCurrentPos(buffer, first_chunk_size));
EXPECT_EQ(kDataSize - first_chunk_size,
file.ReadAtCurrentPos(buffer + first_chunk_size,
kDataSize - first_chunk_size));
EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData));
}
TEST(FileTest, WriteAtCurrentPosition) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path =
temp_dir.GetPath().AppendASCII("write_at_current_position");
File file(file_path,
base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE);
EXPECT_TRUE(file.IsValid());
const char kData[] = "test";
const int kDataSize = sizeof(kData) - 1;
int first_chunk_size = kDataSize / 2;
EXPECT_EQ(first_chunk_size, file.WriteAtCurrentPos(kData, first_chunk_size));
EXPECT_EQ(kDataSize - first_chunk_size,
file.WriteAtCurrentPos(kData + first_chunk_size,
kDataSize - first_chunk_size));
char buffer[kDataSize];
EXPECT_EQ(kDataSize, file.Read(0, buffer, kDataSize));
EXPECT_EQ(std::string(buffer, buffer + kDataSize), std::string(kData));
}
TEST(FileTest, Seek) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("seek_file");
File file(file_path,
base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE);
ASSERT_TRUE(file.IsValid());
const int64_t kOffset = 10;
EXPECT_EQ(kOffset, file.Seek(base::File::FROM_BEGIN, kOffset));
EXPECT_EQ(2 * kOffset, file.Seek(base::File::FROM_CURRENT, kOffset));
EXPECT_EQ(kOffset, file.Seek(base::File::FROM_CURRENT, -kOffset));
EXPECT_TRUE(file.SetLength(kOffset * 2));
EXPECT_EQ(kOffset, file.Seek(base::File::FROM_END, -kOffset));
}
#if !defined(STARBOARD)
TEST(FileTest, Duplicate) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
File file(file_path,(base::File::FLAG_CREATE |
base::File::FLAG_READ |
base::File::FLAG_WRITE));
ASSERT_TRUE(file.IsValid());
File file2(file.Duplicate());
ASSERT_TRUE(file2.IsValid());
// Write through one handle, close it, read through the other.
static const char kData[] = "now is a good time.";
static const int kDataLen = sizeof(kData) - 1;
ASSERT_EQ(0, file.Seek(base::File::FROM_CURRENT, 0));
ASSERT_EQ(0, file2.Seek(base::File::FROM_CURRENT, 0));
ASSERT_EQ(kDataLen, file.WriteAtCurrentPos(kData, kDataLen));
ASSERT_EQ(kDataLen, file.Seek(base::File::FROM_CURRENT, 0));
ASSERT_EQ(kDataLen, file2.Seek(base::File::FROM_CURRENT, 0));
file.Close();
char buf[kDataLen];
ASSERT_EQ(kDataLen, file2.Read(0, &buf[0], kDataLen));
ASSERT_EQ(std::string(kData, kDataLen), std::string(&buf[0], kDataLen));
}
#endif
#if !defined(STARBOARD)
TEST(FileTest, DuplicateDeleteOnClose) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
File file(file_path,(base::File::FLAG_CREATE |
base::File::FLAG_READ |
base::File::FLAG_WRITE |
base::File::FLAG_DELETE_ON_CLOSE));
ASSERT_TRUE(file.IsValid());
File file2(file.Duplicate());
ASSERT_TRUE(file2.IsValid());
file.Close();
file2.Close();
ASSERT_FALSE(base::PathExists(file_path));
}
#endif
#if BUILDFLAG(ENABLE_BASE_TRACING) && !defined(STARBOARD)
TEST(FileTest, TracedValueSupport) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
File file(file_path,
(base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE | base::File::FLAG_DELETE_ON_CLOSE));
ASSERT_TRUE(file.IsValid());
EXPECT_EQ(perfetto::TracedValueToString(file),
"{is_valid:true,created:true,async:false,error_details:FILE_OK}");
}
#endif // BUILDFLAG(ENABLE_BASE_TRACING)
#if BUILDFLAG(IS_WIN)
// Flakily times out on Windows, see http://crbug.com/846276.
#define MAYBE_WriteDataToLargeOffset DISABLED_WriteDataToLargeOffset
#else
#define MAYBE_WriteDataToLargeOffset WriteDataToLargeOffset
#endif
TEST(FileTest, MAYBE_WriteDataToLargeOffset) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
#if defined(STARBOARD)
File file(file_path, (base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE));
#else
File file(file_path,
(base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE | base::File::FLAG_DELETE_ON_CLOSE));
#endif
ASSERT_TRUE(file.IsValid());
const char kData[] = "this file is sparse.";
const int kDataLen = sizeof(kData) - 1;
#if defined(STARBOARD)
#if SB_IS(32_BIT)
// Maximum off_t for lseek() on 32-bit builds is just below 2^31.
const int64_t kLargeFileOffset = (1LL << 31) - 2;
#else // SB_IS(32_BIT)
const int64_t kLargeFileOffset = (1LL << 31);
#endif // SB_IS(32_BIT)
#else // defined(STARBOARD)
const int64_t kLargeFileOffset = (1LL << 31);
#endif // defined(STARBOARD)
// If the file fails to write, it is probably we are running out of disk space
// and the file system doesn't support sparse file.
if (file.Write(kLargeFileOffset - kDataLen - 1, kData, kDataLen) < 0)
return;
ASSERT_EQ(kDataLen, file.Write(kLargeFileOffset + 1, kData, kDataLen));
}
TEST(FileTest, AddFlagsForPassingToUntrustedProcess) {
{
uint32_t flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
flags = base::File::AddFlagsForPassingToUntrustedProcess(flags);
EXPECT_EQ(flags, base::File::FLAG_OPEN | base::File::FLAG_READ);
}
{
uint32_t flags = base::File::FLAG_OPEN | base::File::FLAG_WRITE;
flags = base::File::AddFlagsForPassingToUntrustedProcess(flags);
EXPECT_EQ(flags, base::File::FLAG_OPEN | base::File::FLAG_WRITE |
base::File::FLAG_WIN_NO_EXECUTE);
}
}
#if BUILDFLAG(IS_WIN)
TEST(FileTest, GetInfoForDirectory) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath empty_dir =
temp_dir.GetPath().Append(FILE_PATH_LITERAL("gpfi_test"));
ASSERT_TRUE(CreateDirectory(empty_dir));
base::File dir(
::CreateFile(empty_dir.value().c_str(), GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS, // Needed to open a directory.
NULL));
ASSERT_TRUE(dir.IsValid());
base::File::Info info;
EXPECT_TRUE(dir.GetInfo(&info));
EXPECT_TRUE(info.is_directory);
EXPECT_FALSE(info.is_symbolic_link);
EXPECT_EQ(0, info.size);
}
TEST(FileTest, DeleteNoop) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
// Creating and closing a file with DELETE perms should do nothing special.
File file(file_path,
(base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
ASSERT_TRUE(file.IsValid());
file.Close();
ASSERT_TRUE(base::PathExists(file_path));
}
TEST(FileTest, Delete) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
// Creating a file with DELETE and then marking for delete on close should
// delete it.
File file(file_path,
(base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
ASSERT_TRUE(file.IsValid());
ASSERT_TRUE(file.DeleteOnClose(true));
file.Close();
ASSERT_FALSE(base::PathExists(file_path));
}
TEST(FileTest, DeleteThenRevoke) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
// Creating a file with DELETE, marking it for delete, then clearing delete on
// close should not delete it.
File file(file_path,
(base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
ASSERT_TRUE(file.IsValid());
ASSERT_TRUE(file.DeleteOnClose(true));
ASSERT_TRUE(file.DeleteOnClose(false));
file.Close();
ASSERT_TRUE(base::PathExists(file_path));
}
TEST(FileTest, IrrevokableDeleteOnClose) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
// DELETE_ON_CLOSE cannot be revoked by this opener.
File file(file_path,
(base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE | base::File::FLAG_DELETE_ON_CLOSE |
base::File::FLAG_WIN_SHARE_DELETE |
base::File::FLAG_CAN_DELETE_ON_CLOSE));
ASSERT_TRUE(file.IsValid());
// https://msdn.microsoft.com/library/windows/desktop/aa364221.aspx says that
// setting the dispositon has no effect if the handle was opened with
// FLAG_DELETE_ON_CLOSE. Do not make the test's success dependent on whether
// or not SetFileInformationByHandle indicates success or failure. (It happens
// to indicate success on Windows 10.)
file.DeleteOnClose(false);
file.Close();
ASSERT_FALSE(base::PathExists(file_path));
}
TEST(FileTest, IrrevokableDeleteOnCloseOther) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
// DELETE_ON_CLOSE cannot be revoked by another opener.
File file(file_path,
(base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE | base::File::FLAG_DELETE_ON_CLOSE |
base::File::FLAG_WIN_SHARE_DELETE |
base::File::FLAG_CAN_DELETE_ON_CLOSE));
ASSERT_TRUE(file.IsValid());
File file2(file_path,
(base::File::FLAG_OPEN | base::File::FLAG_READ |
base::File::FLAG_WRITE | base::File::FLAG_WIN_SHARE_DELETE |
base::File::FLAG_CAN_DELETE_ON_CLOSE));
ASSERT_TRUE(file2.IsValid());
file2.DeleteOnClose(false);
file2.Close();
ASSERT_TRUE(base::PathExists(file_path));
file.Close();
ASSERT_FALSE(base::PathExists(file_path));
}
TEST(FileTest, DeleteWithoutPermission) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
// It should not be possible to mark a file for deletion when it was not
// created/opened with DELETE.
File file(file_path, (base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE));
ASSERT_TRUE(file.IsValid());
ASSERT_FALSE(file.DeleteOnClose(true));
file.Close();
ASSERT_TRUE(base::PathExists(file_path));
}
TEST(FileTest, UnsharedDeleteOnClose) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
// Opening with DELETE_ON_CLOSE when a previous opener hasn't enabled sharing
// will fail.
File file(file_path, (base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE));
ASSERT_TRUE(file.IsValid());
File file2(
file_path,
(base::File::FLAG_OPEN | base::File::FLAG_READ | base::File::FLAG_WRITE |
base::File::FLAG_DELETE_ON_CLOSE | base::File::FLAG_WIN_SHARE_DELETE));
ASSERT_FALSE(file2.IsValid());
file.Close();
ASSERT_TRUE(base::PathExists(file_path));
}
TEST(FileTest, NoDeleteOnCloseWithMappedFile) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
// Mapping a file into memory blocks DeleteOnClose.
File file(file_path,
(base::File::FLAG_CREATE | base::File::FLAG_READ |
base::File::FLAG_WRITE | base::File::FLAG_CAN_DELETE_ON_CLOSE));
ASSERT_TRUE(file.IsValid());
ASSERT_EQ(5, file.WriteAtCurrentPos("12345", 5));
{
base::MemoryMappedFile mapping;
ASSERT_TRUE(mapping.Initialize(file.Duplicate()));
ASSERT_EQ(5U, mapping.length());
EXPECT_FALSE(file.DeleteOnClose(true));
}
file.Close();
ASSERT_TRUE(base::PathExists(file_path));
}
// Check that we handle the async bit being set incorrectly in a sane way.
TEST(FileTest, UseSyncApiWithAsyncFile) {
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
File file(file_path, base::File::FLAG_CREATE | base::File::FLAG_WRITE |
base::File::FLAG_ASYNC);
File lying_file(file.TakePlatformFile(), false /* async */);
ASSERT_TRUE(lying_file.IsValid());
ASSERT_EQ(lying_file.WriteAtCurrentPos("12345", 5), -1);
}
TEST(FileDeathTest, InvalidFlags) {
EXPECT_CHECK_DEATH_WITH(
{
// When this test is running as Admin, TMP gets ignored and temporary
// files/folders are created in %ProgramFiles%. This means that the
// temporary folder created by the death test never gets deleted, as it
// crashes before the `base::ScopedTempDir` goes out of scope and also
// does not get automatically cleaned by by the test runner.
//
// To avoid this from happening, this death test explicitly creates the
// temporary folder in TMP, which is set by the test runner parent
// process to a temporary folder for the test. This means that the
// folder created here is always deleted during test runner cleanup.
std::string tmp_folder;
ASSERT_TRUE(base::Environment::Create()->GetVar("TMP", &tmp_folder));
base::ScopedTempDir temp_dir;
ASSERT_TRUE(temp_dir.CreateUniqueTempDirUnderPath(
base::FilePath(base::UTF8ToWide(tmp_folder))));
FilePath file_path = temp_dir.GetPath().AppendASCII("file");
File file(file_path,
base::File::FLAG_CREATE | base::File::FLAG_WIN_EXECUTE |
base::File::FLAG_READ | base::File::FLAG_WIN_NO_EXECUTE);
},
"FLAG_WIN_NO_EXECUTE");
}
#endif // BUILDFLAG(IS_WIN)