filesystem Namespace Reference

Classes
class	Descriptor

Functions
std::pair< uint8_t *, intptr_t >	ReadFileDescriptorToBytes (int fd)
bool	ReadFileToString (const std::string &path, std::string *result)
bool	ReadFileDescriptorToString (int fd, std::string *result)
std::pair< uint8_t *, intptr_t >	ReadFileToBytes (const std::string &path)
std::string	SimplifyPath (std::string path)
std::string	AbsolutePath (const std::string &path)
std::string	GetDirectoryName (const std::string &path)
std::string	GetBaseName (const std::string &path)
std::string	GetAbsoluteFilePath (const std::string &path)
	TEST (Directory, CreateDirectory)
	TEST (FileDescriptor, WriteAndRead)
void	ExpectPlatformPath (std::string expected, std::string actual)
	TEST (Path, SimplifyPath)
	TEST (Path, AbsolutePath)
	TEST (Path, GetDirectoryName)
	TEST (Path, GetBaseName)
	TEST (Path, DeletePath)
	TEST (Path, DeletePathRecursively)
	TEST (ScopedTempDir, Creation)
	TEST (ScopedTempDir, Deletion)
	TEST (ScopedTempDir, NewTempFile)
	TEST (ScopedTempDir, CustomParent)

Function Documentation

AbsolutePath()

std::string filesystem::AbsolutePath

(

const std::string &

path

)

Definition at line 147 of file path_posix.cc.

                                              {
  if (!path.empty()) {
    if (path[0] == '/') {
      // Path is already absolute.
      return path;
    }
    return GetCurrentDirectory() + "/" + path;
  } else {
    // Path is empty.
    return GetCurrentDirectory();
  }
}

ExpectPlatformPath()

void filesystem::ExpectPlatformPath	(	std::string	expected,
		std::string	actual
	)

Definition at line 13 of file path_unittest.cc.

                                                              {
#if defined(OS_WIN)
  std::replace(expected.begin(), expected.end(), '/', '\\');
#endif
  EXPECT_EQ(expected, actual);
}

GetAbsoluteFilePath()

std::string filesystem::GetAbsoluteFilePath

(

const std::string &

path

)

Definition at line 176 of file path_posix.cc.

                                                     {
#if defined(OS_FUCHSIA)
  // realpath() isn't supported by Fuchsia. See MG-425.
  return SimplifyPath(AbsolutePath(path));
#else
  char buffer[PATH_MAX];
  if (realpath(path.c_str(), buffer) == nullptr)
    return std::string();
  return buffer;
#endif  // defined(OS_FUCHSIA)
}

GetBaseName()

std::string filesystem::GetBaseName

(

const std::string &

path

)

Definition at line 169 of file path_posix.cc.

                                             {
  size_t separator = path.rfind('/');
  if (separator == std::string::npos)
    return path;
  return path.substr(separator + 1);
}

GetDirectoryName()

std::string filesystem::GetDirectoryName

(

const std::string &

path

)

Definition at line 160 of file path_posix.cc.

                                                  {
  size_t separator = path.rfind('/');
  if (separator == 0u)
    return "/";
  if (separator == std::string::npos)
    return std::string();
  return path.substr(0, separator);
}

ReadFileDescriptorToBytes()

std::pair< uint8_t *, intptr_t > filesystem::ReadFileDescriptorToBytes

(

int

fd

)

Definition at line 63 of file file.cc.

                                                              {
  std::pair<uint8_t*, intptr_t> failure_pair{nullptr, -1};
  struct stat st;
  if (fstat(fd, &st) != 0) {
    return failure_pair;
  }
  intptr_t file_size = st.st_size;
  uint8_t* ptr = (uint8_t*)malloc(file_size);
 
  size_t bytes_left = file_size;
  size_t offset = 0;
  while (bytes_left > 0) {
    ssize_t bytes_read = HANDLE_EINTR(read(fd, &ptr[offset], bytes_left));
    if (bytes_read < 0) {
      return failure_pair;
    }
    offset += bytes_read;
    bytes_left -= bytes_read;
  }
  return std::pair<uint8_t*, intptr_t>(ptr, file_size);
}

ReadFileDescriptorToString()

bool filesystem::ReadFileDescriptorToString	(	int	fd,
		std::string *	result
	)

Definition at line 90 of file file.cc.

                                                           {
  return ReadFileDescriptor(fd, result);
}

