file_unittest.cc File Reference

#include <cstring>
#include <memory>
#include <vector>
#include "flutter/fml/build_config.h"
#include "flutter/fml/file.h"
#include "flutter/fml/mapping.h"
#include "flutter/fml/paths.h"
#include "flutter/fml/unique_fd.h"
#include "gtest/gtest.h"

Go to the source code of this file.

Functions
static bool	WriteStringToFile (const fml::UniqueFD &fd, const std::string &contents)
static std::string	ReadStringFromFile (const fml::UniqueFD &fd)
	TEST (FileTest, CreateTemporaryAndUnlink)
	TEST (FileTest, ScopedTempDirIsValid)
	TEST (FileTest, CanOpenFileForWriting)
	TEST (FileTest, CanTruncateAndWrite)
	TEST (FileTest, CreateDirectoryStructure)
	TEST (FileTest, VisitFilesCanBeCalledTwice)
	TEST (FileTest, CanListFilesRecursively)
	TEST (FileTest, CanStopVisitEarly)
	TEST (FileTest, AtomicWriteTest)
	TEST (FileTest, IgnoreBaseDirWhenPathIsAbsolute)
	TEST (FileTest, EmptyMappingTest)
	TEST (FileTest, MappingDontNeedSafeTest)
	TEST (FileTest, FileTestsWork)
	TEST (FileTest, FileTestsSupportsUnicode)

Function Documentation

ReadStringFromFile()

static std::string ReadStringFromFile ( const fml::UniqueFD &  fd )

static

Definition at line 35 of file file_unittest.cc.

                                                           {
  fml::FileMapping mapping(fd);
 
  if (mapping.GetMapping() == nullptr) {
    return {};
  }
 
  return {reinterpret_cast<const char*>(mapping.GetMapping()),
          mapping.GetSize()};
}

References fml::FileMapping::GetMapping(), and fml::FileMapping::GetSize().

Referenced by TEST(), TEST(), and TEST().

TEST() [1/14]

TEST	(	FileTest	,
		AtomicWriteTest
	)

Definition at line 236 of file file_unittest.cc.

                                {
  fml::ScopedTemporaryDirectory dir;
 
  const std::string contents = "These are my contents.";
 
  auto data = std::make_unique<fml::DataMapping>(
      std::vector<uint8_t>{contents.begin(), contents.end()});
 
  // Write.
  ASSERT_TRUE(fml::WriteAtomically(dir.fd(), "precious_data", *data));
 
  // Read and verify.
  ASSERT_EQ(contents,
            ReadStringFromFile(fml::OpenFile(dir.fd(), "precious_data", false,
                                             fml::FilePermission::kRead)));
 
  // Cleanup.
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), "precious_data"));
}

References data, fml::ScopedTemporaryDirectory::fd(), fml::kRead, fml::OpenFile(), ReadStringFromFile(), fml::UnlinkFile(), and fml::WriteAtomically().

TEST() [2/14]

TEST	(	FileTest	,
		CanListFilesRecursively
	)

Definition at line 168 of file file_unittest.cc.

                                        {
  fml::ScopedTemporaryDirectory dir;
 
  {
    auto c = fml::CreateDirectory(dir.fd(), {"a", "b", "c"},
                                  fml::FilePermission::kReadWrite);
    ASSERT_TRUE(c.is_valid());
    auto file1 =
        fml::OpenFile(c, "file1", true, fml::FilePermission::kReadWrite);
    auto file2 =
        fml::OpenFile(c, "file2", true, fml::FilePermission::kReadWrite);
    auto d = fml::CreateDirectory(c, {"d"}, fml::FilePermission::kReadWrite);
    ASSERT_TRUE(d.is_valid());
    auto file3 =
        fml::OpenFile(d, "file3", true, fml::FilePermission::kReadWrite);
    ASSERT_TRUE(file1.is_valid());
    ASSERT_TRUE(file2.is_valid());
    ASSERT_TRUE(file3.is_valid());
  }
 
  std::set<std::string> names;
  fml::FileVisitor visitor = [&names](const fml::UniqueFD& directory,
                                      const std::string& filename) {
    names.insert(filename);
    return true;
  };
 
  fml::VisitFilesRecursively(dir.fd(), visitor);
  ASSERT_EQ(names, std::set<std::string>(
                       {"a", "b", "c", "d", "file1", "file2", "file3"}));
 
  // Cleanup.
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), "a/b/c/d/file3"));
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), "a/b/c/file1"));
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), "a/b/c/file2"));
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a/b/c/d"));
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a/b/c"));
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a/b"));
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a"));
}

