[lldb] Add a SubsystemRAII that takes care of calling Initialize and Terminate in the unit tests

[teemperor]

Summary

Many of our tests need to initialize certain subsystems/plugins of LLDB such as
FileSystem or HostInfo by calling their static Initialize functions before the
test starts and then calling ::Terminate after the test is done (in reverse order).
This adds a lot of error-prone boilerplate code to our testing code.

This patch adds a RAII called SubsystemRAII that ensures that we always call
::Initialize and then call ::Terminate after the test is done (and that the Terminate
calls are always in the reverse order of the ::Initialize calls). It also gets rid of
all of the boilerplate that we had for these calls.

Per-fixture initialization is still not very nice with this approach as it would
require some kind of static unique_ptr that gets manually assigned/reseted
from the gtest SetUpTestCase/TearDownTestCase functions. Because of that
I changed all per-fixture setup to now do per-test setup which can be done
by just having the SubsystemRAII as a member of the test fixture. This change doesn't
influence our normal test runtime as LIT anyway runs each test case separately
(and the Initialize/Terminate calls are anyway not very expensive). It will however
make running all tests in a single executable slightly slower.

[teemperor]

I only converted like 40% of our tests to the new system as I first wanted to get some feedback before I do all the refactoring. Also I'm open to ideas how to name the member (currently I just use subsystems without the m_ prefix as it's not really a real member with any contents).

[labath]

We have at least one Initialize function (Socket::Initialize) which can return an llvm::Error (and it is used in some unit tests). What's your plan to handle that?

Assuming we can come up with something there, I think this would be a great utility. I wouldn't be opposed to using this for the main initialization code too...

[teemperor]

• Added SFINAE spaghetti to handle llvm::Error return types.

[labath]

Yep, looks good.

lldb/unittests/TestingSupport/SubsystemRAII.h

60

This doesn't have to be a template since it's already parameterized by the enclosing T. Or, you could actually move it outside the SubsystemRAII class (and possibly into a detail namespace) and save the compiler some work then Using the same class in different subsystem sequences.

[shafik]

lldb/unittests/TestingSupport/SubsystemRAII.h

58

Should we write a test for this?

[teemperor]

• Add test
• Move SubsystemRAIICase to ::detail

I'll wait with landing this until HostInfo's Initialize/Terminate are fixed (calling Terminate and Initialize is currently breaking the whole thing)

[teemperor]

• Migrated more tests to SubsystemRAII

[teemperor]

• Rebased

lldb/unittests/Core/MangledTest.cpp

 //===-- MangledTest.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 "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/SymbolContext.h"
TEST(MangledTest, EmptyForInvalidName) {
   Mangled TheMangled(MangledName);
   ConstString TheDemangled =
       TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
 
   EXPECT_STREQ("", TheDemangled.GetCString());
 }
 
 TEST(MangledTest, NameIndexes_FindFunctionSymbols) {
-  FileSystem::Initialize();
-  HostInfo::Initialize();
-  ObjectFileELF::Initialize();
-  SymbolFileSymtab::Initialize();
+  SubsystemRAII<FileSystem, HostInfo, ObjectFileELF, SymbolFileSymtab>
+      subsystems;
 
   auto ExpectedFile = TestFile::fromYaml(R"(
 --- !ELF
 FileHeader:      
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   Type:            ET_EXEC
   Machine:         EM_X86_64
)");
   EXPECT_EQ(0, Count("ObjCbar", eFunctionNameTypeMethod));
 
   // Invalid things: unable to decode but still possible to find by full name
   EXPECT_EQ(1, Count("_Z12undemangableEvx42", eFunctionNameTypeFull));
   EXPECT_EQ(1, Count("_Z12undemangableEvx42", eFunctionNameTypeBase));
   EXPECT_EQ(0, Count("_Z12undemangableEvx42", eFunctionNameTypeMethod));
   EXPECT_EQ(0, Count("undemangable", eFunctionNameTypeBase));
   EXPECT_EQ(0, Count("undemangable", eFunctionNameTypeMethod));
-
-  SymbolFileSymtab::Terminate();
-  ObjectFileELF::Terminate();
-  HostInfo::Terminate();
-  FileSystem::Terminate();
 }

lldb/unittests/Editline/EditlineTest.cpp

 #include <stdio.h>
 #include <unistd.h>
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <memory>
 #include <thread>
 
+#include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Host/Editline.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StringList.h"
 
 using namespace lldb_private;