ReadFileToBytes()

std::pair< uint8_t *, intptr_t > filesystem::ReadFileToBytes

(

const std::string &

path

)

Definition at line 94 of file file.cc.

                                                                   {
  std::pair<uint8_t*, intptr_t> failure_pair{nullptr, -1};
  Descriptor fd(open(path.c_str(), O_RDONLY | BINARY_MODE));
  if (!fd.is_valid())
    return failure_pair;
  return ReadFileDescriptorToBytes(fd.get());
}

ReadFileToString()

bool filesystem::ReadFileToString	(	const std::string &	path,
		std::string *	result
	)

Definition at line 85 of file file.cc.

                                                                {
  Descriptor fd(open(path.c_str(), O_RDONLY));
  return ReadFileDescriptor(fd.get(), result);
}

SimplifyPath()

std::string filesystem::SimplifyPath

(

std::string

path

)

Definition at line 48 of file path_posix.cc.

                                       {
  if (path.empty())
    return ".";
 
  size_t put = 0;
  size_t get = 0;
  size_t traversal_root = 0;
  size_t component_start = 0;
 
  if (path[0] == '/') {
    put = 1;
    get = 1;
    component_start = 1;
  }
 
  while (get < path.size()) {
    char c = path[get];
 
    if (c == '.' && (get == component_start || get == component_start + 1)) {
      // We've seen "." or ".." so far in this component. We need to continue
      // searching.
      ++get;
      continue;
    }
 
    if (c == '/') {
      if (get == component_start || get == component_start + 1) {
        // We've found a "/" or a "./", which we can elide.
        ++get;
        component_start = get;
        continue;
      }
      if (get == component_start + 2) {
        // We've found a "../", which means we need to remove the previous
        // component.
        if (put == traversal_root) {
          path[put++] = '.';
          path[put++] = '.';
          path[put++] = '/';
          traversal_root = put;
        } else {
          put = ResolveParentDirectoryTraversal(path, put);
        }
        ++get;
        component_start = get;
        continue;
      }
    }
 
    size_t next_separator = path.find('/', get);
    if (next_separator == std::string::npos) {
      // We've reached the last component.
      break;
    }
    size_t next_component_start = next_separator + 1;
    ++next_separator;
    size_t component_size = next_component_start - component_start;
    if (put != component_start && component_size > 0) {
      path.replace(put, component_size,
                   path.substr(component_start, component_size));
    }
    put += component_size;
    get = next_component_start;
    component_start = next_component_start;
  }
 
  size_t last_component_size = path.size() - component_start;
  if (last_component_size == 1 && path[component_start] == '.') {
    // The last component is ".", which we can elide.
  } else if (last_component_size == 2 && path[component_start] == '.' &&
             path[component_start + 1] == '.') {
    // The last component is "..", which means we need to remove the previous
    // component.
    if (put == traversal_root) {
      path[put++] = '.';
      path[put++] = '.';
      path[put++] = '/';
      traversal_root = put;
    } else {
      put = ResolveParentDirectoryTraversal(path, put);
    }
  } else {
    // Otherwise, we need to copy over the last component.
    if (put != component_start && last_component_size > 0) {
      path.replace(put, last_component_size,
                   path.substr(component_start, last_component_size));
    }
    put += last_component_size;
  }
 
  if (put >= 2 && path[put - 1] == '/')
    --put;  // Trim trailing /
  else if (put == 0)
    return ".";  // Use . for otherwise empty paths to treat them as relative.
 
  path.resize(put);
  return path;
}

TEST() [1/12]

filesystem::TEST	(	Directory	,
		CreateDirectory
	)

Definition at line 12 of file directory_unittest.cc.

                                 {
  std::string cwd = GetCurrentDirectory();
 
  ScopedTempDir dir;
  EXPECT_TRUE(IsDirectory(dir.path()));
  EXPECT_EQ(0, chdir(dir.path().c_str()));
 
  EXPECT_TRUE(CreateDirectory("foo/bar"));
  EXPECT_TRUE(IsDirectory("foo"));
  EXPECT_TRUE(IsDirectory("foo/bar"));
  EXPECT_FALSE(IsDirectory("foo/bar/baz"));
 
  EXPECT_TRUE(CreateDirectory("foo/bar/baz"));
  EXPECT_TRUE(IsDirectory("foo/bar/baz"));
 
  EXPECT_TRUE(CreateDirectory("qux"));
  EXPECT_TRUE(IsDirectory("qux"));
 
  EXPECT_EQ(0, chdir(cwd.c_str()));
 
  std::string abs_path = dir.path() + "/another/one";
  EXPECT_TRUE(CreateDirectory(abs_path));
  EXPECT_TRUE(IsDirectory(abs_path));
}

