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 nullptr;
  }
 
  return {reinterpret_cast<const char*>(mapping.GetMapping()),
          mapping.GetSize()};
}

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"));
}

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"));
}

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"));
}

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"));
}

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");
}

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"));
}

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()));
}

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"));
}

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 char* filename = 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));
}

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));
}

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()));
}

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"));
}

TEST() [13/14]

TEST	(	FileTest	,
		ScopedTempDirIsValid
	)

Definition at line 56 of file file_unittest.cc.

                                     {
  fml::ScopedTemporaryDirectory dir;
  ASSERT_TRUE(dir.fd().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"));
}

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;
}