[llvm] [unittests] Remove some temporary files after they're not needed

[broadwaylamb]

Summary

Some LLVM unit tests forget to clean up the temporary files and directories.

Use existing RAII classes for cleaning them up, remove duplicated code (ScopedDir, ScopedFile, ScopedLink classes) by extracting it into a common header file.

[broadwaylamb]

Gentle ping.

[sammccall]

Thanks, I think these will be useful helpers to have! I think we do need to consider the API though, rather than being too anchored on the existing callsites.

llvm/utils/unittest/support/llvm-test-helper.h

1 ↗

(On Diff #275704)

Missing header guard

1 ↗

(On Diff #275704)

Existing test helpers associated with support libraries live in llvm/Testing/Support, in namespace llvm. Can we follow that?

(Whereas the code in this directory is mostly third-party stuff).

17 ↗

(On Diff #275704)

While making these more publicly visible, we should be a bit more careful about API:

I think they should mention "temporary" somewhere.
What about TempDir? I think the RAII nature can be clear from the usage and from the documentation.

We should consider hiding Path, avoiding assignment (including accidental - many sys::path functions take a mutable SmallString as inout param).
I think StringRef TempDir::path() is probably clearer than the StringRef operator, which we should consider dropping.
Another option I've had success with is std::string TempDir::path(StringRef rel="") which allows you to construct relative paths fluently.

We should add a doc comment for the class.

46 ↗

(On Diff #275704)

this signature doesn't seem ergonomic for cross-platform tests (note that the current users are all #ifdef LLVM_ON_UNIX), because of the "/" vs "\" distinction.
If a pattern like ScopedLink Link(RealPath, Dir.path("foo/bar")) is expected, I'd suggest weakening const Twine& to StringRef. (Use of Twines for paths is IMO a historical mistake that we don't need to propagate further).

It's also not particularly obvious to me whether "To" is the link target or the link being written. Maybe Target/Link?

61 ↗

(On Diff #275704)

the overloaded constructor is pretty confusing here: one creates a random filename based on a template and writes an empty file, the other wants the full path to be passed in and sets the contents.

If both are needed, I'd suggest something like:

class ScopedFile {
public:
  ScopedFile(StringRef Path, StringRef Contents="");
  static ScopedFile withUniquePath(StringRef NameModel="%%%%%%%%%%%%");
};

[broadwaylamb]

Address review comments, change some tests that didn't use the RAII objects to use them where appropriate.

[broadwaylamb]

@sammccall could you please take a look?

[broadwaylamb]

ping

[sammccall]

Sorry, this fell off my radar :-(

llvm/include/llvm/Testing/Support/SupportHelpers.h

122

the bool param that changes the meaning of the previous param is a little cryptic (including at callsites).
It also makes the common case of "unique temporary directory that I don't care about the name of

You could consider TempDir(Name) and TempDir::unique(). (Specifying the model doesn't seem all that useful?).

Up to you.

158

to avoid a bit of template magic, you can just accept a path separated by / and call native on it before append. I tend to find this more readable at the callsites that multiple params, up to you.

[broadwaylamb]

llvm/include/llvm/Testing/Support/SupportHelpers.h

122

The name of the unique directory helps identify what went wrong if that directory isn't cleaned up. This is exactly how I've figured out which test cases need to use RAII objects.

For example, if we see that a directory isn't cleaned up, we can tell by its name which test case could crash and cause that directory to not be cleaned up.

158

Good point, I'll do it.

[broadwaylamb]

Make the path() member function of TempDir non-template.

llvm/include/llvm/Testing/Support/SupportHelpers.h

 //===- Testing/Support/SupportHelpers.h -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TESTING_SUPPORT_SUPPORTHELPERS_H
 #define LLVM_TESTING_SUPPORT_SUPPORTHELPERS_H
 
 #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"
 
 #include <string>
 
 namespace llvm {
 namespace detail {

 
 /// Matches an llvm::Optional<T> with a value that conforms to an inner matcher.
 /// To match llvm::None you could use Eq(llvm::None).
 template <class InnerMatcher>
 detail::ValueIsMatcher<InnerMatcher> ValueIs(const InnerMatcher &ValueMatcher) {
   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
 
 #endif

llvm/unittests/ProfileData/SampleProfTest.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/ProfileData/SampleProfReader.h"
 #include "llvm/ProfileData/SampleProfWriter.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorOr.h"
 #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();
   return ::testing::AssertionFailure() << "error " << EC.value() << ": "
                                        << EC.message();
 }
 
 namespace {
void readProfile(const Module &M, StringRef Profile,
                    StringRef RemapFile = "") {
     auto ReaderOrErr = SampleProfileReader::create(
         std::string(Profile), Context, std::string(RemapFile));
     ASSERT_TRUE(NoError(ReaderOrErr.getError()));
     Reader = std::move(ReaderOrErr.get());
     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
   // Metadata. \p AddPartialField is to choose whether the Metadata
   // contains the IsPartialProfile field which is optional.
   void verifyProfileSummary(ProfileSummary &Summary, Module &M,
                             const bool AddPartialField,
                             const bool AddPartialProfileRatioField) {
void verifyProfileSummary(ProfileSummary &Summary, Module &M,
     ASSERT_TRUE(MD);
     PS = ProfileSummary::getFromMD(MD);
     ASSERT_TRUE(PS);
     VerifySummary(*PS);
     delete PS;
   }
 
   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();
 
     StringRef FooName("_Z3fooi");
     FunctionSamples FooSamples;
     FooSamples.setName(FooName);
     FooSamples.addTotalSamples(7711);
     FooSamples.addHeadSamples(610);
void testRoundTrip(SampleProfileFormat Format, bool Remap, bool UseMD5) {
     Profiles[BarName] = std::move(BarSamples);
     Profiles[BazName] = std::move(BazSamples);
     Profiles[BooName] = std::move(BooSamples);
 
     Module M("my_module", Context);
     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";
       HooName = "_Z3hool";
     }
 
     M.getOrInsertFunction(FooName, fn_type);
     M.getOrInsertFunction(BarName, fn_type);
     M.getOrInsertFunction(BooName, fn_type);
 
     ProfileSymbolList List;
     if (Format == SampleProfileFormat::SPF_Ext_Binary) {
       List.add("zoo", true);
       List.add("moo", true);
     }
     Writer->setProfileSymbolList(&List);
 
     std::error_code EC;
     EC = Writer->write(Profiles);
     ASSERT_TRUE(NoError(EC));
 
     Writer->getOutputStream().flush();
 
-    readProfile(M, Profile, RemapFile);
+    readProfile(M, ProfileFile.path(), RemapFile.path());
     EC = Reader->read();
     ASSERT_TRUE(NoError(EC));
 
     if (Format == SampleProfileFormat::SPF_Ext_Binary) {
       std::unique_ptr<ProfileSymbolList> ReaderList =
           Reader->getProfileSymbolList();
       ReaderList->contains("zoo");
       ReaderList->contains("moo");
struct SampleProfTest : ::testing::Test {
   void setupModuleForElisionTest(Module *M, StringRef Policy) {
     createFunctionWithSampleProfileElisionPolicy(M, "foo", Policy);
     createFunctionWithSampleProfileElisionPolicy(M, "foo.bar", Policy);
     createFunctionWithSampleProfileElisionPolicy(M, "foo.llvm.2465", Policy);
   }
 
   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));
 
     for (auto I = Expected.begin(); I != Expected.end(); ++I) {
       uint64_t Esamples = uint64_t(-1);
       FunctionSamples *Samples = Reader->getSamplesFor(I->getKey());
       if (Samples != nullptr)
         Esamples = Samples->getTotalSamples();

llvm/unittests/Support/CommandLineTest.cpp

 #include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #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 <stdlib.h>
 #include <string>
 #include <tuple>
 
 using namespace llvm;
+using llvm::unittest::TempDir;
+using llvm::unittest::TempFile;
 
 namespace {
 
 MATCHER(StringEquality, "Checks if two char* are equal as strings") {
   return std::string(std::get<0>(arg)) == std::string(std::get<1>(arg));
 }
 
 class TempEnvVar {
TEST(CommandLineTest, ResponseFileWindows) {
   if (!Triple(sys::getProcessTriple()).isOSWindows())
     return;
 
   StackOption<std::string, cl::list<std::string>> InputFilenames(
       cl::Positional, cl::desc("<input files>"), cl::ZeroOrMore);
   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(
       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
   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) {
   vfs::InMemoryFileSystem FS;
 #ifdef _WIN32
   const char *TestRoot = "C:\\";
 #else
   const char *TestRoot = "/";
TEST(CommandLineTest, SetDefautValue) {
   EXPECT_TRUE(Opt2);
   EXPECT_TRUE(Opt3 == 3);
   Alias.removeArgument();
 }
 
 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"
+  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";
-  ConfigFile.close();
+                      "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"
+  llvm::sys::path::append(TestCfg2, TestDir.path(), "subconfig");
+  TempFile ConfigFile2(TestCfg2, "",
+                       "-option_2\n"
                        "\n"
-                 "   # comment\n";
-  ConfigFile2.close();
+                       "   # 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[0], "-option_1");
   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) {
   cl::ResetCommandLineParser();
 
   StackOption<std::string, cl::list<std::string>> PosEatArgs(
       "positional-eat-args", cl::Positional, cl::desc("<arguments>..."),
       cl::ZeroOrMore, cl::PositionalEatsArgs);

llvm/unittests/Support/FileCollectorTest.cpp

 //===-- FileCollectorTest.cpp -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #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 {
 inline bool operator==(const llvm::vfs::YAMLVFSEntry &LHS,
                        const llvm::vfs::YAMLVFSEntry &RHS) {
   return LHS.VPath == RHS.VPath && LHS.RPath == RHS.RPath;
 }
 } // namespace vfs
 } // namespace llvm
 
 namespace {
 class TestingFileCollector : public FileCollector {
 public:
   using FileCollector::FileCollector;
   using FileCollector::Root;
   using FileCollector::Seen;
   using FileCollector::SymlinkMap;
   using FileCollector::VFSWriter;
 
   bool hasSeen(StringRef fs) {
     return Seen.find(fs) != Seen.end();
   }
 };
 
-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");
   FileCollector.addFile("/path/to/b");
   FileCollector.addFile("/path/to/c");
 
   // 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("/path/to/a"));
   EXPECT_TRUE(FileCollector.hasSeen("/path/to/b"));
   EXPECT_TRUE(FileCollector.hasSeen("/path/to/c"));
 
   // Make sure we've only seen the added files.
   EXPECT_FALSE(FileCollector.hasSeen("/path/to/d"));
 }
 
 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);
   EXPECT_FALSE(ec);
 
   // Now add a bogus file and make sure we error out.
   FileCollector.addFile("/some/bogus/file");
   ec = FileCollector.copyFiles(true);
   EXPECT_TRUE(ec);
 
   // However, if stop_on_error is true the copy should still succeed.
   ec = FileCollector.copyFiles(false);
   EXPECT_FALSE(ec);
 }
 
 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

llvm/unittests/Support/FileUtilitiesTest.cpp

 //===- llvm/unittest/Support/FileUtilitiesTest.cpp - unit tests -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorHandling.h"
 #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;                                           \
     raw_svector_ostream Message(MessageStorage);                               \
     Message << #x ": did not return errc::success.\n"                          \
             << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
             << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
     GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
   } else {                                                                     \
   }
 
 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) + "-%%%%%%%%";
   const std::string TestfileContent = "fooFOOfoo";
 
   llvm::Error Err = llvm::writeFileAtomically(TempUniqTestFileModel, FinalTestfilePath, TestfileContent);
   ASSERT_FALSE(static_cast<bool>(Err));
 
   std::ifstream FinalFileStream(std::string(FinalTestfilePath.str()));
   std::string FinalFileContent;
   FinalFileStream >> FinalFileContent;
   ASSERT_EQ(FinalFileContent, TestfileContent);
 }
 } // anonymous namespace

llvm/unittests/Support/LockFileManagerTest.cpp

 //===- unittests/LockFileManagerTest.cpp - LockFileManager tests ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #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");
 
   {
     // The lock file should not exist, so we should successfully acquire it.
     LockFileManager Locked1(LockedFile);
     EXPECT_EQ(LockFileManager::LFS_Owned, Locked1.getState());
 
     // Attempting to reacquire the lock should fail.  Waiting on it would cause
     // deadlock, so don't try that.
     LockFileManager Locked2(LockedFile);
     EXPECT_NE(LockFileManager::LFS_Owned, Locked2.getState());
   }
 
   // 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);
   ASSERT_EQ(Ret, 0);
 
   EC = sys::fs::create_link(TmpFileLock.str(), FileLocK.str());
   ASSERT_FALSE(EC);
 
   EC = sys::fs::remove(StringRef(TmpFileLock));
   ASSERT_FALSE(EC);
 
   {
     // The lock file doesn't point to a real file, so we should successfully
     // acquire it.
     LockFileManager Locked(LockedFile);
     EXPECT_EQ(LockFileManager::LFS_Owned, Locked.getState());
   }
 
   // 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);
   FileLock += ".lock";
 
   {
     // The lock file should not exist, so we should successfully acquire it.
     LockFileManager Locked(LockedFile);
     EXPECT_EQ(LockFileManager::LFS_Owned, Locked.getState());
     EXPECT_TRUE(sys::fs::exists(FileLock.str()));
   }
 
   // Now that the lock is out of scope, the file should be gone.
   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

llvm/unittests/Support/TarWriterTest.cpp

 //===- llvm/unittest/Support/TarWriterTest.cpp ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #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 {
   char Name[100];
   char Mode[8];
   char Uid[8];
   char Gid[8];
   char Size[12];
struct UstarHeader {
   char DevMinor[8];
   char Prefix[155];
   char Pad[12];
 };
 
 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(),
                            (const uint8_t *)MB->getBufferEnd());
 
   // 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;
 }
 
 static UstarHeader createUstar(StringRef Base, StringRef Filename) {
   std::vector<uint8_t> Buf = createTar(Base, Filename);
   EXPECT_TRUE(Buf.size() >= sizeof(UstarHeader));
   return *reinterpret_cast<const UstarHeader *>(Buf.data());
TEST_F(TarWriterTest, Pax) {
   EXPECT_EQ("", StringRef(Hdr->Prefix));
   EXPECT_EQ("", StringRef(Hdr->Name));
 
   StringRef Pax = StringRef((char *)(Buf.data() + 512), 512);
   EXPECT_TRUE(Pax.startswith("211 path=/" + std::string(200, 'x')));
 }
 
 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->append("BarPath", "bar");
   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->append("FooPath", "bar");
   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);
 }
 } // namespace

llvm/unittests/Support/VirtualFileSystemTest.cpp

 //===- unittests/Support/VirtualFileSystem.cpp -------------- VFS tests ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/VirtualFileSystem.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Host.h"
 #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>
 #include <string>
 
 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 DummyFile : public vfs::File {
   vfs::Status S;
   explicit DummyFile(vfs::Status S) : S(S) {}
ErrorOr<vfs::Status> Status((std::error_code()));
     Status = (*it)->status("/foo");
     ASSERT_TRUE(Status.getError());
 
     it++;
     EXPECT_EQ(it, end);
   }
 }
 
-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.
   EXPECT_TRUE(I->path().endswith("a") || I->path().endswith("c"));
   I.increment(EC);
   ASSERT_FALSE(EC);
   ASSERT_NE(vfs::directory_iterator(), I);
   EXPECT_TRUE(I->path().endswith("a") || I->path().endswith("c"));
   I.increment(EC);
   EXPECT_EQ(vfs::directory_iterator(), I);
 }
 
 #ifdef LLVM_ON_UNIX
 TEST(VirtualFileSystemTest, MultipleWorkingDirs) {
   // 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");
   ASSERT_TRUE(BBuf);
   EXPECT_EQ("bbbb", (*BBuf)->getBuffer());
 
   auto ABuf = CFS->getBufferForFile("aa");
   ASSERT_TRUE(ABuf);
   EXPECT_EQ("aaaa", (*ABuf)->getBuffer());
 
   // status()
   auto BStat = BFS->status("bb");
   ASSERT_TRUE(BStat);
   EXPECT_EQ("bb", BStat->getName());
 
   auto AStat = CFS->status("aa");
   ASSERT_TRUE(AStat);
   EXPECT_EQ("aa", AStat->getName()); // unresolved name
 
   // 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()))] =
         FS->status(I->path()).getError();
   }
   EXPECT_THAT(
       StatResults,
       ElementsAre(
           Pair("a", std::make_error_code(std::errc::no_such_file_or_directory)),
           Pair("b", std::error_code()),
           Pair("c",
                std::make_error_code(std::errc::no_such_file_or_directory))));
 }
 #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);
 
   std::vector<std::string> Contents;
   for (auto E = vfs::recursive_directory_iterator(); !EC && I != E;
        I.increment(EC)) {
     Contents.push_back(std::string(I->path()));
   }
TEST(VirtualFileSystemTest, BasicRealFSRecursiveIteration) {
   }
   EXPECT_EQ(1, Counts[0]); // a
   EXPECT_EQ(1, Counts[1]); // b
   EXPECT_EQ(1, Counts[2]); // c
   EXPECT_EQ(1, Counts[3]); // d
 }
 
 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;
     for (auto E = vfs::recursive_directory_iterator(); !EC && I != E;
          I.increment(EC)) {
       Contents.push_back(std::string(I->path()));
       char last = I->path().back();
       switch (last) {
       case 'b':
       case 'd':
       case 'f':
       case 'g':
         I.no_push();
         break;
       default:
         break;
       }
     }
     EXPECT_EQ(7U, Contents.size());
   }
 
   // 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;
     for (auto E = vfs::recursive_directory_iterator(); !EC && I != E;
          I.increment(EC)) {
       Contents.push_back(std::string(I->path()));
       char last = I->path().back();
       switch (last) {
// Test that calling no_push skips subdirectories.
     EXPECT_EQ(1, Counts[4]); // e
     EXPECT_EQ(0, Counts[5]); // f
     EXPECT_EQ(1, Counts[6]); // g
   }
 }
 
 #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)
         .push_back(std::string(I->path()));
   }
 
   // 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
 
 template <typename DirIter>
 static void checkContents(DirIter I, ArrayRef<StringRef> ExpectedOut) {
   std::error_code EC;
   SmallVector<StringRef, 4> Expected(ExpectedOut.begin(), ExpectedOut.end());
   SmallVector<std::string, 4> InputToCheck;
TEST_F(VFSFromYAMLTest, WorkingDirectoryFallthroughInvalid) {
   ASSERT_FALSE(Status.getError());
   EXPECT_TRUE(Status->exists());
 
   Status = FS->status("foo/a");
   ASSERT_TRUE(Status.getError());
 }
 
 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);
   VFSWriter.write(OS);
   OS.flush();
 
   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
   Lower->addDirectory("//root/");
   Lower->addDirectory("//root/a");
   Lower->addRegularFile("//root/a/b");
   Lower->addDirectory("//root/b");
   Lower->addDirectory("//root/c");
   Lower->addRegularFile("//root/c/d");
   Lower->addDirectory("//root/e");
   Lower->addDirectory("//root/e/f");
   Lower->addRegularFile("//root/g");
   Lower->addDirectory("//root/h");
 
   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);
   VFSWriter.write(OS);
   OS.flush();
 
   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
   EXPECT_TRUE(FS.get() != nullptr);
 }
 
 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);
   VFSWriter.write(OS);
   OS.flush();
 
   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
   EXPECT_TRUE(FS.get() != nullptr);
 }
 
 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);
   VFSWriter.write(OS);
   OS.flush();
 
   // We didn't add a single file - only directories.
   EXPECT_TRUE(Buffer.find("'type': 'file'") == std::string::npos);
 
   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
   Lower->addDirectory("//root/a");
   Lower->addDirectory("//root/b");
   Lower->addDirectory("//root/c");
   // canaries
   Lower->addRegularFile("//root/a/a");
   Lower->addRegularFile("//root/b/b");
   Lower->addRegularFile("//root/c/c");
 
   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")));
 }