TEST() [2/12]

filesystem::TEST	(	FileDescriptor	,
		WriteAndRead
	)

Definition at line 17 of file file_descriptor_unittest.cc.

                                   {
  files::ScopedTempDir temp_dir;
  std::string path;
  ASSERT_TRUE(temp_dir.NewTempFile(&path));
 
  fxl::UniqueFD fd(open(path.c_str(), O_RDWR));
  ASSERT_TRUE(fd.is_valid());
 
  std::string string = "one, two, three";
  EXPECT_TRUE(WriteFileDescriptor(fd.get(), string.data(), string.size()));
  EXPECT_EQ(0, lseek(fd.get(), 0, SEEK_SET));
 
  std::vector<char> buffer;
  buffer.resize(1024);
  ssize_t read = ReadFileDescriptor(fd.get(), buffer.data(), 1024);
  EXPECT_EQ(static_cast<ssize_t>(string.size()), read);
  EXPECT_EQ(string, buffer.data());
}

TEST() [3/12]

filesystem::TEST	(	Path	,
		AbsolutePath
	)

Definition at line 138 of file path_unittest.cc.

                         {
#if defined(OS_WIN)
  // We cut out the drive letter as it can be different on every system.
  EXPECT_EQ(":\\foo\\bar", AbsolutePath("\\foo\\bar").substr(1));
  EXPECT_EQ(":\\foo\\bar", AbsolutePath("/foo/bar").substr(1));
  EXPECT_EQ(":\\foo\\bar\\", AbsolutePath("\\foo\\bar\\").substr(1));
  EXPECT_EQ(":\\foo\\bar\\", AbsolutePath("/foo/bar/").substr(1));
  EXPECT_EQ("C:\\foo\\bar\\", AbsolutePath("C:\\foo\\bar\\"));
  EXPECT_EQ(GetCurrentDirectory() + "\\foo", AbsolutePath("foo"));
#else
  EXPECT_EQ("/foo/bar", AbsolutePath("/foo/bar"));
  EXPECT_EQ("/foo/bar/", AbsolutePath("/foo/bar/"));
  EXPECT_EQ(GetCurrentDirectory() + "/foo", AbsolutePath("foo"));
#endif
  EXPECT_EQ(GetCurrentDirectory(), AbsolutePath(""));
}

TEST() [4/12]

filesystem::TEST	(	Path	,
		DeletePath
	)

Definition at line 201 of file path_unittest.cc.

                       {
  ScopedTempDir dir;
 
  std::string sub_dir = dir.path() + "/dir";
  CreateDirectory(sub_dir);
  EXPECT_TRUE(IsDirectory(sub_dir));
  EXPECT_TRUE(DeletePath(sub_dir, false));
  EXPECT_FALSE(IsDirectory(sub_dir));
}

TEST() [5/12]

filesystem::TEST	(	Path	,
		DeletePathRecursively
	)

Definition at line 211 of file path_unittest.cc.

                                  {
  ScopedTempDir dir;
 
  std::string sub_dir = dir.path() + "/dir";
  CreateDirectory(sub_dir);
  EXPECT_TRUE(IsDirectory(sub_dir));
 
  std::string sub_sub_dir1 = sub_dir + "/dir1";
  CreateDirectory(sub_sub_dir1);
  EXPECT_TRUE(IsDirectory(sub_sub_dir1));
  std::string sub_sub_dir2 = sub_dir + "/dir2";
  CreateDirectory(sub_sub_dir2);
  EXPECT_TRUE(IsDirectory(sub_sub_dir2));
 
  EXPECT_FALSE(DeletePath(sub_dir, false));
  EXPECT_TRUE(IsDirectory(sub_dir));
  EXPECT_TRUE(IsDirectory(sub_sub_dir1));
 
  EXPECT_TRUE(DeletePath(sub_dir, true));
  EXPECT_FALSE(IsDirectory(sub_dir));
  EXPECT_FALSE(IsDirectory(sub_sub_dir1));
}

TEST() [6/12]