References fml::CreateDirectory(), d, fml::ScopedTemporaryDirectory::fd(), fml::kReadWrite, fml::OpenFile(), fml::UnlinkDirectory(), fml::UnlinkFile(), and fml::VisitFilesRecursively().

TEST() [3/14]

TEST	(	FileTest	,
		CanOpenFileForWriting
	)

Definition at line 61 of file file_unittest.cc.

                                      {
  fml::ScopedTemporaryDirectory dir;
  ASSERT_TRUE(dir.fd().is_valid());
 
  auto fd =
      fml::OpenFile(dir.fd(), "some.txt", true, fml::FilePermission::kWrite);
  ASSERT_TRUE(fd.is_valid());
  fd.reset();
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), "some.txt"));
}

References fml::ScopedTemporaryDirectory::fd(), fml::UniqueObject< T, Traits >::is_valid(), fml::kWrite, fml::OpenFile(), and fml::UnlinkFile().

TEST() [4/14]

TEST	(	FileTest	,
		CanStopVisitEarly
	)

Definition at line 209 of file file_unittest.cc.

                                  {
  fml::ScopedTemporaryDirectory dir;
 
  {
    auto d = fml::CreateDirectory(dir.fd(), {"a", "b", "c", "d"},
                                  fml::FilePermission::kReadWrite);
    ASSERT_TRUE(d.is_valid());
  }
 
  std::set<std::string> names;
  fml::FileVisitor visitor = [&names](const fml::UniqueFD& directory,
                                      const std::string& filename) {
    names.insert(filename);
    return filename == "c" ? false : true;  // stop if c is found
  };
 
  // Check the d is not visited as we stop at c.
  ASSERT_FALSE(fml::VisitFilesRecursively(dir.fd(), visitor));
  ASSERT_EQ(names, std::set<std::string>({"a", "b", "c"}));
 
  // Cleanup.
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a/b/c/d"));
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a/b/c"));
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a/b"));
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a"));
}

References fml::CreateDirectory(), d, fml::ScopedTemporaryDirectory::fd(), fml::kReadWrite, fml::UnlinkDirectory(), and fml::VisitFilesRecursively().

TEST() [5/14]

TEST	(	FileTest	,
		CanTruncateAndWrite
	)

Definition at line 72 of file file_unittest.cc.

                                    {
  fml::ScopedTemporaryDirectory dir;
  ASSERT_TRUE(dir.fd().is_valid());
 
  std::string contents = "some contents here";
 
  // On the first iteration, this tests writing and then reading a file that
  // didn't exist yet. On the second iteration it tests truncating, writing,
  // and reading a file that already existed.
  for (int i = 0; i < 2; i++) {
    {
      auto fd = fml::OpenFile(dir.fd(), "some.txt", true,
                              fml::FilePermission::kReadWrite);
      ASSERT_TRUE(fd.is_valid());
 
      ASSERT_TRUE(fml::TruncateFile(fd, contents.size()));
 
      fml::FileMapping mapping(fd, {fml::FileMapping::Protection::kWrite});
      ASSERT_EQ(mapping.GetSize(), contents.size());
      ASSERT_NE(mapping.GetMutableMapping(), nullptr);
 
      ::memcpy(mapping.GetMutableMapping(), contents.data(), contents.size());
    }
 
    {
      auto fd = fml::OpenFile(dir.fd(), "some.txt", false,
                              fml::FilePermission::kRead);
      ASSERT_TRUE(fd.is_valid());
 
      fml::FileMapping mapping(fd);
      ASSERT_EQ(mapping.GetSize(), contents.size());
 
      ASSERT_EQ(
          0, ::memcmp(mapping.GetMapping(), contents.data(), contents.size()));
    }
  }
 
  fml::UnlinkFile(dir.fd(), "some.txt");
}

