#include "llvm/ADT/Optional.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/Error.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
#include "llvm/Support/raw_os_ostream.h"
#include "gmock/gmock-matchers.h"
#include "gtest/gtest-printers.h"
return detail::ValueIsMatcher<InnerMatcher>(ValueMatcher);
}
namespace unittest {
+
SmallString<128> getInputFileDirectory(const char *Argv0);
+
+/// A RAII object that creates a temporary directory upon initialization and
+/// removes it upon destruction.
+class TempDir {
+ SmallString<128> Path;
+
+public:
+ /// Creates a managed temporary directory.
+ ///
+ /// @param Name The name of the directory to create.
+ /// @param Unique If true, the directory will be created using
+ /// llvm::sys::fs::createUniqueDirectory.
+ explicit TempDir(StringRef Name, bool Unique = false) {
+ std::error_code EC;
+ if (Unique) {
+ EC = llvm::sys::fs::createUniqueDirectory(Name, Path);
+ if (!EC) {
+ // Resolve any symlinks in the new directory.
+ std::string UnresolvedPath(Path.str());
+ EC = llvm::sys::fs::real_path(UnresolvedPath, Path);
+ }
+ } else {
+ Path = Name;
+ EC = llvm::sys::fs::create_directory(Path);
+ }
+ if (EC)
+ Path.clear();
+ EXPECT_FALSE(EC) << EC.message();
+ }
+
+ ~TempDir() {
+ if (!Path.empty()) {
+ EXPECT_FALSE(llvm::sys::fs::remove_directories(Path.str()));
+ }
+ }
+
+ TempDir(const TempDir &) = delete;
+ TempDir &operator=(const TempDir &) = delete;
+
+ TempDir(TempDir &&) = default;
+ TempDir &operator=(TempDir &&) = default;
+
+ /// The path to the temporary directory.
+ StringRef path() const { return Path; }
+
+ /// Creates a new path by appending the argument to the path of the managed
+ /// directory using the native path separator.
+ SmallString<128> path(StringRef component) const {
+ SmallString<128> Result(Path);
+ SmallString<128> ComponentToAppend(component);
+ llvm::sys::path::native(ComponentToAppend);
+ llvm::sys::path::append(Result, Twine(ComponentToAppend));
+ return Result;
+ }
+};
+
+/// A RAII object that creates a link upon initialization and
+/// removes it upon destruction.
+///
+/// The link may be a soft or a hard link, depending on the platform.
+class TempLink {
+ SmallString<128> Path;
+
+public:
+ /// Creates a managed link at path Link pointing to Target.
+ TempLink(StringRef Target, StringRef Link) {
+ Path = Link;
+ std::error_code EC = sys::fs::create_link(Target, Link);
+ if (EC)
+ Path.clear();
+ EXPECT_FALSE(EC);
+ }
+ ~TempLink() {
+ if (!Path.empty()) {
+ EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
+ }
+ }
+
+ TempLink(const TempLink &) = delete;
+ TempLink &operator=(const TempLink &) = delete;
+
+ TempLink(TempLink &&) = default;
+ TempLink &operator=(TempLink &&) = default;
+
+ /// The path to the link.
+ StringRef path() const { return Path; }
+};
+
+/// A RAII object that creates a file upon initialization and
+/// removes it upon destruction.
+class TempFile {
+ SmallString<128> Path;
+
+public:
+ /// Creates a managed file.
+ ///
+ /// @param Name The name of the file to create.
+ /// @param Contents The string to write to the file.
+ /// @param Unique If true, the file will be created using
+ /// llvm::sys::fs::createTemporaryFile.
+ TempFile(StringRef Name, StringRef Suffix = "", StringRef Contents = "",
+ bool Unique = false) {
+ std::error_code EC;
+ int fd;
+ if (Unique) {
+ EC = llvm::sys::fs::createTemporaryFile(Name, Suffix, fd, Path);
+ } else {
+ Path = Name;
+ if (!Suffix.empty()) {
+ Path.append(".");
+ Path.append(Suffix);
+ }
+ EC = llvm::sys::fs::openFileForWrite(Path, fd);
+ }
+ EXPECT_FALSE(EC);
+ raw_fd_ostream OS(fd, /*shouldClose*/ true);
+ OS << Contents;
+ OS.flush();
+ EXPECT_FALSE(OS.error());
+ if (EC || OS.error())
+ Path.clear();
+ }
+ ~TempFile() {
+ if (!Path.empty()) {
+ EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
+ }
+ }
+
+ /// The path to the file.
+ StringRef path() const { return Path; }
+};
+
} // namespace unittest
} // namespace llvm
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
#include "gtest/gtest.h"
#include <string>
#include <vector>
using namespace llvm;
using namespace sampleprof;
+using llvm::unittest::TempFile;
+
static ::testing::AssertionResult NoError(std::error_code EC) {
if (!EC)
return ::testing::AssertionSuccess();
Reader->collectFuncsFrom(M);
}
- void createRemapFile(SmallVectorImpl<char> &RemapPath, StringRef &RemapFile) {
- std::error_code EC =
- llvm::sys::fs::createTemporaryFile("remapfile", "", RemapPath);
- ASSERT_TRUE(NoError(EC));
- RemapFile = StringRef(RemapPath.data(), RemapPath.size());
-
- std::unique_ptr<raw_fd_ostream> OS(
- new raw_fd_ostream(RemapFile, EC, sys::fs::OF_None));
- *OS << R"(
+ TempFile createRemapFile() {
+ return TempFile("remapfile", "", R"(
# Types 'int' and 'long' are equivalent
type i l
# Function names 'foo' and 'faux' are equivalent
name 3foo 4faux
- )";
- OS->close();
+ )",
+ /*Unique*/ true);
}
// Verify profile summary is consistent in the roundtrip to and from
}
void testRoundTrip(SampleProfileFormat Format, bool Remap, bool UseMD5) {
- SmallVector<char, 128> ProfilePath;
- ASSERT_TRUE(NoError(llvm::sys::fs::createTemporaryFile("profile", "", ProfilePath)));
- StringRef Profile(ProfilePath.data(), ProfilePath.size());
- createWriter(Format, Profile);
+ TempFile ProfileFile("profile", "", "", /*Unique*/ true);
+ createWriter(Format, ProfileFile.path());
if (Format == SampleProfileFormat::SPF_Ext_Binary && UseMD5)
static_cast<SampleProfileWriterExtBinary *>(Writer.get())->setUseMD5();
FunctionType *fn_type =
FunctionType::get(Type::getVoidTy(Context), {}, false);
- SmallVector<char, 128> RemapPath;
- StringRef RemapFile;
+ TempFile RemapFile(createRemapFile());
if (Remap) {
- createRemapFile(RemapPath, RemapFile);
FooName = "_Z4fauxi";
BarName = "_Z3barl";
GooName = "_Z3gool";
Writer->getOutputStream().flush();
- readProfile(M, Profile, RemapFile);
+ readProfile(M, ProfileFile.path(), RemapFile.path());
EC = Reader->read();
ASSERT_TRUE(NoError(EC));
void testSuffixElisionPolicy(SampleProfileFormat Format, StringRef Policy,
const StringMap<uint64_t> &Expected) {
- SmallVector<char, 128> ProfilePath;
- std::error_code EC;
- EC = llvm::sys::fs::createTemporaryFile("profile", "", ProfilePath);
- ASSERT_TRUE(NoError(EC));
- StringRef ProfileFile(ProfilePath.data(), ProfilePath.size());
+ TempFile ProfileFile("profile", "", "", /*Unique*/ true);
Module M("my_module", Context);
setupModuleForElisionTest(&M, Policy);
StringMap<FunctionSamples> ProfMap = setupFcnSamplesForElisionTest(Policy);
// write profile
- createWriter(Format, ProfileFile);
+ createWriter(Format, ProfileFile.path());
+ std::error_code EC;
EC = Writer->write(ProfMap);
ASSERT_TRUE(NoError(EC));
Writer->getOutputStream().flush();
// read profile
- readProfile(M, ProfileFile);
+ readProfile(M, ProfileFile.path());
EC = Reader->read();
ASSERT_TRUE(NoError(EC));
#include "llvm/Support/StringSaver.h"
#include "llvm/Support/VirtualFileSystem.h"
#include "llvm/Support/raw_ostream.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <fstream>
#include <tuple>
using namespace llvm;
+using llvm::unittest::TempDir;
+using llvm::unittest::TempFile;
namespace {
StackOption<bool> TopLevelOpt("top-level", cl::init(false));
// Create response file.
- int FileDescriptor;
- SmallString<64> TempPath;
- std::error_code EC =
- llvm::sys::fs::createTemporaryFile("resp-", ".txt", FileDescriptor, TempPath);
- EXPECT_TRUE(!EC);
-
- std::ofstream RspFile(TempPath.c_str());
- EXPECT_TRUE(RspFile.is_open());
- RspFile << "-top-level\npath\\dir\\file1\npath/dir/file2";
- RspFile.close();
+ TempFile ResponseFile("resp-", ".txt",
+ "-top-level\npath\\dir\\file1\npath/dir/file2",
+ /*Unique*/ true);
llvm::SmallString<128> RspOpt;
RspOpt.append(1, '@');
- RspOpt.append(TempPath.c_str());
+ RspOpt.append(ResponseFile.path());
const char *args[] = {"prog", RspOpt.c_str()};
EXPECT_FALSE(TopLevelOpt);
EXPECT_TRUE(
EXPECT_TRUE(TopLevelOpt);
EXPECT_TRUE(InputFilenames[0] == "path\\dir\\file1");
EXPECT_TRUE(InputFilenames[1] == "path/dir/file2");
-
- llvm::sys::fs::remove(TempPath.c_str());
}
TEST(CommandLineTest, ResponseFiles) {
TEST(CommandLineTest, ReadConfigFile) {
llvm::SmallVector<const char *, 1> Argv;
- llvm::SmallString<128> TestDir;
- std::error_code EC =
- llvm::sys::fs::createUniqueDirectory("unittest", TestDir);
- EXPECT_TRUE(!EC);
+ TempDir TestDir("unittest", /*Unique*/ true);
llvm::SmallString<128> TestCfg;
- llvm::sys::path::append(TestCfg, TestDir, "foo");
- std::ofstream ConfigFile(TestCfg.c_str());
- EXPECT_TRUE(ConfigFile.is_open());
- ConfigFile << "# Comment\n"
- "-option_1\n"
- "@subconfig\n"
- "-option_3=abcd\n"
- "-option_4=\\\n"
- "cdef\n";
- ConfigFile.close();
+ llvm::sys::path::append(TestCfg, TestDir.path(), "foo");
+
+ TempFile ConfigFile(TestCfg, "",
+ "# Comment\n"
+ "-option_1\n"
+ "@subconfig\n"
+ "-option_3=abcd\n"
+ "-option_4=\\\n"
+ "cdef\n");
llvm::SmallString<128> TestCfg2;
- llvm::sys::path::append(TestCfg2, TestDir, "subconfig");
- std::ofstream ConfigFile2(TestCfg2.c_str());
- EXPECT_TRUE(ConfigFile2.is_open());
- ConfigFile2 << "-option_2\n"
- "\n"
- " # comment\n";
- ConfigFile2.close();
+ llvm::sys::path::append(TestCfg2, TestDir.path(), "subconfig");
+ TempFile ConfigFile2(TestCfg2, "",
+ "-option_2\n"
+ "\n"
+ " # comment\n");
// Make sure the current directory is not the directory where config files
// resides. In this case the code that expands response files will not find
// 'subconfig' unless it resolves nested inclusions relative to the including
// file.
llvm::SmallString<128> CurrDir;
- EC = llvm::sys::fs::current_path(CurrDir);
+ std::error_code EC = llvm::sys::fs::current_path(CurrDir);
EXPECT_TRUE(!EC);
- EXPECT_TRUE(StringRef(CurrDir) != StringRef(TestDir));
+ EXPECT_TRUE(StringRef(CurrDir) != TestDir.path());
llvm::BumpPtrAllocator A;
llvm::StringSaver Saver(A);
- bool Result = llvm::cl::readConfigFile(TestCfg, Saver, Argv);
+ bool Result = llvm::cl::readConfigFile(ConfigFile.path(), Saver, Argv);
EXPECT_TRUE(Result);
EXPECT_EQ(Argv.size(), 4U);
EXPECT_STREQ(Argv[1], "-option_2");
EXPECT_STREQ(Argv[2], "-option_3=abcd");
EXPECT_STREQ(Argv[3], "-option_4=cdef");
-
- llvm::sys::fs::remove(TestCfg2);
- llvm::sys::fs::remove(TestCfg);
- llvm::sys::fs::remove(TestDir);
}
TEST(CommandLineTest, PositionalEatArgsError) {
#include "llvm/Support/FileCollector.h"
#include "llvm/Support/FileSystem.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
using namespace llvm;
+using llvm::unittest::TempDir;
+using llvm::unittest::TempFile;
+using llvm::unittest::TempLink;
namespace llvm {
namespace vfs {
}
};
-struct ScopedDir {
- SmallString<128> Path;
- ScopedDir(const Twine &Name, bool Unique = false) {
- std::error_code EC;
- if (Unique) {
- EC = llvm::sys::fs::createUniqueDirectory(Name, Path);
- } else {
- Path = Name.str();
- EC = llvm::sys::fs::create_directory(Twine(Path));
- }
- if (EC)
- Path = "";
- EXPECT_FALSE(EC);
- // Ensure the path is the real path so tests can use it to compare against
- // realpath output.
- SmallString<128> RealPath;
- if (!llvm::sys::fs::real_path(Path, RealPath))
- Path.swap(RealPath);
- }
- ~ScopedDir() {
- if (Path != "") {
- EXPECT_FALSE(llvm::sys::fs::remove_directories(Path.str()));
- }
- }
- operator StringRef() { return Path.str(); }
-};
-
-struct ScopedLink {
- SmallString<128> Path;
- ScopedLink(const Twine &To, const Twine &From) {
- Path = From.str();
- std::error_code EC = sys::fs::create_link(To, From);
- if (EC)
- Path = "";
- EXPECT_FALSE(EC);
- }
- ~ScopedLink() {
- if (Path != "") {
- EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
- }
- }
- operator StringRef() { return Path.str(); }
-};
-
-struct ScopedFile {
- SmallString<128> Path;
- ScopedFile(const Twine &Name) {
- std::error_code EC;
- EC = llvm::sys::fs::createUniqueFile(Name, Path);
- if (EC)
- Path = "";
- EXPECT_FALSE(EC);
- }
- ~ScopedFile() {
- if (Path != "") {
- EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
- }
- }
- operator StringRef() { return Path.str(); }
-};
} // end anonymous namespace
TEST(FileCollectorTest, addFile) {
- ScopedDir root("add_file_root", true);
- std::string root_fs = std::string(root.Path.str());
+ TempDir root("add_file_root", /*Unique*/ true);
+ std::string root_fs(root.path());
TestingFileCollector FileCollector(root_fs, root_fs);
FileCollector.addFile("/path/to/a");
}
TEST(FileCollectorTest, addDirectory) {
- ScopedDir file_root("file_root", true);
+ TempDir file_root("file_root", /*Unique*/ true);
- llvm::SmallString<128> aaa = file_root.Path;
+ llvm::SmallString<128> aaa(file_root.path());
llvm::sys::path::append(aaa, "aaa");
- ScopedFile a(aaa.str());
+ TempFile a(aaa.str());
- llvm::SmallString<128> bbb = file_root.Path;
+ llvm::SmallString<128> bbb(file_root.path());
llvm::sys::path::append(bbb, "bbb");
- ScopedFile b(bbb.str());
+ TempFile b(bbb.str());
- llvm::SmallString<128> ccc = file_root.Path;
+ llvm::SmallString<128> ccc(file_root.path());
llvm::sys::path::append(ccc, "ccc");
- ScopedFile c(ccc.str());
+ TempFile c(ccc.str());
- std::string root_fs = std::string(file_root.Path.str());
+ std::string root_fs(file_root.path());
TestingFileCollector FileCollector(root_fs, root_fs);
- FileCollector.addDirectory(file_root.Path);
+ FileCollector.addDirectory(file_root.path());
// Make sure the root is correct.
EXPECT_EQ(FileCollector.Root, root_fs);
// Make sure we've seen all the added files.
- EXPECT_TRUE(FileCollector.hasSeen(a.Path));
- EXPECT_TRUE(FileCollector.hasSeen(b.Path));
- EXPECT_TRUE(FileCollector.hasSeen(c.Path));
+ EXPECT_TRUE(FileCollector.hasSeen(a.path()));
+ EXPECT_TRUE(FileCollector.hasSeen(b.path()));
+ EXPECT_TRUE(FileCollector.hasSeen(c.path()));
// Make sure we've only seen the added files.
- llvm::SmallString<128> ddd = file_root.Path;
+ llvm::SmallString<128> ddd(file_root.path());
llvm::sys::path::append(ddd, "ddd");
- ScopedFile d(ddd.str());
- EXPECT_FALSE(FileCollector.hasSeen(d.Path));
+ TempFile d(ddd.str(), "", "", /*Unique*/ true);
+ EXPECT_FALSE(FileCollector.hasSeen(d.path()));
}
TEST(FileCollectorTest, copyFiles) {
- ScopedDir file_root("file_root", true);
- ScopedFile a(file_root + "/aaa");
- ScopedFile b(file_root + "/bbb");
- ScopedFile c(file_root + "/ccc");
+ TempDir file_root("file_root", /*Unique*/ true);
+ TempFile a(file_root.path("aaa"));
+ TempFile b(file_root.path("bbb"));
+ TempFile c(file_root.path("ccc"));
// Create file collector and add files.
- ScopedDir root("copy_files_root", true);
- std::string root_fs = std::string(root.Path.str());
+ TempDir root("copy_files_root", /*Unique*/ true);
+ std::string root_fs(root.path());
TestingFileCollector FileCollector(root_fs, root_fs);
- FileCollector.addFile(a.Path);
- FileCollector.addFile(b.Path);
- FileCollector.addFile(c.Path);
+ FileCollector.addFile(a.path());
+ FileCollector.addFile(b.path());
+ FileCollector.addFile(c.path());
// Make sure we can copy the files.
std::error_code ec = FileCollector.copyFiles(true);
}
TEST(FileCollectorTest, recordAndConstructDirectory) {
- ScopedDir file_root("dir_root", true);
- ScopedDir subdir(file_root + "/subdir");
- ScopedDir subdir2(file_root + "/subdir2");
- ScopedFile a(subdir2 + "/a");
+ TempDir file_root("dir_root", /*Unique*/ true);
+ TempDir subdir(file_root.path("subdir"));
+ TempDir subdir2(file_root.path("subdir2"));
+ TempFile a(subdir2.path("a"));
// Create file collector and add files.
- ScopedDir root("copy_files_root", true);
- std::string root_fs = std::string(root.Path.str());
+ TempDir root("copy_files_root", /*Unique*/ true);
+ std::string root_fs(root.path());
TestingFileCollector FileCollector(root_fs, root_fs);
- FileCollector.addFile(a.Path);
+ FileCollector.addFile(a.path());
// The empty directory isn't seen until we add it.
- EXPECT_TRUE(FileCollector.hasSeen(a.Path));
- EXPECT_FALSE(FileCollector.hasSeen(subdir.Path));
+ EXPECT_TRUE(FileCollector.hasSeen(a.path()));
+ EXPECT_FALSE(FileCollector.hasSeen(subdir.path()));
- FileCollector.addFile(subdir.Path);
- EXPECT_TRUE(FileCollector.hasSeen(subdir.Path));
+ FileCollector.addFile(subdir.path());
+ EXPECT_TRUE(FileCollector.hasSeen(subdir.path()));
// Make sure we can construct the directory.
std::error_code ec = FileCollector.copyFiles(true);
EXPECT_FALSE(ec);
bool IsDirectory = false;
- llvm::SmallString<128> SubdirInRoot = root.Path;
+ llvm::SmallString<128> SubdirInRoot = root.path();
llvm::sys::path::append(SubdirInRoot,
- llvm::sys::path::relative_path(subdir.Path));
+ llvm::sys::path::relative_path(subdir.path()));
ec = sys::fs::is_directory(SubdirInRoot, IsDirectory);
EXPECT_FALSE(ec);
ASSERT_TRUE(IsDirectory);
}
TEST(FileCollectorTest, recordVFSAccesses) {
- ScopedDir file_root("dir_root", true);
- ScopedDir subdir(file_root + "/subdir");
- ScopedDir subdir2(file_root + "/subdir2");
- ScopedFile a(subdir2 + "/a");
- ScopedFile b(file_root + "/b");
- ScopedDir subdir3(file_root + "/subdir3");
- ScopedFile subdir3a(subdir3 + "/aa");
- ScopedDir subdir3b(subdir3 + "/subdirb");
- {
- ScopedFile subdir3fileremoved(subdir3 + "/removed");
- }
+ TempDir file_root("dir_root", /*Unique*/ true);
+ TempDir subdir(file_root.path("subdir"));
+ TempDir subdir2(file_root.path("subdir2"));
+ TempFile a(subdir2.path("a"));
+ TempFile b(file_root.path("b"));
+ TempDir subdir3(file_root.path("subdir3"));
+ TempFile subdir3a(subdir3.path("aa"));
+ TempDir subdir3b(subdir3.path("subdirb"));
+ { TempFile subdir3fileremoved(subdir3.path("removed")); }
// Create file collector and add files.
- ScopedDir root("copy_files_root", true);
- std::string root_fs = std::string(root.Path.str());
+ TempDir root("copy_files_root", /*Unique*/ true);
+ std::string root_fs(root.path());
auto Collector = std::make_shared<TestingFileCollector>(root_fs, root_fs);
auto VFS =
FileCollector::createCollectorVFS(vfs::getRealFileSystem(), Collector);
- VFS->status(a.Path);
- EXPECT_TRUE(Collector->hasSeen(a.Path));
+ VFS->status(a.path());
+ EXPECT_TRUE(Collector->hasSeen(a.path()));
- VFS->openFileForRead(b.Path);
- EXPECT_TRUE(Collector->hasSeen(b.Path));
+ VFS->openFileForRead(b.path());
+ EXPECT_TRUE(Collector->hasSeen(b.path()));
- VFS->status(subdir.Path);
- EXPECT_TRUE(Collector->hasSeen(subdir.Path));
+ VFS->status(subdir.path());
+ EXPECT_TRUE(Collector->hasSeen(subdir.path()));
#ifndef _WIN32
std::error_code EC;
- auto It = VFS->dir_begin(subdir3.Path, EC);
+ auto It = VFS->dir_begin(subdir3.path(), EC);
EXPECT_FALSE(EC);
- EXPECT_TRUE(Collector->hasSeen(subdir3.Path));
- EXPECT_TRUE(Collector->hasSeen(subdir3a.Path));
- EXPECT_TRUE(Collector->hasSeen(subdir3b.Path));
- std::string RemovedFileName = (Twine(subdir3.Path) + "/removed").str();
+ EXPECT_TRUE(Collector->hasSeen(subdir3.path()));
+ EXPECT_TRUE(Collector->hasSeen(subdir3a.path()));
+ EXPECT_TRUE(Collector->hasSeen(subdir3b.path()));
+ std::string RemovedFileName((Twine(subdir3.path("removed"))).str());
EXPECT_FALSE(Collector->hasSeen(RemovedFileName));
#endif
}
#ifndef _WIN32
TEST(FileCollectorTest, Symlinks) {
// Root where the original files live.
- ScopedDir file_root("file_root", true);
+ TempDir file_root("file_root", /*Unique*/ true);
// Create some files in the file root.
- ScopedFile a(file_root + "/aaa");
- ScopedFile b(file_root + "/bbb");
- ScopedFile c(file_root + "/ccc");
+ TempFile a(file_root.path("aaa"));
+ TempFile b(file_root.path("bbb"));
+ TempFile c(file_root.path("ccc"));
// Create a directory foo with file ddd.
- ScopedDir foo(file_root + "/foo");
- ScopedFile d(foo + "/ddd");
+ TempDir foo(file_root.path("foo"));
+ TempFile d(foo.path("ddd"));
// Create a file eee in the foo's parent directory.
- ScopedFile e(foo + "/../eee");
+ TempFile e(foo.path("../eee"));
// Create a symlink bar pointing to foo.
- ScopedLink symlink(file_root + "/foo", file_root + "/bar");
+ TempLink symlink(file_root.path("foo"), file_root.path("bar"));
// Root where files are copied to.
- ScopedDir reproducer_root("reproducer_root", true);
- std::string root_fs = std::string(reproducer_root.Path.str());
+ TempDir reproducer_root("reproducer_root", /*Unique*/ true);
+ std::string root_fs(reproducer_root.path());
TestingFileCollector FileCollector(root_fs, root_fs);
// Add all the files to the collector.
- FileCollector.addFile(a.Path);
- FileCollector.addFile(b.Path);
- FileCollector.addFile(c.Path);
- FileCollector.addFile(d.Path);
- FileCollector.addFile(e.Path);
- FileCollector.addFile(file_root + "/bar/ddd");
+ FileCollector.addFile(a.path());
+ FileCollector.addFile(b.path());
+ FileCollector.addFile(c.path());
+ FileCollector.addFile(d.path());
+ FileCollector.addFile(e.path());
+ FileCollector.addFile(file_root.path() + "/bar/ddd");
auto mapping = FileCollector.VFSWriter.getMappings();
{
// Make sure the common case works.
- std::string vpath = (file_root + "/aaa").str();
- std::string rpath = (reproducer_root.Path + file_root.Path + "/aaa").str();
+ std::string vpath = (file_root.path() + "/aaa").str();
+ std::string rpath =
+ (reproducer_root.path() + file_root.path() + "/aaa").str();
printf("%s -> %s\n", vpath.c_str(), rpath.c_str());
EXPECT_THAT(mapping, testing::Contains(vfs::YAMLVFSEntry(vpath, rpath)));
}
{
// Make sure the virtual path points to the real source path.
- std::string vpath = (file_root + "/bar/ddd").str();
+ std::string vpath = (file_root.path() + "/bar/ddd").str();
std::string rpath =
- (reproducer_root.Path + file_root.Path + "/foo/ddd").str();
+ (reproducer_root.path() + file_root.path() + "/foo/ddd").str();
printf("%s -> %s\n", vpath.c_str(), rpath.c_str());
EXPECT_THAT(mapping, testing::Contains(vfs::YAMLVFSEntry(vpath, rpath)));
}
{
// Make sure that .. is removed from the source path.
- std::string vpath = (file_root + "/eee").str();
- std::string rpath = (reproducer_root.Path + file_root.Path + "/eee").str();
+ std::string vpath = (file_root.path() + "/eee").str();
+ std::string rpath =
+ (reproducer_root.path() + file_root.path() + "/eee").str();
printf("%s -> %s\n", vpath.c_str(), rpath.c_str());
EXPECT_THAT(mapping, testing::Contains(vfs::YAMLVFSEntry(vpath, rpath)));
}
}
TEST(FileCollectorTest, recordVFSSymlinkAccesses) {
- ScopedDir file_root("dir_root", true);
- ScopedFile a(file_root + "/a");
- ScopedLink symlink(file_root + "/a", file_root + "/b");
+ TempDir file_root("dir_root", /*Unique*/ true);
+ TempFile a(file_root.path("a"));
+ TempLink symlink(file_root.path("a"), file_root.path("b"));
// Create file collector and add files.
- ScopedDir root("copy_files_root", true);
- std::string root_fs = std::string(root.Path.str());
+ TempDir root("copy_files_root", true);
+ std::string root_fs(root.path());
auto Collector = std::make_shared<TestingFileCollector>(root_fs, root_fs);
auto VFS =
FileCollector::createCollectorVFS(vfs::getRealFileSystem(), Collector);
SmallString<256> Output;
- VFS->getRealPath(symlink.Path, Output);
- EXPECT_TRUE(Collector->hasSeen(a.Path));
- EXPECT_TRUE(Collector->hasSeen(symlink.Path));
+ VFS->getRealPath(symlink.path(), Output);
+ EXPECT_TRUE(Collector->hasSeen(a.path()));
+ EXPECT_TRUE(Collector->hasSeen(symlink.path()));
}
#endif
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
#include "gtest/gtest.h"
#include <fstream>
using namespace llvm;
using namespace llvm::sys;
+using llvm::unittest::TempDir;
+
#define ASSERT_NO_ERROR(x) \
if (std::error_code ASSERT_NO_ERROR_ec = x) { \
SmallString<128> MessageStorage; \
namespace {
TEST(writeFileAtomicallyTest, Test) {
// Create unique temporary directory for these tests
- SmallString<128> RootTestDirectory;
- ASSERT_NO_ERROR(
- fs::createUniqueDirectory("writeFileAtomicallyTest", RootTestDirectory));
+ TempDir RootTestDirectory("writeFileAtomicallyTest", /*Unique*/ true);
- SmallString<128> FinalTestfilePath(RootTestDirectory);
+ SmallString<128> FinalTestfilePath(RootTestDirectory.path());
sys::path::append(FinalTestfilePath, "foo.txt");
const std::string TempUniqTestFileModel =
std::string(FinalTestfilePath) + "-%%%%%%%%";
#include "llvm/Support/LockFileManager.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
#include "gtest/gtest.h"
#include <memory>
using namespace llvm;
+using llvm::unittest::TempDir;
namespace {
TEST(LockFileManagerTest, Basic) {
- SmallString<64> TmpDir;
- std::error_code EC;
- EC = sys::fs::createUniqueDirectory("LockFileManagerTestDir", TmpDir);
- ASSERT_FALSE(EC);
+ TempDir TmpDir("LockFileManagerTestDir", /*Unique*/ true);
- SmallString<64> LockedFile(TmpDir);
+ SmallString<64> LockedFile(TmpDir.path());
sys::path::append(LockedFile, "file.lock");
{
// Now that the lock is out of scope, the file should be gone.
EXPECT_FALSE(sys::fs::exists(StringRef(LockedFile)));
-
- EC = sys::fs::remove(StringRef(TmpDir));
- ASSERT_FALSE(EC);
}
TEST(LockFileManagerTest, LinkLockExists) {
- SmallString<64> TmpDir;
- std::error_code EC;
- EC = sys::fs::createUniqueDirectory("LockFileManagerTestDir", TmpDir);
- ASSERT_FALSE(EC);
+ TempDir LockFileManagerTestDir("LockFileManagerTestDir", /*Unique*/ true);
- SmallString<64> LockedFile(TmpDir);
+ SmallString<64> LockedFile(LockFileManagerTestDir.path());
sys::path::append(LockedFile, "file");
- SmallString<64> FileLocK(TmpDir);
+ SmallString<64> FileLocK(LockFileManagerTestDir.path());
sys::path::append(FileLocK, "file.lock");
- SmallString<64> TmpFileLock(TmpDir);
+ SmallString<64> TmpFileLock(LockFileManagerTestDir.path());
sys::path::append(TmpFileLock, "file.lock-000");
int FD;
- EC = sys::fs::openFileForWrite(StringRef(TmpFileLock), FD);
+ std::error_code EC = sys::fs::openFileForWrite(StringRef(TmpFileLock), FD);
ASSERT_FALSE(EC);
int Ret = close(FD);
// Now that the lock is out of scope, the file should be gone.
EXPECT_FALSE(sys::fs::exists(StringRef(LockedFile)));
-
- EC = sys::fs::remove(StringRef(TmpDir));
- ASSERT_FALSE(EC);
}
TEST(LockFileManagerTest, RelativePath) {
- SmallString<64> TmpDir;
- std::error_code EC;
- EC = sys::fs::createUniqueDirectory("LockFileManagerTestDir", TmpDir);
- ASSERT_FALSE(EC);
+ TempDir LockFileManagerTestDir("LockFileManagerTestDir", /*Unique*/ true);
char PathBuf[1024];
const char *OrigPath = getcwd(PathBuf, 1024);
- ASSERT_FALSE(chdir(TmpDir.c_str()));
+ ASSERT_FALSE(chdir(LockFileManagerTestDir.path().data()));
- sys::fs::create_directory("inner");
- SmallString<64> LockedFile("inner");
+ TempDir inner("inner");
+ SmallString<64> LockedFile(inner.path());
sys::path::append(LockedFile, "file");
SmallString<64> FileLock(LockedFile);
EXPECT_FALSE(sys::fs::exists(LockedFile.str()));
EXPECT_FALSE(sys::fs::exists(FileLock.str()));
- EC = sys::fs::remove("inner");
- ASSERT_FALSE(EC);
-
ASSERT_FALSE(chdir(OrigPath));
-
- EC = sys::fs::remove(StringRef(TmpDir));
- ASSERT_FALSE(EC);
}
} // end anonymous namespace
#include "llvm/Support/TarWriter.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
#include "gtest/gtest.h"
#include <vector>
using namespace llvm;
+using llvm::unittest::TempFile;
+
namespace {
struct UstarHeader {
class TarWriterTest : public ::testing::Test {};
static std::vector<uint8_t> createTar(StringRef Base, StringRef Filename) {
- // Create a temporary file.
- SmallString<128> Path;
- std::error_code EC =
- sys::fs::createTemporaryFile("TarWriterTest", "tar", Path);
- EXPECT_FALSE((bool)EC);
+ TempFile TarWriterTest("TarWriterTest", "tar", "", /*Unique*/ true);
// Create a tar file.
- Expected<std::unique_ptr<TarWriter>> TarOrErr = TarWriter::create(Path, Base);
+ Expected<std::unique_ptr<TarWriter>> TarOrErr =
+ TarWriter::create(TarWriterTest.path(), Base);
EXPECT_TRUE((bool)TarOrErr);
std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
Tar->append(Filename, "contents");
Tar.reset();
// Read the tar file.
- ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(Path);
+ ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
+ MemoryBuffer::getFile(TarWriterTest.path());
EXPECT_TRUE((bool)MBOrErr);
std::unique_ptr<MemoryBuffer> MB = std::move(*MBOrErr);
std::vector<uint8_t> Buf((const uint8_t *)MB->getBufferStart(),
// Windows does not allow us to remove a mmap'ed files, so
// unmap first and then remove the temporary file.
MB = nullptr;
- sys::fs::remove(Path);
return Buf;
}
}
TEST_F(TarWriterTest, SingleFile) {
- SmallString<128> Path;
- std::error_code EC =
- sys::fs::createTemporaryFile("TarWriterTest", "tar", Path);
- EXPECT_FALSE((bool)EC);
+ TempFile TarWriterTest("TarWriterTest", "tar", "", /*Unique*/ true);
- Expected<std::unique_ptr<TarWriter>> TarOrErr = TarWriter::create(Path, "");
+ Expected<std::unique_ptr<TarWriter>> TarOrErr =
+ TarWriter::create(TarWriterTest.path(), "");
EXPECT_TRUE((bool)TarOrErr);
std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
Tar->append("FooPath", "foo");
Tar.reset();
uint64_t TarSize;
- EC = sys::fs::file_size(Path, TarSize);
+ std::error_code EC = sys::fs::file_size(TarWriterTest.path(), TarSize);
EXPECT_FALSE((bool)EC);
EXPECT_EQ(TarSize, 2048ULL);
}
TEST_F(TarWriterTest, NoDuplicate) {
- SmallString<128> Path;
- std::error_code EC =
- sys::fs::createTemporaryFile("TarWriterTest", "tar", Path);
- EXPECT_FALSE((bool)EC);
+ TempFile TarWriterTest("TarWriterTest", "tar", "", /*Unique*/ true);
- Expected<std::unique_ptr<TarWriter>> TarOrErr = TarWriter::create(Path, "");
+ Expected<std::unique_ptr<TarWriter>> TarOrErr =
+ TarWriter::create(TarWriterTest.path(), "");
EXPECT_TRUE((bool)TarOrErr);
std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
Tar->append("FooPath", "foo");
Tar.reset();
uint64_t TarSize;
- EC = sys::fs::file_size(Path, TarSize);
+ std::error_code EC = sys::fs::file_size(TarWriterTest.path(), TarSize);
EXPECT_FALSE((bool)EC);
EXPECT_EQ(TarSize, 3072ULL);
}
TEST_F(TarWriterTest, Duplicate) {
- SmallString<128> Path;
- std::error_code EC =
- sys::fs::createTemporaryFile("TarWriterTest", "tar", Path);
- EXPECT_FALSE((bool)EC);
+ TempFile TarWriterTest("TarWriterTest", "tar", "", /*Unique*/ true);
- Expected<std::unique_ptr<TarWriter>> TarOrErr = TarWriter::create(Path, "");
+ Expected<std::unique_ptr<TarWriter>> TarOrErr =
+ TarWriter::create(TarWriterTest.path(), "");
EXPECT_TRUE((bool)TarOrErr);
std::unique_ptr<TarWriter> Tar = std::move(*TarOrErr);
Tar->append("FooPath", "foo");
Tar.reset();
uint64_t TarSize;
- EC = sys::fs::file_size(Path, TarSize);
+ std::error_code EC = sys::fs::file_size(TarWriterTest.path(), TarSize);
EXPECT_FALSE((bool)EC);
EXPECT_EQ(TarSize, 2048ULL);
}
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/SourceMgr.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include <map>
using namespace llvm;
using llvm::sys::fs::UniqueID;
+using llvm::unittest::TempDir;
+using llvm::unittest::TempFile;
+using llvm::unittest::TempLink;
using testing::ElementsAre;
using testing::Pair;
using testing::UnorderedElementsAre;
}
}
-namespace {
-struct ScopedDir {
- SmallString<128> Path;
- ScopedDir(const Twine &Name, bool Unique = false) {
- std::error_code EC;
- if (Unique) {
- EC = llvm::sys::fs::createUniqueDirectory(Name, Path);
- if (!EC) {
- // Resolve any symlinks in the new directory.
- std::string UnresolvedPath = std::string(Path.str());
- EC = llvm::sys::fs::real_path(UnresolvedPath, Path);
- }
- } else {
- Path = Name.str();
- EC = llvm::sys::fs::create_directory(Twine(Path));
- }
- if (EC)
- Path = "";
- EXPECT_FALSE(EC) << EC.message();
- }
- ~ScopedDir() {
- if (Path != "") {
- EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
- }
- }
- operator StringRef() { return Path.str(); }
-};
-
-struct ScopedLink {
- SmallString<128> Path;
- ScopedLink(const Twine &To, const Twine &From) {
- Path = From.str();
- std::error_code EC = sys::fs::create_link(To, From);
- if (EC)
- Path = "";
- EXPECT_FALSE(EC);
- }
- ~ScopedLink() {
- if (Path != "") {
- EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
- }
- }
- operator StringRef() { return Path.str(); }
-};
-
-struct ScopedFile {
- SmallString<128> Path;
- ScopedFile(const Twine &Path, StringRef Contents) {
- Path.toVector(this->Path);
- std::error_code EC;
- raw_fd_ostream OS(this->Path, EC);
- EXPECT_FALSE(EC);
- OS << Contents;
- OS.flush();
- EXPECT_FALSE(OS.error());
- if (EC || OS.error())
- this->Path = "";
- }
- ~ScopedFile() {
- if (Path != "") {
- EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
- }
- }
-};
-} // end anonymous namespace
-
TEST(VirtualFileSystemTest, BasicRealFSIteration) {
- ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
+ TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
std::error_code EC;
- vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory), EC);
+ vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory.path()), EC);
ASSERT_FALSE(EC);
EXPECT_EQ(vfs::directory_iterator(), I); // empty directory is empty
- ScopedDir _a(TestDirectory + "/a");
- ScopedDir _ab(TestDirectory + "/a/b");
- ScopedDir _c(TestDirectory + "/c");
- ScopedDir _cd(TestDirectory + "/c/d");
+ TempDir _a(TestDirectory.path("a"));
+ TempDir _ab(TestDirectory.path("a/b"));
+ TempDir _c(TestDirectory.path("c"));
+ TempDir _cd(TestDirectory.path("c/d"));
- I = FS->dir_begin(Twine(TestDirectory), EC);
+ I = FS->dir_begin(Twine(TestDirectory.path()), EC);
ASSERT_FALSE(EC);
ASSERT_NE(vfs::directory_iterator(), I);
// Check either a or c, since we can't rely on the iteration order.
// Our root contains a/aa, b/bb, c, where c is a link to a/.
// Run tests both in root/b/ and root/c/ (to test "normal" and symlink dirs).
// Interleave operations to show the working directories are independent.
- ScopedDir Root("r", true), ADir(Root.Path + "/a"), BDir(Root.Path + "/b");
- ScopedLink C(ADir.Path, Root.Path + "/c");
- ScopedFile AA(ADir.Path + "/aa", "aaaa"), BB(BDir.Path + "/bb", "bbbb");
+ TempDir Root("r", /*Unique*/ true);
+ TempDir ADir(Root.path("a"));
+ TempDir BDir(Root.path("b"));
+ TempLink C(ADir.path(), Root.path("c"));
+ TempFile AA(ADir.path("aa"), "", "aaaa");
+ TempFile BB(BDir.path("bb"), "", "bbbb");
std::unique_ptr<vfs::FileSystem> BFS = vfs::createPhysicalFileSystem(),
CFS = vfs::createPhysicalFileSystem();
- ASSERT_FALSE(BFS->setCurrentWorkingDirectory(BDir.Path));
- ASSERT_FALSE(CFS->setCurrentWorkingDirectory(C.Path));
- EXPECT_EQ(BDir.Path, *BFS->getCurrentWorkingDirectory());
- EXPECT_EQ(C.Path, *CFS->getCurrentWorkingDirectory());
+ ASSERT_FALSE(BFS->setCurrentWorkingDirectory(BDir.path()));
+ ASSERT_FALSE(CFS->setCurrentWorkingDirectory(C.path()));
+ EXPECT_EQ(BDir.path(), *BFS->getCurrentWorkingDirectory());
+ EXPECT_EQ(C.path(), *CFS->getCurrentWorkingDirectory());
// openFileForRead(), indirectly.
auto BBuf = BFS->getBufferForFile("bb");
// getRealPath()
SmallString<128> BPath;
ASSERT_FALSE(BFS->getRealPath("bb", BPath));
- EXPECT_EQ(BB.Path, BPath);
+ EXPECT_EQ(BB.path(), BPath);
SmallString<128> APath;
ASSERT_FALSE(CFS->getRealPath("aa", APath));
- EXPECT_EQ(AA.Path, APath); // Reports resolved name.
+ EXPECT_EQ(AA.path(), APath); // Reports resolved name.
// dir_begin
std::error_code EC;
auto BIt = BFS->dir_begin(".", EC);
ASSERT_FALSE(EC);
ASSERT_NE(BIt, vfs::directory_iterator());
- EXPECT_EQ((BDir.Path + "/./bb").str(), BIt->path());
+ EXPECT_EQ((BDir.path() + "/./bb").str(), BIt->path());
BIt.increment(EC);
ASSERT_FALSE(EC);
ASSERT_EQ(BIt, vfs::directory_iterator());
auto CIt = CFS->dir_begin(".", EC);
ASSERT_FALSE(EC);
ASSERT_NE(CIt, vfs::directory_iterator());
- EXPECT_EQ((ADir.Path + "/./aa").str(), CIt->path()); // Partly resolved name!
+ EXPECT_EQ((ADir.path() + "/./aa").str(),
+ CIt->path()); // Partly resolved name!
CIt.increment(EC); // Because likely to read through this path.
ASSERT_FALSE(EC);
ASSERT_EQ(CIt, vfs::directory_iterator());
}
TEST(VirtualFileSystemTest, BrokenSymlinkRealFSIteration) {
- ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
+ TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
- ScopedLink _a("no_such_file", TestDirectory + "/a");
- ScopedDir _b(TestDirectory + "/b");
- ScopedLink _c("no_such_file", TestDirectory + "/c");
+ TempLink _a("no_such_file", TestDirectory.path("a"));
+ TempDir _b(TestDirectory.path("b"));
+ TempLink _c("no_such_file", TestDirectory.path("c"));
// Should get no iteration error, but a stat error for the broken symlinks.
std::map<std::string, std::error_code> StatResults;
std::error_code EC;
- for (vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory), EC), E;
+ for (vfs::directory_iterator
+ I = FS->dir_begin(Twine(TestDirectory.path()), EC),
+ E;
I != E; I.increment(EC)) {
EXPECT_FALSE(EC);
StatResults[std::string(sys::path::filename(I->path()))] =
#endif
TEST(VirtualFileSystemTest, BasicRealFSRecursiveIteration) {
- ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
+ TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
std::error_code EC;
- auto I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC);
+ auto I =
+ vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC);
ASSERT_FALSE(EC);
EXPECT_EQ(vfs::recursive_directory_iterator(), I); // empty directory is empty
- ScopedDir _a(TestDirectory + "/a");
- ScopedDir _ab(TestDirectory + "/a/b");
- ScopedDir _c(TestDirectory + "/c");
- ScopedDir _cd(TestDirectory + "/c/d");
+ TempDir _a(TestDirectory.path("a"));
+ TempDir _ab(TestDirectory.path("a/b"));
+ TempDir _c(TestDirectory.path("c"));
+ TempDir _cd(TestDirectory.path("c/d"));
- I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC);
+ I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC);
ASSERT_FALSE(EC);
ASSERT_NE(vfs::recursive_directory_iterator(), I);
}
TEST(VirtualFileSystemTest, BasicRealFSRecursiveIterationNoPush) {
- ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
+ TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
- ScopedDir _a(TestDirectory + "/a");
- ScopedDir _ab(TestDirectory + "/a/b");
- ScopedDir _c(TestDirectory + "/c");
- ScopedDir _cd(TestDirectory + "/c/d");
- ScopedDir _e(TestDirectory + "/e");
- ScopedDir _ef(TestDirectory + "/e/f");
- ScopedDir _g(TestDirectory + "/g");
+ TempDir _a(TestDirectory.path("a"));
+ TempDir _ab(TestDirectory.path("a/b"));
+ TempDir _c(TestDirectory.path("c"));
+ TempDir _cd(TestDirectory.path("c/d"));
+ TempDir _e(TestDirectory.path("e"));
+ TempDir _ef(TestDirectory.path("e/f"));
+ TempDir _g(TestDirectory.path("g"));
IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
// Test that calling no_push on entries without subdirectories has no effect.
{
std::error_code EC;
- auto I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC);
+ auto I =
+ vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC);
ASSERT_FALSE(EC);
std::vector<std::string> Contents;
// Test that calling no_push skips subdirectories.
{
std::error_code EC;
- auto I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC);
+ auto I =
+ vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC);
ASSERT_FALSE(EC);
std::vector<std::string> Contents;
#ifdef LLVM_ON_UNIX
TEST(VirtualFileSystemTest, BrokenSymlinkRealFSRecursiveIteration) {
- ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
+ TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
- ScopedLink _a("no_such_file", TestDirectory + "/a");
- ScopedDir _b(TestDirectory + "/b");
- ScopedLink _ba("no_such_file", TestDirectory + "/b/a");
- ScopedDir _bb(TestDirectory + "/b/b");
- ScopedLink _bc("no_such_file", TestDirectory + "/b/c");
- ScopedLink _c("no_such_file", TestDirectory + "/c");
- ScopedDir _d(TestDirectory + "/d");
- ScopedDir _dd(TestDirectory + "/d/d");
- ScopedDir _ddd(TestDirectory + "/d/d/d");
- ScopedLink _e("no_such_file", TestDirectory + "/e");
+ TempLink _a("no_such_file", TestDirectory.path("a"));
+ TempDir _b(TestDirectory.path("b"));
+ TempLink _ba("no_such_file", TestDirectory.path("b/a"));
+ TempDir _bb(TestDirectory.path("b/b"));
+ TempLink _bc("no_such_file", TestDirectory.path("b/c"));
+ TempLink _c("no_such_file", TestDirectory.path("c"));
+ TempDir _d(TestDirectory.path("d"));
+ TempDir _dd(TestDirectory.path("d/d"));
+ TempDir _ddd(TestDirectory.path("d/d/d"));
+ TempLink _e("no_such_file", TestDirectory.path("e"));
std::vector<std::string> VisitedBrokenSymlinks;
std::vector<std::string> VisitedNonBrokenSymlinks;
std::error_code EC;
- for (vfs::recursive_directory_iterator I(*FS, Twine(TestDirectory), EC), E;
+ for (vfs::recursive_directory_iterator
+ I(*FS, Twine(TestDirectory.path()), EC),
+ E;
I != E; I.increment(EC)) {
EXPECT_FALSE(EC);
(FS->status(I->path()) ? VisitedNonBrokenSymlinks : VisitedBrokenSymlinks)
// Check visited file names.
EXPECT_THAT(VisitedBrokenSymlinks,
- UnorderedElementsAre(StringRef(_a).str(), StringRef(_ba).str(),
- StringRef(_bc).str(), StringRef(_c).str(),
- StringRef(_e).str()));
+ UnorderedElementsAre(_a.path().str(), _ba.path().str(),
+ _bc.path().str(), _c.path().str(),
+ _e.path().str()));
EXPECT_THAT(VisitedNonBrokenSymlinks,
- UnorderedElementsAre(StringRef(_b).str(), StringRef(_bb).str(),
- StringRef(_d).str(), StringRef(_dd).str(),
- StringRef(_ddd).str()));
+ UnorderedElementsAre(_b.path().str(), _bb.path().str(),
+ _d.path().str(), _dd.path().str(),
+ _ddd.path().str()));
}
#endif
}
TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest) {
- ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
- ScopedDir _a(TestDirectory + "/a");
- ScopedFile _ab(TestDirectory + "/a/b", "");
- ScopedDir _c(TestDirectory + "/c");
- ScopedFile _cd(TestDirectory + "/c/d", "");
- ScopedDir _e(TestDirectory + "/e");
- ScopedDir _ef(TestDirectory + "/e/f");
- ScopedFile _g(TestDirectory + "/g", "");
- ScopedDir _h(TestDirectory + "/h");
+ TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
+ TempDir _a(TestDirectory.path("a"));
+ TempFile _ab(TestDirectory.path("a, b"));
+ TempDir _c(TestDirectory.path("c"));
+ TempFile _cd(TestDirectory.path("c/d"));
+ TempDir _e(TestDirectory.path("e"));
+ TempDir _ef(TestDirectory.path("e/f"));
+ TempFile _g(TestDirectory.path("g"));
+ TempDir _h(TestDirectory.path("h"));
vfs::YAMLVFSWriter VFSWriter;
- VFSWriter.addDirectoryMapping(_a.Path, "//root/a");
- VFSWriter.addFileMapping(_ab.Path, "//root/a/b");
- VFSWriter.addFileMapping(_cd.Path, "//root/c/d");
- VFSWriter.addDirectoryMapping(_e.Path, "//root/e");
- VFSWriter.addDirectoryMapping(_ef.Path, "//root/e/f");
- VFSWriter.addFileMapping(_g.Path, "//root/g");
- VFSWriter.addDirectoryMapping(_h.Path, "//root/h");
+ VFSWriter.addDirectoryMapping(_a.path(), "//root/a");
+ VFSWriter.addFileMapping(_ab.path(), "//root/a/b");
+ VFSWriter.addFileMapping(_cd.path(), "//root/c/d");
+ VFSWriter.addDirectoryMapping(_e.path(), "//root/e");
+ VFSWriter.addDirectoryMapping(_ef.path(), "//root/e/f");
+ VFSWriter.addFileMapping(_g.path(), "//root/g");
+ VFSWriter.addDirectoryMapping(_h.path(), "//root/h");
std::string Buffer;
raw_string_ostream OS(Buffer);
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
ASSERT_TRUE(FS.get() != nullptr);
- EXPECT_TRUE(FS->exists(_a.Path));
- EXPECT_TRUE(FS->exists(_ab.Path));
- EXPECT_TRUE(FS->exists(_c.Path));
- EXPECT_TRUE(FS->exists(_cd.Path));
- EXPECT_TRUE(FS->exists(_e.Path));
- EXPECT_TRUE(FS->exists(_ef.Path));
- EXPECT_TRUE(FS->exists(_g.Path));
- EXPECT_TRUE(FS->exists(_h.Path));
+ EXPECT_TRUE(FS->exists(_a.path()));
+ EXPECT_TRUE(FS->exists(_ab.path()));
+ EXPECT_TRUE(FS->exists(_c.path()));
+ EXPECT_TRUE(FS->exists(_cd.path()));
+ EXPECT_TRUE(FS->exists(_e.path()));
+ EXPECT_TRUE(FS->exists(_ef.path()));
+ EXPECT_TRUE(FS->exists(_g.path()));
+ EXPECT_TRUE(FS->exists(_h.path()));
}
TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest2) {
- ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
- ScopedDir _a(TestDirectory + "/a");
- ScopedFile _ab(TestDirectory + "/a/b", "");
- ScopedDir _ac(TestDirectory + "/a/c");
- ScopedFile _acd(TestDirectory + "/a/c/d", "");
- ScopedFile _ace(TestDirectory + "/a/c/e", "");
- ScopedFile _acf(TestDirectory + "/a/c/f", "");
- ScopedDir _ag(TestDirectory + "/a/g");
- ScopedFile _agh(TestDirectory + "/a/g/h", "");
+ TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
+ TempDir _a(TestDirectory.path("a"));
+ TempFile _ab(TestDirectory.path("a/b"));
+ TempDir _ac(TestDirectory.path("a/c"));
+ TempFile _acd(TestDirectory.path("a/c/d"));
+ TempFile _ace(TestDirectory.path("a/c/e"));
+ TempFile _acf(TestDirectory.path("a/c/f"));
+ TempDir _ag(TestDirectory.path("a/g"));
+ TempFile _agh(TestDirectory.path("a/g/h"));
vfs::YAMLVFSWriter VFSWriter;
- VFSWriter.addDirectoryMapping(_a.Path, "//root/a");
- VFSWriter.addFileMapping(_ab.Path, "//root/a/b");
- VFSWriter.addDirectoryMapping(_ac.Path, "//root/a/c");
- VFSWriter.addFileMapping(_acd.Path, "//root/a/c/d");
- VFSWriter.addFileMapping(_ace.Path, "//root/a/c/e");
- VFSWriter.addFileMapping(_acf.Path, "//root/a/c/f");
- VFSWriter.addDirectoryMapping(_ag.Path, "//root/a/g");
- VFSWriter.addFileMapping(_agh.Path, "//root/a/g/h");
+ VFSWriter.addDirectoryMapping(_a.path(), "//root/a");
+ VFSWriter.addFileMapping(_ab.path(), "//root/a/b");
+ VFSWriter.addDirectoryMapping(_ac.path(), "//root/a/c");
+ VFSWriter.addFileMapping(_acd.path(), "//root/a/c/d");
+ VFSWriter.addFileMapping(_ace.path(), "//root/a/c/e");
+ VFSWriter.addFileMapping(_acf.path(), "//root/a/c/f");
+ VFSWriter.addDirectoryMapping(_ag.path(), "//root/a/g");
+ VFSWriter.addFileMapping(_agh.path(), "//root/a/g/h");
std::string Buffer;
raw_string_ostream OS(Buffer);
}
TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest3) {
- ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
- ScopedDir _a(TestDirectory + "/a");
- ScopedFile _ab(TestDirectory + "/a/b", "");
- ScopedDir _ac(TestDirectory + "/a/c");
- ScopedDir _acd(TestDirectory + "/a/c/d");
- ScopedDir _acde(TestDirectory + "/a/c/d/e");
- ScopedFile _acdef(TestDirectory + "/a/c/d/e/f", "");
- ScopedFile _acdeg(TestDirectory + "/a/c/d/e/g", "");
- ScopedDir _ah(TestDirectory + "/a/h");
- ScopedFile _ahi(TestDirectory + "/a/h/i", "");
+ TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
+ TempDir _a(TestDirectory.path("a"));
+ TempFile _ab(TestDirectory.path("a/b"));
+ TempDir _ac(TestDirectory.path("a/c"));
+ TempDir _acd(TestDirectory.path("a/c/d"));
+ TempDir _acde(TestDirectory.path("a/c/d/e"));
+ TempFile _acdef(TestDirectory.path("a/c/d/e/f"));
+ TempFile _acdeg(TestDirectory.path("a/c/d/e/g"));
+ TempDir _ah(TestDirectory.path("a/h"));
+ TempFile _ahi(TestDirectory.path("a/h/i"));
vfs::YAMLVFSWriter VFSWriter;
- VFSWriter.addDirectoryMapping(_a.Path, "//root/a");
- VFSWriter.addFileMapping(_ab.Path, "//root/a/b");
- VFSWriter.addDirectoryMapping(_ac.Path, "//root/a/c");
- VFSWriter.addDirectoryMapping(_acd.Path, "//root/a/c/d");
- VFSWriter.addDirectoryMapping(_acde.Path, "//root/a/c/d/e");
- VFSWriter.addFileMapping(_acdef.Path, "//root/a/c/d/e/f");
- VFSWriter.addFileMapping(_acdeg.Path, "//root/a/c/d/e/g");
- VFSWriter.addDirectoryMapping(_ahi.Path, "//root/a/h");
- VFSWriter.addFileMapping(_ahi.Path, "//root/a/h/i");
+ VFSWriter.addDirectoryMapping(_a.path(), "//root/a");
+ VFSWriter.addFileMapping(_ab.path(), "//root/a/b");
+ VFSWriter.addDirectoryMapping(_ac.path(), "//root/a/c");
+ VFSWriter.addDirectoryMapping(_acd.path(), "//root/a/c/d");
+ VFSWriter.addDirectoryMapping(_acde.path(), "//root/a/c/d/e");
+ VFSWriter.addFileMapping(_acdef.path(), "//root/a/c/d/e/f");
+ VFSWriter.addFileMapping(_acdeg.path(), "//root/a/c/d/e/g");
+ VFSWriter.addDirectoryMapping(_ahi.path(), "//root/a/h");
+ VFSWriter.addFileMapping(_ahi.path(), "//root/a/h/i");
std::string Buffer;
raw_string_ostream OS(Buffer);
}
TEST_F(VFSFromYAMLTest, YAMLVFSWriterTestHandleDirs) {
- ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
- ScopedDir _a(TestDirectory + "/a");
- ScopedDir _b(TestDirectory + "/b");
- ScopedDir _c(TestDirectory + "/c");
+ TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
+ TempDir _a(TestDirectory.path("a"));
+ TempDir _b(TestDirectory.path("b"));
+ TempDir _c(TestDirectory.path("c"));
vfs::YAMLVFSWriter VFSWriter;
- VFSWriter.addDirectoryMapping(_a.Path, "//root/a");
- VFSWriter.addDirectoryMapping(_b.Path, "//root/b");
- VFSWriter.addDirectoryMapping(_c.Path, "//root/c");
+ VFSWriter.addDirectoryMapping(_a.path(), "//root/a");
+ VFSWriter.addDirectoryMapping(_b.path(), "//root/b");
+ VFSWriter.addDirectoryMapping(_c.path(), "//root/c");
std::string Buffer;
raw_string_ostream OS(Buffer);
IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
ASSERT_TRUE(FS.get() != nullptr);
- EXPECT_FALSE(FS->exists(_a.Path + "/a"));
- EXPECT_FALSE(FS->exists(_b.Path + "/b"));
- EXPECT_FALSE(FS->exists(_c.Path + "/c"));
+ EXPECT_FALSE(FS->exists(_a.path("a")));
+ EXPECT_FALSE(FS->exists(_b.path("b")));
+ EXPECT_FALSE(FS->exists(_c.path("c")));
}
#include "llvm/Support/TargetSelect.h"
#include "llvm/Support/YAMLTraits.h"
#include "llvm/Support/raw_ostream.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using ::testing::Pointwise;
using ::testing::Property;
+using llvm::unittest::TempDir;
+
namespace llvm {
namespace exegesis {
ToDisk.Error = "error";
ToDisk.Info = "info";
- SmallString<64> Filename;
- std::error_code EC;
- EC = sys::fs::createUniqueDirectory("BenchmarkResultTestDir", Filename);
- ASSERT_FALSE(EC);
+ TempDir TestDirectory("BenchmarkResultTestDir", /*Unique*/ true);
+ SmallString<64> Filename(TestDirectory.path());
sys::path::append(Filename, "data.yaml");
errs() << Filename << "-------\n";
ExitOnErr(ToDisk.writeYaml(State, Filename));
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Support/raw_ostream.h"
+#include "llvm/Testing/Support/SupportHelpers.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using testing::Property;
using testing::SizeIs;
+using llvm::unittest::TempDir;
+
class X86SnippetFileTest : public X86TestBase {
protected:
Expected<std::vector<BenchmarkCode>> TestCommon(StringRef Contents) {
- SmallString<64> Filename;
- std::error_code EC;
- EC = sys::fs::createUniqueDirectory("SnippetFileTestDir", Filename);
- EXPECT_FALSE(EC);
+ TempDir TestDirectory("SnippetFileTestDir", /*Unique*/ true);
+ SmallString<64> Filename(TestDirectory.path());
sys::path::append(Filename, "snippet.s");
errs() << Filename << "-------\n";
{
+ std::error_code EC;
raw_fd_ostream FOS(Filename, EC);
FOS << Contents;
EXPECT_FALSE(EC);
projects / platform / upstream / llvm.git / commitdiff