filesystem::TEST	(	Path	,
		GetBaseName
	)

Definition at line 178 of file path_unittest.cc.

                        {
  EXPECT_EQ("", GetBaseName("foo/"));
  EXPECT_EQ("", GetBaseName("foo/bar/"));
  EXPECT_EQ("bar", GetBaseName("foo/bar"));
  EXPECT_EQ("..", GetBaseName("foo/bar/.."));
  EXPECT_EQ("..", GetBaseName("foo/bar/../.."));
  EXPECT_EQ("foo", GetBaseName("foo"));
  EXPECT_EQ("", GetBaseName("/"));
  EXPECT_EQ("a", GetBaseName("a"));
  EXPECT_EQ("a", GetBaseName("/a"));
  EXPECT_EQ("", GetBaseName("/a/"));
  EXPECT_EQ("", GetBaseName("a/"));
#if defined(OS_WIN)
  EXPECT_EQ("", GetBaseName("C:\\"));
  EXPECT_EQ("", GetBaseName("C:\\foo\\"));
  EXPECT_EQ("bar", GetBaseName("C:\\foo\\bar"));
  EXPECT_EQ("", GetBaseName("foo\\bar\\"));
  EXPECT_EQ("bar", GetBaseName("foo\\bar"));
  EXPECT_EQ("", GetBaseName("\\"));
  EXPECT_EQ("a", GetBaseName("\\a"));
#endif
}

TEST() [7/12]

filesystem::TEST	(	Path	,
		GetDirectoryName
	)

Definition at line 155 of file path_unittest.cc.

                             {
  EXPECT_EQ("foo", GetDirectoryName("foo/"));
  EXPECT_EQ("foo/bar", GetDirectoryName("foo/bar/"));
  EXPECT_EQ("foo", GetDirectoryName("foo/bar"));
  EXPECT_EQ("foo/bar", GetDirectoryName("foo/bar/.."));
  EXPECT_EQ("foo/bar/..", GetDirectoryName("foo/bar/../.."));
  EXPECT_EQ("", GetDirectoryName("foo"));
  EXPECT_EQ("/", GetDirectoryName("/"));
  EXPECT_EQ("", GetDirectoryName("a"));
  EXPECT_EQ("/", GetDirectoryName("/a"));
  EXPECT_EQ("/a", GetDirectoryName("/a/"));
  EXPECT_EQ("a", GetDirectoryName("a/"));
#if defined(OS_WIN)
  EXPECT_EQ("C:\\", GetDirectoryName("C:\\"));
  EXPECT_EQ("C:\\foo", GetDirectoryName("C:\\foo\\"));
  EXPECT_EQ("C:\\foo", GetDirectoryName("C:\\foo\\bar"));
  EXPECT_EQ("foo\\bar", GetDirectoryName("foo\\bar\\"));
  EXPECT_EQ("foo", GetDirectoryName("foo\\bar"));
  EXPECT_EQ("\\", GetDirectoryName("\\"));
  EXPECT_EQ("\\", GetDirectoryName("\\a"));
#endif
}

TEST() [8/12]

filesystem::TEST	(	Path	,
		SimplifyPath
	)