References fml::ScopedTemporaryDirectory::fd(), fml::FileMapping::GetMapping(), fml::FileMapping::GetSize(), i, fml::UniqueObject< T, Traits >::is_valid(), fml::kRead, fml::kReadWrite, fml::FileMapping::kWrite, fml::OpenFile(), fml::TruncateFile(), and fml::UnlinkFile().

TEST() [6/14]

TEST	(	FileTest	,
		CreateDirectoryStructure
	)

Definition at line 112 of file file_unittest.cc.

                                         {
  fml::ScopedTemporaryDirectory dir;
 
  std::string contents = "These are my contents";
  {
    auto sub = fml::CreateDirectory(dir.fd(), {"a", "b", "c"},
                                    fml::FilePermission::kReadWrite);
    ASSERT_TRUE(sub.is_valid());
    auto file = fml::OpenFile(sub, "my_contents", true,
                              fml::FilePermission::kReadWrite);
    ASSERT_TRUE(file.is_valid());
    ASSERT_TRUE(WriteStringToFile(file, contents));
  }
 
  const char* file_path = "a/b/c/my_contents";
 
  {
    auto contents_file =
        fml::OpenFile(dir.fd(), file_path, false, fml::FilePermission::kRead);
    ASSERT_EQ(ReadStringFromFile(contents_file), contents);
  }
 
  // Cleanup.
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), file_path));
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a/b/c"));
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a/b"));
  ASSERT_TRUE(fml::UnlinkDirectory(dir.fd(), "a"));
}

References fml::CreateDirectory(), fml::ScopedTemporaryDirectory::fd(), fml::kRead, fml::kReadWrite, fml::OpenFile(), ReadStringFromFile(), fml::UnlinkDirectory(), fml::UnlinkFile(), and WriteStringToFile().

TEST() [7/14]

TEST	(	FileTest	,
		CreateTemporaryAndUnlink
	)

Definition at line 46 of file file_unittest.cc.

                                         {
  auto dir_name = fml::CreateTemporaryDirectory();
  ASSERT_NE(dir_name, "");
  auto dir =
      fml::OpenDirectory(dir_name.c_str(), false, fml::FilePermission::kRead);
  ASSERT_TRUE(dir.is_valid());
  dir.reset();
  ASSERT_TRUE(fml::UnlinkDirectory(dir_name.c_str()));
}

References fml::CreateTemporaryDirectory(), fml::kRead, fml::OpenDirectory(), and fml::UnlinkDirectory().

TEST() [8/14]

TEST	(	FileTest	,
		EmptyMappingTest
	)

Definition at line 283 of file file_unittest.cc.

                                 {
  fml::ScopedTemporaryDirectory dir;
 
  {
    auto file = fml::OpenFile(dir.fd(), "my_contents", true,
                              fml::FilePermission::kReadWrite);
 
    fml::FileMapping mapping(file);
    ASSERT_TRUE(mapping.IsValid());
    ASSERT_EQ(mapping.GetSize(), 0ul);
    ASSERT_EQ(mapping.GetMapping(), nullptr);
  }
 
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), "my_contents"));
}

References fml::ScopedTemporaryDirectory::fd(), fml::FileMapping::GetMapping(), fml::FileMapping::GetSize(), fml::FileMapping::IsValid(), fml::kReadWrite, fml::OpenFile(), and fml::UnlinkFile().