llvm/unittests/tools/llvm-exegesis/Mips/BenchmarkResultTest.cpp

 #include "TestBase.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetRegistry.h"
 #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::AllOf;
 using ::testing::Eq;
 using ::testing::get;
 using ::testing::Pointwise;
 using ::testing::Property;
 
+using llvm::unittest::TempDir;
+
 namespace llvm {
 namespace exegesis {
 
 bool operator==(const BenchmarkMeasure &A, const BenchmarkMeasure &B) {
   return std::tie(A.Key, A.PerInstructionValue, A.PerSnippetValue) ==
          std::tie(B.Key, B.PerInstructionValue, B.PerSnippetValue);
 }
 
TEST_F(BenchmarkResultTest, WriteToAndReadFromDisk) {
   ToDisk.CpuName = "cpu_name";
   ToDisk.LLVMTriple = "llvm_triple";
   ToDisk.NumRepetitions = 1;
   ToDisk.Measurements.push_back(BenchmarkMeasure{"a", 1, 1});
   ToDisk.Measurements.push_back(BenchmarkMeasure{"b", 2, 2});
   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));
 
   {
     // One-element version.
     const auto FromDisk =
         ExitOnErr(InstructionBenchmark::readYaml(State, Filename));

llvm/unittests/tools/llvm-exegesis/X86/SnippetFileTest.cpp

 #include "TestBase.h"
 #include "X86InstrInfo.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #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"
 
 namespace llvm {
 namespace exegesis {
 
 void InitializeX86ExegesisTarget();
 
 namespace {
 
 using testing::AllOf;
 using testing::ElementsAre;
 using testing::Eq;
 using testing::Field;
 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);
     }
     return readSnippets(State, Filename);
   }
 };