Definition at line 20 of file path_unittest.cc.

                         {
  ExpectPlatformPath(".", SimplifyPath(""));
  ExpectPlatformPath(".", SimplifyPath("."));
  ExpectPlatformPath("..", SimplifyPath(".."));
  ExpectPlatformPath("...", SimplifyPath("..."));
 
  ExpectPlatformPath("/", SimplifyPath("/"));
  ExpectPlatformPath("/", SimplifyPath("/."));
  ExpectPlatformPath("/", SimplifyPath("/.."));
  ExpectPlatformPath("/...", SimplifyPath("/..."));
 
  ExpectPlatformPath("foo", SimplifyPath("foo"));
  ExpectPlatformPath("foo", SimplifyPath("foo/"));
  ExpectPlatformPath("foo", SimplifyPath("foo/."));
  ExpectPlatformPath("foo", SimplifyPath("foo/./"));
  ExpectPlatformPath(".", SimplifyPath("foo/.."));
  ExpectPlatformPath(".", SimplifyPath("foo/../"));
  ExpectPlatformPath("foo/...", SimplifyPath("foo/..."));
  ExpectPlatformPath("foo/...", SimplifyPath("foo/.../"));
  ExpectPlatformPath("foo/.b", SimplifyPath("foo/.b"));
  ExpectPlatformPath("foo/.b", SimplifyPath("foo/.b/"));
 
  ExpectPlatformPath("/foo", SimplifyPath("/foo"));
  ExpectPlatformPath("/foo", SimplifyPath("/foo/"));
  ExpectPlatformPath("/foo", SimplifyPath("/foo/."));
  ExpectPlatformPath("/foo", SimplifyPath("/foo/./"));
  ExpectPlatformPath("/", SimplifyPath("/foo/.."));
  ExpectPlatformPath("/", SimplifyPath("/foo/../"));
  ExpectPlatformPath("/foo/...", SimplifyPath("/foo/..."));
  ExpectPlatformPath("/foo/...", SimplifyPath("/foo/.../"));
  ExpectPlatformPath("/foo/.b", SimplifyPath("/foo/.b"));
  ExpectPlatformPath("/foo/.b", SimplifyPath("/foo/.b/"));
 
  ExpectPlatformPath("foo/bar", SimplifyPath("foo/bar"));
  ExpectPlatformPath("foo/bar", SimplifyPath("foo/bar/"));
  ExpectPlatformPath("foo/bar", SimplifyPath("foo/./bar"));
  ExpectPlatformPath("foo/bar", SimplifyPath("foo/./bar/"));
  ExpectPlatformPath("bar", SimplifyPath("foo/../bar"));
  ExpectPlatformPath("bar", SimplifyPath("foo/baz/../../bar"));
  ExpectPlatformPath("bar", SimplifyPath("foo/../bar/"));
  ExpectPlatformPath("foo/.../bar", SimplifyPath("foo/.../bar"));
  ExpectPlatformPath("foo/.../bar", SimplifyPath("foo/.../bar/"));
  ExpectPlatformPath("foo/.b/bar", SimplifyPath("foo/.b/bar"));
  ExpectPlatformPath("foo/.b/bar", SimplifyPath("foo/.b/bar/"));
 
  ExpectPlatformPath("/foo/bar", SimplifyPath("/foo/bar"));
  ExpectPlatformPath("/foo/bar", SimplifyPath("/foo/bar/"));
  ExpectPlatformPath("/foo/bar", SimplifyPath("/foo/./bar"));
  ExpectPlatformPath("/foo/bar", SimplifyPath("/foo/./bar/"));
  ExpectPlatformPath("/bar", SimplifyPath("/foo/../bar"));
  ExpectPlatformPath("/bar", SimplifyPath("/foo/../bar/"));
  ExpectPlatformPath("/foo/.../bar", SimplifyPath("/foo/.../bar"));
  ExpectPlatformPath("/foo/.../bar", SimplifyPath("/foo/.../bar/"));
  ExpectPlatformPath("/foo/.b/bar", SimplifyPath("/foo/.b/bar"));
  ExpectPlatformPath("/foo/.b/bar", SimplifyPath("/foo/.b/bar/"));
 
  ExpectPlatformPath("../foo", SimplifyPath("../foo"));
  ExpectPlatformPath("../../bar", SimplifyPath("../foo/../../bar"));
  ExpectPlatformPath("/bar", SimplifyPath("/foo/../../bar"));
 
  // Already clean
  ExpectPlatformPath(".", SimplifyPath(""));
  ExpectPlatformPath("abc", SimplifyPath("abc"));
  ExpectPlatformPath("abc/def", SimplifyPath("abc/def"));
  ExpectPlatformPath("a/b/c", SimplifyPath("a/b/c"));
  ExpectPlatformPath(".", SimplifyPath("."));
  ExpectPlatformPath("..", SimplifyPath(".."));
  ExpectPlatformPath("../..", SimplifyPath("../.."));
  ExpectPlatformPath("../../abc", SimplifyPath("../../abc"));
  ExpectPlatformPath("/abc", SimplifyPath("/abc"));
  ExpectPlatformPath("/", SimplifyPath("/"));
 
  // Remove trailing slash
  ExpectPlatformPath("abc", SimplifyPath("abc/"));
  ExpectPlatformPath("abc/def", SimplifyPath("abc/def/"));
  ExpectPlatformPath("a/b/c", SimplifyPath("a/b/c/"));
  ExpectPlatformPath(".", SimplifyPath("./"));
  ExpectPlatformPath("..", SimplifyPath("../"));
  ExpectPlatformPath("../..", SimplifyPath("../../"));
  ExpectPlatformPath("/abc", SimplifyPath("/abc/"));
 
  // Remove doubled slash
  ExpectPlatformPath("abc/def/ghi", SimplifyPath("abc//def//ghi"));
  ExpectPlatformPath("/abc", SimplifyPath("//abc"));
  ExpectPlatformPath("/abc", SimplifyPath("///abc"));
  ExpectPlatformPath("/abc", SimplifyPath("//abc//"));
  ExpectPlatformPath("abc", SimplifyPath("abc//"));
 
  // Remove . elements
  ExpectPlatformPath("abc/def", SimplifyPath("abc/./def"));
  ExpectPlatformPath("/abc/def", SimplifyPath("/./abc/def"));
  ExpectPlatformPath("abc", SimplifyPath("abc/."));
 
  // Remove .. elements
  ExpectPlatformPath("abc/def/jkl", SimplifyPath("abc/def/ghi/../jkl"));
  ExpectPlatformPath("abc/jkl", SimplifyPath("abc/def/../ghi/../jkl"));
  ExpectPlatformPath("abc", SimplifyPath("abc/def/.."));
  ExpectPlatformPath(".", SimplifyPath("abc/def/../.."));
  ExpectPlatformPath("/", SimplifyPath("/abc/def/../.."));
  ExpectPlatformPath("..", SimplifyPath("abc/def/../../.."));
  ExpectPlatformPath("/", SimplifyPath("/abc/def/../../.."));
  ExpectPlatformPath("../../mno",
                     SimplifyPath("abc/def/../../../ghi/jkl/../../../mno"));
  ExpectPlatformPath("/mno", SimplifyPath("/../mno"));
 
  // Combinations
  ExpectPlatformPath("def", SimplifyPath("abc/./../def"));
  ExpectPlatformPath("def", SimplifyPath("abc//./../def"));
  ExpectPlatformPath("../../def", SimplifyPath("abc/../../././../def"));
 
#if defined(OS_WIN)
  ExpectPlatformPath("a\\c", SimplifyPath("a\\b\\..\\c"));
  ExpectPlatformPath("X:\\a\\c", SimplifyPath("X:/a/b/../c"));
  ExpectPlatformPath("X:\\a\\b\\c", SimplifyPath("X:/a/b/./c"));
  ExpectPlatformPath("X:\\c", SimplifyPath("X:/../../c"));
#endif
}