TEST() [9/14]

TEST	(	FileTest	,
		FileTestsSupportsUnicode
	)

Definition at line 343 of file file_unittest.cc.

                                         {
  fml::ScopedTemporaryDirectory dir;
  ASSERT_TRUE(dir.fd().is_valid());
  const auto* filename = reinterpret_cast<const char*>(u8"äëïöüテスト☃");
  auto fd =
      fml::OpenFile(dir.fd(), filename, true, fml::FilePermission::kWrite);
  ASSERT_TRUE(fd.is_valid());
  fd.reset();
  ASSERT_TRUE(fml::FileExists(dir.fd(), filename));
  ASSERT_TRUE(
      fml::IsFile(fml::paths::JoinPaths({dir.path(), filename}).c_str()));
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), filename));
}

References fml::ScopedTemporaryDirectory::fd(), fml::FileExists(), fml::UniqueObject< T, Traits >::is_valid(), fml::IsFile(), fml::paths::JoinPaths(), fml::kWrite, fml::OpenFile(), fml::ScopedTemporaryDirectory::path(), and fml::UnlinkFile().

TEST() [10/14]

TEST	(	FileTest	,
		FileTestsWork
	)

Definition at line 329 of file file_unittest.cc.

                              {
  fml::ScopedTemporaryDirectory dir;
  ASSERT_TRUE(dir.fd().is_valid());
  const char* filename = "some.txt";
  auto fd =
      fml::OpenFile(dir.fd(), filename, true, fml::FilePermission::kWrite);
  ASSERT_TRUE(fd.is_valid());
  fd.reset();
  ASSERT_TRUE(fml::FileExists(dir.fd(), filename));
  ASSERT_TRUE(
      fml::IsFile(fml::paths::JoinPaths({dir.path(), filename}).c_str()));
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), filename));
}

References fml::ScopedTemporaryDirectory::fd(), fml::FileExists(), fml::UniqueObject< T, Traits >::is_valid(), fml::IsFile(), fml::paths::JoinPaths(), fml::kWrite, fml::OpenFile(), fml::ScopedTemporaryDirectory::path(), and fml::UnlinkFile().

TEST() [11/14]

TEST	(	FileTest	,
		IgnoreBaseDirWhenPathIsAbsolute
	)

Definition at line 256 of file file_unittest.cc.

                                                {
  fml::ScopedTemporaryDirectory dir;
 
  // Make an absolute path.
  std::string filename = "filename.txt";
  std::string full_path =
      fml::paths::AbsolutePath(fml::paths::JoinPaths({dir.path(), filename}));
 
  const std::string contents = "These are my contents.";
  auto data = std::make_unique<fml::DataMapping>(
      std::vector<uint8_t>{contents.begin(), contents.end()});
 
  // Write.
  ASSERT_TRUE(fml::WriteAtomically(dir.fd(), full_path.c_str(), *data));
 
  // Test existence.
  ASSERT_TRUE(fml::FileExists(dir.fd(), full_path.c_str()));
 
  // Read and verify.
  ASSERT_EQ(contents,
            ReadStringFromFile(fml::OpenFile(dir.fd(), full_path.c_str(), false,
                                             fml::FilePermission::kRead)));
 
  // Cleanup.
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), full_path.c_str()));
}

References fml::paths::AbsolutePath(), data, fml::ScopedTemporaryDirectory::fd(), fml::FileExists(), fml::paths::JoinPaths(), fml::kRead, fml::OpenFile(), fml::ScopedTemporaryDirectory::path(), ReadStringFromFile(), fml::UnlinkFile(), and fml::WriteAtomically().

TEST() [12/14]

TEST	(	FileTest	,
		MappingDontNeedSafeTest
	)