#if EDITLINE_TEST_DUMP_OUTPUT
     }
     printf("<stdout> 0x%02x (%03d) (%s)\n", ch, ch, display_str);
 // putc(ch, stdout);
 #endif
   }
 }
 
 class EditlineTestFixture : public ::testing::Test {
-private:
+  SubsystemRAII<FileSystem> subsystems;
   EditlineAdapter _el_adapter;
   std::shared_ptr<std::thread> _sp_output_thread;
 
 public:
   static void SetUpTestCase() {
     // We need a TERM set properly for editline to work as expected.
     setenv("TERM", "vt100", 1);
   }
 
   void SetUp() override {
-    FileSystem::Initialize();
-
     // Validate the editline adapter.
     EXPECT_TRUE(_el_adapter.IsValid());
     if (!_el_adapter.IsValid())
       return;
 
     // Dump output.
     _sp_output_thread =
         std::make_shared<std::thread>([&] { _el_adapter.ConsumeAllOutput(); });
   }
 
   void TearDown() override {
     _el_adapter.CloseInput();
     if (_sp_output_thread)
       _sp_output_thread->join();
-
-    FileSystem::Terminate();
   }
 
   EditlineAdapter &GetEditlineAdapter() { return _el_adapter; }
 };
 
 TEST_F(EditlineTestFixture, EditlineReceivesSingleLineText) {
   // Send it some text via our virtual keyboard.
   const std::string input_text("Hello, world");

lldb/unittests/Expression/ClangExpressionDeclMapTest.cpp

 //===-- ClangExpressionDeclMapTest.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 "Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/Symbol/ClangTestUtils.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/lldb-defines.h"
 #include "gtest/gtest.h"
 

 private:
   /// The persistent decls in this test with their names as keys.
   llvm::DenseMap<llvm::StringRef, clang::NamedDecl *> m_persistent_decls;
 };
 } // namespace
 
 namespace {
 struct ClangExpressionDeclMapTest : public testing::Test {
-  static void SetUpTestCase() {
-    FileSystem::Initialize();
-    HostInfo::Initialize();
-  }
-  static void TearDownTestCase() {
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
+  SubsystemRAII<FileSystem, HostInfo> subsystems;
 
   /// The ClangASTImporter used during the test.
   ClangASTImporterSP importer;
   /// The ExpressionDeclMap for the current test case.
   std::unique_ptr<FakeClangExpressionDeclMap> decl_map;
 
   /// The target AST that lookup results should be imported to.
   std::unique_ptr<ClangASTContext> target_ast;

lldb/unittests/Expression/ClangParserTest.cpp

 //===-- ClangParserTest.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 "clang/Basic/Version.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangHost.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-defines.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 namespace {
 struct ClangHostTest : public testing::Test {
-  static void SetUpTestCase() {
-    FileSystem::Initialize();
-    HostInfo::Initialize();
-  }
-  static void TearDownTestCase() {
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
+  SubsystemRAII<FileSystem, HostInfo> subsystems;
 };
 } // namespace
 
 static std::string ComputeClangResourceDir(std::string lldb_shlib_path,
                                            bool verify = false) {
   FileSpec clang_dir;
   FileSpec lldb_shlib_spec(lldb_shlib_path);
   ComputeClangResourceDirectory(lldb_shlib_spec, clang_dir, verify);

lldb/unittests/Expression/CppModuleConfigurationTest.cpp

 //===-- CppModuleConfigurationTest.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 "Plugins/ExpressionParser/Clang/CppModuleConfiguration.h"
 #include "Plugins/ExpressionParser/Clang/ClangHost.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 namespace {
 struct CppModuleConfigurationTest : public testing::Test {
-  static void SetUpTestCase() {
-    // Getting the resource directory uses those subsystems, so we should
-    // initialize them.
-    FileSystem::Initialize();
-    HostInfo::Initialize();
-  }
-  static void TearDownTestCase() {
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
+  SubsystemRAII<FileSystem, HostInfo> subsystems;
 };
 } // namespace
 
 /// Returns the Clang resource include directory.
 static std::string ResourceInc() {
   llvm::SmallString<256> resource_dir;
   llvm::sys::path::append(resource_dir, GetClangResourceDir().GetPath(),
                           "include");

lldb/unittests/Expression/DWARFExpressionTest.cpp

 //===-- DWARFExpressionTest.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 "lldb/Expression/DWARFExpression.h"
 #include "../../source/Plugins/SymbolFile/DWARF/DWARFUnit.h"
 #include "../../source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ObjectYAML/DWARFEmitter.h"
public:
   Type CalculateType() override { return {}; }
   Strata CalculateStrata() override { return {}; }
   /// \}
 };
 
 /// Helper class that can construct a module from YAML and evaluate
 /// DWARF expressions on it.
 class YAMLModuleTester {
+  SubsystemRAII<FileSystem> subsystems;
   llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> m_sections_map;
   lldb::ModuleSP m_module_sp;
   lldb::ObjectFileSP m_objfile_sp;
   DWARFUnitSP m_dwarf_unit;
   std::unique_ptr<SymbolFileDWARF> m_symfile_dwarf;
 
 public:
   /// Parse the debug info sections from the YAML description.
   YAMLModuleTester(llvm::StringRef yaml_data, llvm::StringRef triple) {
-    FileSystem::Initialize();
-
     auto sections_map = llvm::DWARFYAML::EmitDebugSections(yaml_data, true);
     if (!sections_map)
       return;
     m_sections_map = std::move(*sections_map);
     ArchSpec arch(triple);
     m_module_sp = std::make_shared<YAMLModule>(arch);
     m_objfile_sp = std::make_shared<YAMLObjectFile>(m_module_sp, m_sections_map);
     static_cast<YAMLModule *>(m_module_sp.get())->SetObjectFile(m_objfile_sp);
 
     lldb::user_id_t uid = 0;
     llvm::StringRef raw_debug_info = m_sections_map["debug_info"]->getBuffer();
     lldb_private::DataExtractor debug_info(
         raw_debug_info.data(), raw_debug_info.size(),
         m_objfile_sp->GetByteOrder(), m_objfile_sp->GetAddressByteSize());
     lldb::offset_t offset_ptr = 0;
     m_symfile_dwarf = std::make_unique<SymbolFileDWARF>(m_objfile_sp, nullptr);
     llvm::Expected<DWARFUnitSP> dwarf_unit = DWARFUnit::extract(
         *m_symfile_dwarf, uid,
         *static_cast<lldb_private::DWARFDataExtractor *>(&debug_info),
         DIERef::DebugInfo, &offset_ptr);
     if (dwarf_unit)
       m_dwarf_unit = dwarf_unit.get();
   }
-  ~YAMLModuleTester() { FileSystem::Terminate(); }
   DWARFUnitSP GetDwarfUnit() { return m_dwarf_unit; }
 
   // Evaluate a raw DWARF expression.
   llvm::Expected<Scalar> Eval(llvm::ArrayRef<uint8_t> expr) {
     return ::Evaluate(expr, m_module_sp, m_dwarf_unit.get());
   }
 };
 

lldb/unittests/Host/ConnectionFileDescriptorTest.cpp

 //===-- ConnectionFileDescriptorTest.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 "SocketTestUtilities.h"
 #include "gtest/gtest.h"
 
+#include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
 #include "lldb/Utility/UriParser.h"
 
 using namespace lldb_private;
 
 class ConnectionFileDescriptorTest : public testing::Test {
 public:
-  void SetUp() override {
-    ASSERT_THAT_ERROR(Socket::Initialize(), llvm::Succeeded());
-  }
-
-  void TearDown() override { Socket::Terminate(); }
+  SubsystemRAII<Socket> subsystems;
 
   void TestGetURI(std::string ip) {
     std::unique_ptr<TCPSocket> socket_a_up;
     std::unique_ptr<TCPSocket> socket_b_up;
     if (!IsAddressFamilySupported(ip)) {
       GTEST_LOG_(WARNING) << "Skipping test due to missing IPv"
                           << (IsIPv4(ip) ? "4" : "6") << " support.";
       return;

lldb/unittests/Host/HostInfoTest.cpp

 //===-- HostInfoTest.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 "lldb/Host/HostInfo.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/lldb-defines.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 using namespace llvm;
 
 namespace {
 class HostInfoTest : public ::testing::Test {
-public:
-  void SetUp() override {
-    FileSystem::Initialize();
-    HostInfo::Initialize();
-  }
-  void TearDown() override {
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
+  SubsystemRAII<FileSystem, HostInfo> subsystems;
 };
 } // namespace
 
 TEST_F(HostInfoTest, GetAugmentedArchSpec) {
   // Fully specified triple should not be changed.
   ArchSpec spec = HostInfo::GetAugmentedArchSpec("x86_64-pc-linux-gnu");
   EXPECT_EQ(spec.GetTriple().getTriple(), "x86_64-pc-linux-gnu");
 

lldb/unittests/Host/MainLoopTest.cpp

 //===-- MainLoopTest.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 "lldb/Host/MainLoop.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/PseudoTerminal.h"
 #include "lldb/Host/common/TCPSocket.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 #include <future>
 
 using namespace lldb_private;
 
 namespace {
 class MainLoopTest : public testing::Test {
 public:
-  static void SetUpTestCase() {
-    ASSERT_THAT_ERROR(Socket::Initialize(), llvm::Succeeded());
-  }
-
-  static void TearDownTestCase() { Socket::Terminate(); }
+  SubsystemRAII<Socket> subsystems;
 
   void SetUp() override {
     bool child_processes_inherit = false;
     Status error;
     std::unique_ptr<TCPSocket> listen_socket_up(
         new TCPSocket(true, child_processes_inherit));
     ASSERT_TRUE(error.Success());
     error = listen_socket_up->Listen("localhost:0", 5);

lldb/unittests/Host/SocketAddressTest.cpp

 //===-- SocketAddressTest.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 "lldb/Host/SocketAddress.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Host/Socket.h"
 #include "llvm/Testing/Support/Error.h"
 
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 namespace {
 class SocketAddressTest : public testing::Test {
 public:
-  static void SetUpTestCase() {
-    ASSERT_THAT_ERROR(Socket::Initialize(), llvm::Succeeded());
-  }
-  static void TearDownTestCase() { Socket::Terminate(); }
+  SubsystemRAII<Socket> subsystems;
 };
 } // namespace
 
 TEST_F(SocketAddressTest, Set) {
   SocketAddress sa;
   ASSERT_TRUE(sa.SetToLocalhost(AF_INET, 1138));
   ASSERT_STREQ("127.0.0.1", sa.GetIPAddress().c_str());
   ASSERT_EQ(1138, sa.GetPort());

lldb/unittests/Host/SocketTest.cpp

 //===-- SocketTest.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 "SocketTestUtilities.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Utility/UriParser.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 
 class SocketTest : public testing::Test {
 public:
-  void SetUp() override {
-    ASSERT_THAT_ERROR(Socket::Initialize(), llvm::Succeeded());
-  }
-
-  void TearDown() override { Socket::Terminate(); }
+  SubsystemRAII<Socket> subsystems;
 };
 
 TEST_F(SocketTest, DecodeHostAndPort) {
   std::string host_str;
   std::string port_str;
   int32_t port;
   Status error;
   EXPECT_TRUE(Socket::DecodeHostAndPort("localhost:1138", host_str, port_str,

lldb/unittests/Interpreter/TestCompletion.cpp

 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/Utility/TildeExpressionResolver.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #include "TestingSupport/MockTildeExpressionResolver.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace fs = llvm::sys::fs;
 namespace path = llvm::sys::path;
 using namespace llvm;
 using namespace lldb_private;
 
 namespace {
 
 class CompletionTest : public testing::Test {
+  SubsystemRAII<FileSystem> subsystems;
+
 protected:
   /// Unique temporary directory in which all created filesystem entities must
   /// be placed. It is removed at the end of the test suite.
   SmallString<128> BaseDir;
 
   /// The working directory that we got when starting the test. Every test
   /// should chdir into this directory first because some tests maybe chdir
   /// into another one during their run.
protected:
   SmallString<128> FileAA;
   SmallString<128> FileAB;
   SmallString<128> FileAC;
   SmallString<128> FileFoo;
   SmallString<128> FileBar;
   SmallString<128> FileBaz;
 
   void SetUp() override {
-    FileSystem::Initialize();
-
     // chdir back into the original working dir this test binary started with.
     // A previous test may have have changed the working dir.
     ASSERT_NO_ERROR(fs::set_current_path(OriginalWorkingDir));
 
     // Get the name of the current test. To prevent that by chance two tests
     // get the same temporary directory if createUniqueDirectory fails.
     auto test_info = ::testing::UnitTest::GetInstance()->current_test_info();
     ASSERT_TRUE(test_info != nullptr);
protected:
   }
 
   static void SetUpTestCase() {
     ASSERT_NO_ERROR(fs::current_path(OriginalWorkingDir));
   }
 
   void TearDown() override {
     ASSERT_NO_ERROR(fs::remove_directories(BaseDir));
-    FileSystem::Terminate();
   }
 
   static bool HasEquivalentFile(const Twine &Path, const StringList &Paths) {
     for (size_t I = 0; I < Paths.GetSize(); ++I) {
       if (fs::equivalent(Path, Paths[I]))
         return true;
     }
     return false;

lldb/unittests/Language/Highlighting/HighlighterTest.cpp

 //===-- HighlighterTest.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 "gtest/gtest.h"
 
 #include "lldb/Core/Highlighter.h"
 #include "lldb/Host/FileSystem.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"
+#include "TestingSupport/SubsystemRAII.h"
 
 using namespace lldb_private;
 
 namespace {
 class HighlighterTest : public testing::Test {
-public:
-  static void SetUpTestCase();
-  static void TearDownTestCase();
+  SubsystemRAII<FileSystem, CPlusPlusLanguage, ObjCLanguage,
+                ObjCPlusPlusLanguage>
+      subsystems;
 };
 } // namespace
 
-void HighlighterTest::SetUpTestCase() {
-  // The HighlighterManager uses the language plugins under the hood, so we
-  // have to initialize them here for our test process.
-  FileSystem::Initialize();
-  CPlusPlusLanguage::Initialize();
-  ObjCLanguage::Initialize();
-  ObjCPlusPlusLanguage::Initialize();
-}
-
-void HighlighterTest::TearDownTestCase() {
-  CPlusPlusLanguage::Terminate();
-  ObjCLanguage::Terminate();
-  ObjCPlusPlusLanguage::Terminate();
-  FileSystem::Terminate();
-}
-
 static std::string getName(lldb::LanguageType type) {
   HighlighterManager m;
   return m.getHighlighterFor(type, "").GetName().str();
 }
 
 static std::string getName(llvm::StringRef path) {
   HighlighterManager m;
   return m.getHighlighterFor(lldb::eLanguageTypeUnknown, path).GetName().str();

lldb/unittests/ObjectFile/ELF/TestObjectFileELF.cpp

 //===-- TestObjectFileELF.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 "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 class ObjectFileELFTest : public testing::Test {
-public:
-  void SetUp() override {
-    FileSystem::Initialize();
-    HostInfo::Initialize();
-    ObjectFileELF::Initialize();
-    SymbolFileSymtab::Initialize();
-  }
-
-  void TearDown() override {
-    SymbolFileSymtab::Terminate();
-    ObjectFileELF::Terminate();
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
-
-protected:
+  SubsystemRAII<FileSystem, HostInfo, ObjectFileELF, SymbolFileSymtab>
+      subsystems;
 };
 
 TEST_F(ObjectFileELFTest, SectionsResolveConsistently) {
   auto ExpectedFile = TestFile::fromYaml(R"(
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
)");
   ModuleSpec spec{FileSpec(ExpectedFile->name())};
   spec.GetSymbolFileSpec().SetFile(ExpectedFile->name(),
                                    FileSpec::Style::native);
   auto module_sp = std::make_shared<Module>(spec);
 
   auto entry_point_addr = module_sp->GetObjectFile()->GetEntryPointAddress();
   ASSERT_EQ(entry_point_addr.GetAddressClass(), AddressClass::eCode);
 }
 No newline at end of file

lldb/unittests/ObjectFile/PECOFF/TestPECallFrameInfo.cpp

 //===-- TestPECallFrameInfo.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 "gtest/gtest.h"
 
 #include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
 #include "Plugins/Process/Utility/lldb-x86-register-enums.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/CallFrameInfo.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 class PECallFrameInfoTest : public testing::Test {
-public:
-  void SetUp() override {
-    FileSystem::Initialize();
-    ObjectFilePECOFF::Initialize();
-  }
-
-  void TearDown() override {
-    ObjectFilePECOFF::Terminate();
-    FileSystem::Terminate();
-  }
+  SubsystemRAII<FileSystem, ObjectFilePECOFF> subsystems;
 
 protected:
   void GetUnwindPlan(addr_t file_addr, UnwindPlan &plan) const;
 };
 
 void PECallFrameInfoTest::GetUnwindPlan(addr_t file_addr, UnwindPlan &plan) const {
   llvm::Expected<TestFile> ExpectedFile = TestFile::fromYaml(
       R"(

lldb/unittests/Process/minidump/MinidumpParserTest.cpp

 //===-- MinidumpTypesTest.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 "Plugins/Process/minidump/MinidumpParser.h"
 #include "Plugins/Process/minidump/MinidumpTypes.h"
 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_32.h"
 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_64.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/FileSpec.h"
 #include "llvm/ADT/ArrayRef.h"

 // C++ includes
 #include <memory>
 
 using namespace lldb_private;
 using namespace minidump;
 
 class MinidumpParserTest : public testing::Test {
 public:
-  void SetUp() override { FileSystem::Initialize(); }
-
-  void TearDown() override { FileSystem::Terminate(); }
+  SubsystemRAII<FileSystem> subsystems;
 
   void SetUpData(const char *minidump_filename) {
     std::string filename = GetInputFilePath(minidump_filename);
     auto BufferPtr = FileSystem::Instance().CreateDataBuffer(filename, -1, 0);
     ASSERT_NE(BufferPtr, nullptr);
     llvm::Expected<MinidumpParser> expected_parser =
         MinidumpParser::Create(BufferPtr);
     ASSERT_THAT_EXPECTED(expected_parser, llvm::Succeeded());

lldb/unittests/Symbol/LocateSymbolFileTest.cpp

 //===-- SymbolsTest.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 "gtest/gtest.h"
 
+#include "TestingSupport/SubsystemRAII.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Target/Target.h"
 
 using namespace lldb_private;
 
 namespace {
 class SymbolsTest : public ::testing::Test {
 public:
-  void SetUp() override {
-    FileSystem::Initialize();
-    HostInfo::Initialize();
-  }
-  void TearDown() override {
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
+  SubsystemRAII<FileSystem, HostInfo> subsystems;
 };
 } // namespace
 
 TEST_F(
     SymbolsTest,
     TerminateLocateExecutableSymbolFileForUnknownExecutableAndUnknownSymbolFile) {
   ModuleSpec module_spec;
   FileSpecList search_paths = Target::GetDefaultDebugFileSearchPaths();

lldb/unittests/Symbol/TestClangASTContext.cpp

 //===-- TestClangASTContext.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 "TestingSupport/SubsystemRAII.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/Declaration.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/ExprCXX.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace lldb;
 using namespace lldb_private;
 
 class TestClangASTContext : public testing::Test {
 public:
-  static void SetUpTestCase() {
-    FileSystem::Initialize();
-    HostInfo::Initialize();
-  }
-
-  static void TearDownTestCase() {
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
+  SubsystemRAII<FileSystem, HostInfo> subsystems;
 
   void SetUp() override {
     std::string triple = HostInfo::GetTargetTriple();
     m_ast.reset(new ClangASTContext(triple.c_str()));
   }
 
   void TearDown() override { m_ast.reset(); }
 

lldb/unittests/Symbol/TestClangASTImporter.cpp

 //===-- TestClangASTImporter.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 "gtest/gtest.h"
 
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/Symbol/ClangTestUtils.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/ClangASTMetadata.h"
 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/Declaration.h"
 #include "clang/AST/DeclCXX.h"
 
 using namespace clang;
 using namespace lldb;
 using namespace lldb_private;
 
 class TestClangASTImporter : public testing::Test {
 public:
-  static void SetUpTestCase() {
-    FileSystem::Initialize();
-    HostInfo::Initialize();
-  }
-
-  static void TearDownTestCase() {
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
+  SubsystemRAII<FileSystem, HostInfo> subsystems;
 };
 
 TEST_F(TestClangASTImporter, CanImportInvalidType) {
   ClangASTImporter importer;
   EXPECT_FALSE(importer.CanImport(CompilerType()));
 }
 
 TEST_F(TestClangASTImporter, ImportInvalidType) {

lldb/unittests/Symbol/TestDWARFCallFrameInfo.cpp

 //===-- TestDWARFCallFrameInfo.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 "gtest/gtest.h"
 
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/Process/Utility/RegisterContext_x86.h"
 #include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/Testing/Support/Error.h"
 
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 class DWARFCallFrameInfoTest : public testing::Test {
-public:
-  void SetUp() override {
-    FileSystem::Initialize();
-    HostInfo::Initialize();
-    ObjectFileELF::Initialize();
-    SymbolFileSymtab::Initialize();
-  }
-
-  void TearDown() override {
-    SymbolFileSymtab::Terminate();
-    ObjectFileELF::Terminate();
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
+  SubsystemRAII<FileSystem, HostInfo, ObjectFileELF, SymbolFileSymtab>
+      subsystems;
 
 protected:
   void TestBasic(DWARFCallFrameInfo::Type type, llvm::StringRef symbol);
 };
 
 namespace lldb_private {
 static std::ostream &operator<<(std::ostream &OS, const UnwindPlan::Row &row) {
   StreamString SS;

lldb/unittests/Symbol/TestLineEntry.cpp

 //===-- TestLineEntry.cpp ------------------------------*- C++ -*-===//
 //
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 #include <iostream>
 
 #include "Plugins/ObjectFile/Mach-O/ObjectFileMachO.h"
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Symbol/ClangASTContext.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/SymbolContext.h"
 
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Testing/Support/Error.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 class LineEntryTest : public testing::Test {
+  SubsystemRAII<FileSystem, HostInfo, ObjectFileMachO, SymbolFileDWARF,
+                ClangASTContext>
+      subsystem;
+
 public:
   void SetUp() override;
 
-  void TearDown() override {
-    ClangASTContext::Terminate();
-    SymbolFileDWARF::Terminate();
-    ObjectFileMachO::Terminate();
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
-
 protected:
   llvm::Expected<LineEntry> GetLineEntryForLine(uint32_t line);
   llvm::Optional<TestFile> m_file;
   ModuleSP m_module_sp;
 };
 
 void LineEntryTest::SetUp() {
-  FileSystem::Initialize();
-  HostInfo::Initialize();
-  ObjectFileMachO::Initialize();
-  SymbolFileDWARF::Initialize();
-  ClangASTContext::Initialize();
   auto ExpectedFile = TestFile::fromYamlFile("inlined-functions.yaml");
   ASSERT_THAT_EXPECTED(ExpectedFile, llvm::Succeeded());
   m_file.emplace(std::move(*ExpectedFile));
   m_module_sp = std::make_shared<Module>(ModuleSpec(FileSpec(m_file->name())));
 }
 
 llvm::Expected<LineEntry> LineEntryTest::GetLineEntryForLine(uint32_t line) {
   bool check_inlines = true;

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

 //===-- DWARFASTParserClangTests.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 "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
+#include "TestingSupport/SubsystemRAII.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class DWARFASTParserClangTests : public testing::Test {
-public:
-  void SetUp() override {
-    FileSystem::Initialize();
-    ClangASTContext::Initialize();
-  }
-
-  void TearDown() override {
-    ClangASTContext::Terminate();
-    FileSystem::Terminate();
-  }
+  SubsystemRAII<FileSystem, ClangASTContext> subsystems;
 };
 
 namespace {
 class DWARFASTParserClangStub : public DWARFASTParserClang {
 public:
   using DWARFASTParserClang::DWARFASTParserClang;
   using DWARFASTParserClang::LinkDeclContextToDIE;
 

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

 #include "llvm/Support/Path.h"
 
 #include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
 #include "Plugins/SymbolFile/DWARF/DWARFAbbreviationDeclaration.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDataExtractor.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugAbbrev.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataEncoder.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StreamString.h"
 
 
 
 using namespace lldb;
 using namespace lldb_private;
 
 class SymbolFileDWARFTests : public testing::Test {
+  SubsystemRAII<FileSystem, HostInfo, ObjectFilePECOFF, SymbolFileDWARF,
+                ClangASTContext, SymbolFilePDB>
+      subsystems;
+
 public:
   void SetUp() override {
-// Initialize and TearDown the plugin every time, so we get a brand new
-// AST every time so that modifications to the AST from each test don't
-// leak into the next test.
-FileSystem::Initialize();
-HostInfo::Initialize();
-ObjectFilePECOFF::Initialize();
-SymbolFileDWARF::Initialize();
-ClangASTContext::Initialize();
-SymbolFilePDB::Initialize();
-
     m_dwarf_test_exe = GetInputFilePath("test-dwarf.exe");
   }
 
-  void TearDown() override {
-    SymbolFilePDB::Terminate();
-    ClangASTContext::Initialize();
-    SymbolFileDWARF::Terminate();
-    ObjectFilePECOFF::Terminate();
-    HostInfo::Terminate();
-    FileSystem::Terminate();
-  }
-
 protected:
   std::string m_dwarf_test_exe;
 };
 
 TEST_F(SymbolFileDWARFTests, TestAbilitiesForDWARF) {
   // Test that when we have Dwarf debug info, SymbolFileDWARF is used.
   FileSpec fspec(m_dwarf_test_exe);
   ArchSpec aspec("i686-pc-windows");

lldb/unittests/Target/ModuleCacheTest.cpp

 #include "gtest/gtest.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
+#include "TestingSupport/SubsystemRAII.h"
 #include "TestingSupport/TestUtilities.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ModuleCache.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 namespace {
 
 class ModuleCacheTest : public testing::Test {
-public:
-  static void SetUpTestCase();
+  SubsystemRAII<FileSystem, HostInfo, ObjectFileELF, SymbolFileSymtab>
+      subsystems;
 
-  static void TearDownTestCase();
+public:
+  void SetUp() override;
 
 protected:
-  static FileSpec s_cache_dir;
-  static std::string s_test_executable;
+  FileSpec s_cache_dir;
+  std::string s_test_executable;
 
   void TryGetAndPut(const FileSpec &cache_dir, const char *hostname,
                     bool expect_download);
 };
 }
 
-FileSpec ModuleCacheTest::s_cache_dir;
-std::string ModuleCacheTest::s_test_executable;
-
 static const char dummy_hostname[] = "dummy_hostname";
 static const char dummy_remote_dir[] = "bin";
 static const char module_name[] = "TestModule.so";
 static const char module_uuid[] =
     "F4E7E991-9B61-6AD4-0073-561AC3D9FA10-C043A476";
 static const uint32_t uuid_bytes = 20;
 static const size_t module_size = 5602;
 

 
 static FileSpec GetSysrootView(FileSpec spec, const char *hostname) {
   spec.AppendPathComponent(hostname);
   spec.AppendPathComponent(dummy_remote_dir);
   spec.AppendPathComponent(module_name);
   return spec;
 }
 
-void ModuleCacheTest::SetUpTestCase() {
-  FileSystem::Initialize();
-  HostInfo::Initialize();
-  ObjectFileELF::Initialize();
-  SymbolFileSymtab::Initialize();
-
+void ModuleCacheTest::SetUp() {
   s_cache_dir = HostInfo::GetProcessTempDir();
   s_test_executable = GetInputFilePath(module_name);
 }
 
-void ModuleCacheTest::TearDownTestCase() {
-  SymbolFileSymtab::Terminate();
-  ObjectFileELF::Terminate();
-  HostInfo::Terminate();
-  FileSystem::Terminate();
-}
-
 static void VerifyDiskState(const FileSpec &cache_dir, const char *hostname) {
   FileSpec uuid_view = GetUuidView(cache_dir);
   EXPECT_TRUE(FileSystem::Instance().Exists(uuid_view))
       << "uuid_view is: " << uuid_view.GetCString();
   EXPECT_EQ(module_size, FileSystem::Instance().GetByteSize(uuid_view));
 
   FileSpec sysroot_view = GetSysrootView(cache_dir, hostname);
   EXPECT_TRUE(FileSystem::Instance().Exists(sysroot_view))
void ModuleCacheTest::TryGetAndPut(const FileSpec &cache_dir,
   module_spec.GetUUID().SetFromStringRef(module_uuid, uuid_bytes);
   module_spec.SetObjectSize(module_size);
   ModuleSP module_sp;
   bool did_create;
   bool download_called = false;
 
   Status error = mc.GetAndPut(
       cache_dir, hostname, module_spec,
-      [&download_called](const ModuleSpec &module_spec,
+      [&download_called, this](const ModuleSpec &module_spec,
                                const FileSpec &tmp_download_file_spec) {
         download_called = true;
         EXPECT_STREQ(GetDummyRemotePath().GetCString(),
                      module_spec.GetFileSpec().GetCString());
         std::error_code ec = llvm::sys::fs::copy_file(
             s_test_executable, tmp_download_file_spec.GetCString());
         EXPECT_FALSE(ec);
         return Status();
       },

lldb/unittests/TestingSupport/SubsystemRAII.h

+//===- SubsystemRAII.h ------------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UNITTESTS_TESTINGSUPPORT_SUBSYSTEMRAII_H
+#define LLDB_UNITTESTS_TESTINGSUPPORT_SUBSYSTEMRAII_H
+
+#include "llvm/Support/Error.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gtest/gtest.h"
+#include <type_traits>
+
+namespace lldb_private {
+
+namespace detail {
+/// Initializes and deinitializes a single subsystem.
+/// @see SubsystemRAII
+template <typename T> struct SubsystemRAIICase {
+
+  /// Calls ::Initialize if it has a void return type.
+  template <typename U = T>
+  typename std::enable_if<
+      std::is_same<decltype(U::Initialize()), void>::value>::type
+  CallInitialize() {
+    T::Initialize();
+  }
+
+  /// Calls ::Initialize if it has a llvm::Error return type and checks
+  /// the Error instance for success.
+  template <typename U = T>
+  typename std::enable_if<
+      std::is_same<decltype(U::Initialize()), llvm::Error>::value>::type
+  CallInitialize() {
+    ASSERT_THAT_ERROR(T::Initialize(), llvm::Succeeded());
+  }
+
+  SubsystemRAIICase() { CallInitialize(); }
+  ~SubsystemRAIICase() { T::Terminate(); }
+};
+} // namespace detail
+
+template <typename... T> class SubsystemRAII {};
+
+/// RAII for initializing and deinitializing LLDB subsystems.
+///
+/// This RAII takes care of calling the Initialize and Terminate functions for
+/// the subsystems specified by its template arguments. The ::Initialize
+/// functions are called on construction for each subsystem template parameter
+/// in the order in which they are passed as template parameters.
+/// The ::Terminate functions are called in the reverse order at destruction
+/// time.
+///
+/// If the ::Initialize function returns an llvm::Error this function handles
+/// the Error instance (by checking that there is no error).
+///
+/// Constructing this RAII in a scope like this:
+///
+///   @code{.cpp}
+///   {
+///     SubsystemRAII<FileSystem, HostInfo, Socket> Subsystems;
+///     DoingTestWork();
+///   }
+///   @endcode
+///
+/// is equivalent to the following code:
+///
+///   @code{.cpp}
+///   {
+///     FileSystem::Initialize();
+///     HostInfo::Initialize();
+///     ASSERT_THAT_ERROR(Socket::Initialize(), llvm::Succeeded());
+///
+///     DoingTestWork();
+///
+///     Socket::Terminate();
+///     FileSystem::Terminate();
+///     HostInfo::Terminate();
+///   }
+///   @endcode
+template <typename T, typename... Ts> class SubsystemRAII<T, Ts...> {
+  detail::SubsystemRAIICase<T> CurrentSubsystem;
+  SubsystemRAII<Ts...> RemainingSubsystems;
+};
+} // namespace lldb_private
+
+#endif // LLDB_UNITTESTS_TESTINGSUPPORT_SUBSYSTEMRAII_H

lldb/unittests/Utility/CMakeLists.txt

add_lldb_unittest(UtilityTests
   StateTest.cpp
   StatusTest.cpp
   StreamTeeTest.cpp
   StreamTest.cpp
   StringExtractorTest.cpp
   StringLexerTest.cpp
   StringListTest.cpp
   StructuredDataTest.cpp
+  SubsystemRAIITest.cpp
   TildeExpressionResolverTest.cpp
   TimeoutTest.cpp
   TimerTest.cpp
   UriParserTest.cpp
   UserIDResolverTest.cpp
   UUIDTest.cpp
   VASprintfTest.cpp
   VMRangeTest.cpp

lldb/unittests/Utility/SubsystemRAIITest.cpp

+//===-- SubsystemRAIITest.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 "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
+
+#include "TestingSupport/SubsystemRAII.h"
+
+using namespace lldb_private;
+
+namespace {
+
+enum class SystemState {
+  /// Start state of the subsystem.
+  Start,
+  /// Initialize has been called but Terminate hasn't been called yet.
+  Initialized,
+  /// Terminate has been called.
+  Terminated
+};
+
+struct TestSubsystem {
+  static SystemState state;
+  static void Initialize() {
+    assert(state == SystemState::Start);
+    state = SystemState::Initialized;
+  }
+  static void Terminate() {
+    assert(state == SystemState::Initialized);
+    state = SystemState::Terminated;
+  }
+};
+} // namespace
+
+SystemState TestSubsystem::state = SystemState::Start;
+
+TEST(SubsystemRAIITest, NormalSubsystem) {
+  // Tests that SubsystemRAII handles Initialize functions that return void.
+  EXPECT_EQ(SystemState::Start, TestSubsystem::state);
+  {
+    SubsystemRAII<TestSubsystem> subsystem;
+    EXPECT_EQ(SystemState::Initialized, TestSubsystem::state);
+  }
+  EXPECT_EQ(SystemState::Terminated, TestSubsystem::state);
+}
+
+static const char *SubsystemErrorString = "Initialize failed";
+
+namespace {
+struct TestSubsystemWithError {
+  static SystemState state;
+  static bool will_fail;
+  static llvm::Error Initialize() {
+    assert(state == SystemState::Start);
+    state = SystemState::Initialized;
+    if (will_fail)
+      return llvm::make_error<llvm::StringError>(
+          SubsystemErrorString, llvm::inconvertibleErrorCode());
+    return llvm::Error::success();
+  }
+  static void Terminate() {
+    assert(state == SystemState::Initialized);
+    state = SystemState::Terminated;
+  }
+  /// Reset the subsystem to the default state for testing.
+  static void Reset() { state = SystemState::Start; }
+};
+} // namespace
+
+SystemState TestSubsystemWithError::state = SystemState::Start;
+bool TestSubsystemWithError::will_fail = false;
+
+TEST(SubsystemRAIITest, SubsystemWithErrorSuccess) {
+  // Tests that SubsystemRAII handles llvm::success() returned from
+  // Initialize.
+  TestSubsystemWithError::Reset();
+  EXPECT_EQ(SystemState::Start, TestSubsystemWithError::state);
+  {
+    TestSubsystemWithError::will_fail = false;
+    SubsystemRAII<TestSubsystemWithError> subsystem;
+    EXPECT_EQ(SystemState::Initialized, TestSubsystemWithError::state);
+  }
+  EXPECT_EQ(SystemState::Terminated, TestSubsystemWithError::state);
+}
+
+TEST(SubsystemRAIITest, SubsystemWithErrorFailure) {
+  // Tests that SubsystemRAII handles any errors returned from
+  // Initialize.
+  TestSubsystemWithError::Reset();
+  EXPECT_EQ(SystemState::Start, TestSubsystemWithError::state);
+  TestSubsystemWithError::will_fail = true;
+  EXPECT_FATAL_FAILURE(SubsystemRAII<TestSubsystemWithError> subsystem,
+                       SubsystemErrorString);
+}