TEST() [9/12]

filesystem::TEST	(	ScopedTempDir	,
		Creation
	)

Definition at line 12 of file scoped_temp_dir_unittest.cc.

                              {
  ScopedTempDir dir;
 
  EXPECT_TRUE(IsDirectory(dir.path()));
}

TEST() [10/12]

filesystem::TEST	(	ScopedTempDir	,
		CustomParent
	)

Definition at line 35 of file scoped_temp_dir_unittest.cc.

                                  {
  ScopedTempDir root_dir;
  std::string parent = root_dir.path() + "/a/b/c";
  std::string path;
  {
    ScopedTempDir dir(parent);
    path = dir.path();
    EXPECT_TRUE(IsDirectory(path));
    EXPECT_EQ(path.substr(0, parent.size()), parent);
    EXPECT_NE("temp_dir_XXXXXX", GetBaseName(path));
 
    // Regression test - don't create temp_dir_XXXXXX dir next to the temp one.
    EXPECT_FALSE(
        files::IsDirectory(GetDirectoryName(path) + "/temp_dir_XXXXXX"));
  }
 
  // Verify that the tmp directory itself was deleted, but not the parent.
  EXPECT_FALSE(IsDirectory(path));
  EXPECT_TRUE(IsDirectory(parent));
}

TEST() [11/12]

filesystem::TEST	(	ScopedTempDir	,
		Deletion
	)

Definition at line 18 of file scoped_temp_dir_unittest.cc.

                              {
  std::string path;
  {
    ScopedTempDir dir;
    path = dir.path();
  }
 
  EXPECT_FALSE(IsDirectory(path));
}

TEST() [12/12]

filesystem::TEST	(	ScopedTempDir	,
		NewTempFile
	)

Definition at line 28 of file scoped_temp_dir_unittest.cc.

                                 {
  ScopedTempDir dir;
  std::string path;
  EXPECT_TRUE(dir.NewTempFile(&path));
  EXPECT_FALSE(path.empty());
}