Definition at line 299 of file file_unittest.cc.

                                        {
  fml::ScopedTemporaryDirectory dir;
 
  {
    auto file = fml::OpenFile(dir.fd(), "my_contents", true,
                              fml::FilePermission::kReadWrite);
    WriteStringToFile(file, "some content");
  }
 
  {
    auto file = fml::OpenFile(dir.fd(), "my_contents", false,
                              fml::FilePermission::kRead);
    fml::FileMapping mapping(file);
    ASSERT_TRUE(mapping.IsValid());
    ASSERT_EQ(mapping.GetMutableMapping(), nullptr);
    ASSERT_TRUE(mapping.IsDontNeedSafe());
  }
 
  {
    auto file = fml::OpenFile(dir.fd(), "my_contents", false,
                              fml::FilePermission::kReadWrite);
    fml::FileMapping mapping(file, {fml::FileMapping::Protection::kRead,
                                    fml::FileMapping::Protection::kWrite});
    ASSERT_TRUE(mapping.IsValid());
    ASSERT_NE(mapping.GetMutableMapping(), nullptr);
    ASSERT_FALSE(mapping.IsDontNeedSafe());
  }
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), "my_contents"));
}

References fml::ScopedTemporaryDirectory::fd(), fml::FileMapping::GetMutableMapping(), fml::FileMapping::IsDontNeedSafe(), fml::FileMapping::IsValid(), fml::kRead, fml::FileMapping::kRead, fml::kReadWrite, fml::FileMapping::kWrite, fml::OpenFile(), fml::UnlinkFile(), and WriteStringToFile().

TEST() [13/14]

TEST	(	FileTest	,
		ScopedTempDirIsValid
	)

Definition at line 56 of file file_unittest.cc.

                                     {
  fml::ScopedTemporaryDirectory dir;
  ASSERT_TRUE(dir.fd().is_valid());
}

References fml::ScopedTemporaryDirectory::fd(), and fml::UniqueObject< T, Traits >::is_valid().

TEST() [14/14]

TEST	(	FileTest	,
		VisitFilesCanBeCalledTwice
	)

Definition at line 141 of file file_unittest.cc.

                                           {
  fml::ScopedTemporaryDirectory dir;
 
  {
    auto file = fml::OpenFile(dir.fd(), "my_contents", true,
                              fml::FilePermission::kReadWrite);
    ASSERT_TRUE(file.is_valid());
  }
 
  int count;
  fml::FileVisitor count_visitor = [&count](const fml::UniqueFD& directory,
                                            const std::string& filename) {
    count += 1;
    return true;
  };
  count = 0;
  fml::VisitFiles(dir.fd(), count_visitor);
  ASSERT_EQ(count, 1);
 
  // Without `rewinddir` in `VisitFiles`, the following check would fail.
  count = 0;
  fml::VisitFiles(dir.fd(), count_visitor);
  ASSERT_EQ(count, 1);
 
  ASSERT_TRUE(fml::UnlinkFile(dir.fd(), "my_contents"));
}

References fml::ScopedTemporaryDirectory::fd(), fml::kReadWrite, fml::OpenFile(), fml::UnlinkFile(), and fml::VisitFiles().

WriteStringToFile()

static bool WriteStringToFile ( const fml::UniqueFD &  fd, const std::string &  contents  )

static

Definition at line 16 of file file_unittest.cc.

                                                         {
  if (!fml::TruncateFile(fd, contents.size())) {
    return false;
  }
 
  fml::FileMapping mapping(fd, {fml::FileMapping::Protection::kWrite});
  if (mapping.GetSize() != contents.size()) {
    return false;
  }
 
  if (mapping.GetMutableMapping() == nullptr) {
    return false;
  }
 
  ::memmove(mapping.GetMutableMapping(), contents.data(), contents.size());
  return true;
}

References fml::FileMapping::kWrite, and fml::TruncateFile().

Referenced by TEST(), and TEST().