[unittests] Add a helper function for getting an input file

[labath]

Summary

Fetching an input file required about five lines of code, and this was
repeated in multiple unit tests, with slight variations. Add a helper
function for doing that into the lldbUtilityMocks module (which I rename
to lldbUtilityHelpers to commemorate the fact it includes more than
mocks)

[eugene]

Great change. The only comment I have is about location of TestUtilities.cpp.
Utility\Helpers kinda implies that these are helpers for Utility tests which is not true.

I would move it up one level up lldb/unittests/TestUtilities.cpp

[zturner]

unittests/Utility/Helpers/TestUtilities.cpp

17

this should be const Twine &name. Also can you call this GetInputFilePath()? At first I was assuming it would return the contents of the file.

[labath]

In D34683#792736, @eugene wrote:

The only comment I have is about location of TestUtilities.cpp.
Utility\Helpers kinda implies that these are helpers for Utility tests which is not true.

I would move it up one level up lldb/unittests/TestUtilities.cpp

Hm.. that makes sort of sense for this function.

However, right now I can't think of any other utility function that would go here. OTOH, I have a couple of ideas about the use of the XXX/Helpers/YYY.h pattern. For example, in Host/Helpers we could have a utility function which creates two connected sockets (already needed for a couple tests), and Core/Helpers could contain mocked versions of various Process/Target/... classes (as no higher level functionality can be tested without one of those around).

That's why I'd like to avoid creating a module if it's going to contain just this function. And with that in mind putting in in Utility/Helpers makes sense as that's the place everyone can pull it from without grabbing additional dependencies.

unittests/Interpreter/CMakeLists.txt

 add_lldb_unittest(InterpreterTests
   TestArgs.cpp
   TestCompletion.cpp
 
   LINK_LIBS
     lldbInterpreter
-    lldbUtilityMocks
+    lldbUtilityHelpers
   )
 
 target_link_libraries(InterpreterTests
   ${PYTHON_LIBRARY}
   )

unittests/Interpreter/TestCompletion.cpp

 //===-- TestCompletion.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 "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/Utility/TildeExpressionResolver.h"
 
+#include "unittests/Utility/Helpers/MockTildeExpressionResolver.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
-#include "unittests/Utility/Mocks/MockTildeExpressionResolver.h"
-
 namespace fs = llvm::sys::fs;
 namespace path = llvm::sys::path;
 using namespace llvm;
 using namespace lldb_private;
 
 #define ASSERT_NO_ERROR(x)                                                     \
   if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
     SmallString<128> MessageStorage;                                           \

unittests/ObjectFile/ELF/CMakeLists.txt

 add_lldb_unittest(ObjectFileELFTests
   TestELFHeader.cpp
   TestObjectFileELF.cpp
 
   LINK_LIBS
     lldbPluginObjectFileELF
     lldbPluginSymbolVendorELF
     lldbCore
+    lldbUtilityHelpers
   )
 
 add_dependencies(ObjectFileELFTests yaml2obj)
 add_definitions(-DYAML2OBJ="$<TARGET_FILE:yaml2obj>")
 
 set(test_inputs
   sections-resolve-consistently.yaml
   )
 add_unittest_inputs(ObjectFileELFTests "${test_inputs}")

unittests/ObjectFile/ELF/TestObjectFileELF.cpp

 //===-- TestObjectFileELF.cpp -----------------------------------*- C++ -*-===//
 //
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
+#include "Plugins/SymbolVendor/ELF/SymbolVendorELF.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/HostInfo.h"
+#include "unittests/Utility/Helpers/TestUtilities.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 
-#include "Plugins/SymbolVendor/ELF/SymbolVendorELF.h"
-
-extern const char *TestMainArgv0;
-
 using namespace lldb_private;
 using namespace lldb;
 
 class ObjectFileELFTest : public testing::Test {
 public:
   void SetUp() override {
     HostInfo::Initialize();
     ObjectFileELF::Initialize();
     SymbolVendorELF::Initialize();
-
-    m_inputs_folder = llvm::sys::path::parent_path(TestMainArgv0);
-    llvm::sys::path::append(m_inputs_folder, "Inputs");
-    llvm::sys::fs::make_absolute(m_inputs_folder);
   }
 
   void TearDown() override {
     SymbolVendorELF::Terminate();
     ObjectFileELF::Terminate();
     HostInfo::Terminate();
   }
 
 protected:
-  llvm::SmallString<128> m_inputs_folder;
 };
 
 #define ASSERT_NO_ERROR(x)                                                     \
   if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
     llvm::SmallString<128> MessageStorage;                                     \
     llvm::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 {                                                                     \
   }
 
 TEST_F(ObjectFileELFTest, SectionsResolveConsistently) {
-  llvm::SmallString<128> yaml = m_inputs_folder;
-  llvm::sys::path::append(yaml, "sections-resolve-consistently.yaml");
-  llvm::SmallString<128> obj = m_inputs_folder;
+  std::string yaml = GetInputFile("sections-resolve-consistently.yaml");
+  llvm::SmallString<128> obj;
   ASSERT_NO_ERROR(llvm::sys::fs::createTemporaryFile(
       "sections-resolve-consistently-%%%%%%", "obj", obj));
 
   llvm::FileRemover remover(obj);
   const char *args[] = {YAML2OBJ, yaml.c_str(), nullptr};
   llvm::StringRef obj_ref = obj;
   const llvm::StringRef *redirects[] = {nullptr, &obj_ref, nullptr};
   ASSERT_EQ(0, llvm::sys::ExecuteAndWait(YAML2OBJ, args, nullptr, redirects));

unittests/Process/minidump/CMakeLists.txt

 add_lldb_unittest(LLDBMinidumpTests
   MinidumpParserTest.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbTarget
     lldbPluginProcessUtility
     lldbPluginProcessMinidump
+    lldbUtilityHelpers
   LINK_COMPONENTS
     Support
   )
 
 set(test_inputs
    linux-i386.dmp
    linux-x86_64.dmp
    linux-x86_64_not_crashed.dmp
    fizzbuzz_no_heap.dmp
    fizzbuzz_wow64.dmp)
 
 add_unittest_inputs(LLDBMinidumpTests "${test_inputs}")

unittests/Process/minidump/MinidumpParserTest.cpp

 // Other libraries and framework includes
 #include "gtest/gtest.h"
 
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/FileSpec.h"
-
+#include "unittests/Utility/Helpers/TestUtilities.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 
 // C includes
 
 // C++ includes
 #include <memory>
 
-extern const char *TestMainArgv0;
-
 using namespace lldb_private;
 using namespace minidump;
 
 class MinidumpParserTest : public testing::Test {
 public:
-  void SetUp() override {
-    llvm::StringRef dmp_folder = llvm::sys::path::parent_path(TestMainArgv0);
-    inputs_folder = dmp_folder;
-    llvm::sys::path::append(inputs_folder, "Inputs");
-  }
-
   void SetUpData(const char *minidump_filename,
                  uint64_t load_size = UINT64_MAX) {
-    llvm::SmallString<128> filename = inputs_folder;
-    llvm::sys::path::append(filename, minidump_filename);
-
+    std::string filename = GetInputFile(minidump_filename);
     auto BufferPtr = DataBufferLLVM::CreateSliceFromPath(filename, load_size, 0);
 
     llvm::Optional<MinidumpParser> optional_parser =
         MinidumpParser::Create(BufferPtr);
     ASSERT_TRUE(optional_parser.hasValue());
     parser.reset(new MinidumpParser(optional_parser.getValue()));
     ASSERT_GT(parser->GetData().size(), 0UL);
   }
 
-  llvm::SmallString<128> inputs_folder;
   std::unique_ptr<MinidumpParser> parser;
 };
 
 TEST_F(MinidumpParserTest, GetThreadsAndGetThreadContext) {
   SetUpData("linux-x86_64.dmp");
   llvm::ArrayRef<MinidumpThread> thread_list;
 
   thread_list = parser->GetThreads();

unittests/Symbol/CMakeLists.txt

 add_lldb_unittest(SymbolTests
   TestClangASTContext.cpp
   TestDWARFCallFrameInfo.cpp
   TestType.cpp
 
   LINK_LIBS
     lldbHost
     lldbSymbol
+    lldbUtilityHelpers
   )
 
 add_dependencies(SymbolTests yaml2obj)
 add_definitions(-DYAML2OBJ="$<TARGET_FILE:yaml2obj>")
 set(test_inputs
   basic-call-frame-info.yaml
   )
 add_unittest_inputs(SymbolTests "${test_inputs}")

unittests/Symbol/TestDWARFCallFrameInfo.cpp

 #include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
 #include "Plugins/Process/Utility/RegisterContext_x86.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Utility/StreamString.h"
+#include "unittests/Utility/Helpers/TestUtilities.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 
-extern const char *TestMainArgv0;
-
 using namespace lldb_private;
 using namespace lldb;
 
 class DWARFCallFrameInfoTest : public testing::Test {
 public:
   void SetUp() override {
     HostInfo::Initialize();
     ObjectFileELF::Initialize();
-
-    m_inputs_folder = llvm::sys::path::parent_path(TestMainArgv0);
-    llvm::sys::path::append(m_inputs_folder, "Inputs");
-    llvm::sys::fs::make_absolute(m_inputs_folder);
   }
 
   void TearDown() override {
     ObjectFileELF::Terminate();
     HostInfo::Terminate();
   }
 
 protected:
-  llvm::SmallString<128> m_inputs_folder;
-
   void TestBasic(DWARFCallFrameInfo::Type type, llvm::StringRef symbol);
 };
 
 #define ASSERT_NO_ERROR(x)                                                     \
   if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
     llvm::SmallString<128> MessageStorage;                                     \
     llvm::raw_svector_ostream Message(MessageStorage);                         \
     Message << #x ": did not return errc::success.\n"                          \
static UnwindPlan::Row GetExpectedRow2() {
   row.GetCFAValue().SetIsRegisterPlusOffset(dwarf_rbp_x86_64, 16);
   row.SetRegisterLocationToAtCFAPlusOffset(dwarf_rip_x86_64, -8, false);
   row.SetRegisterLocationToAtCFAPlusOffset(dwarf_rbp_x86_64, -16, false);
   return row;
 }
 
 void DWARFCallFrameInfoTest::TestBasic(DWARFCallFrameInfo::Type type,
                                        llvm::StringRef symbol) {
-  llvm::SmallString<128> yaml = m_inputs_folder;
-  llvm::sys::path::append(yaml, "basic-call-frame-info.yaml");
-  llvm::SmallString<128> obj = m_inputs_folder;
+  std::string yaml = GetInputFile("basic-call-frame-info.yaml");
+  llvm::SmallString<128> obj;
 
   ASSERT_NO_ERROR(llvm::sys::fs::createTemporaryFile(
       "basic-call-frame-info-%%%%%%", "obj", obj));
   llvm::FileRemover obj_remover(obj);
 
   const char *args[] = {YAML2OBJ, yaml.c_str(), nullptr};
   llvm::StringRef obj_ref = obj;
   const llvm::StringRef *redirects[] = {nullptr, &obj_ref, nullptr};

unittests/SymbolFile/DWARF/CMakeLists.txt

 add_lldb_unittest(SymbolFileDWARFTests
   SymbolFileDWARFTests.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbSymbol
     lldbPluginObjectFilePECOFF
     lldbPluginSymbolFileDWARF
     lldbPluginSymbolFilePDB
+    lldbUtilityHelpers
   LINK_COMPONENTS
     Support
     DebugInfoPDB
   )
 
 set(test_inputs
    test-dwarf.exe)
 
 add_unittest_inputs(SymbolFileDWARFTests "${test_inputs}")

unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

 #include "gtest/gtest.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
+#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
+#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
+#include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Utility/FileSpec.h"
-
-#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
-#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
-#include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
-
-extern const char *TestMainArgv0;
+#include "unittests/Utility/Helpers/TestUtilities.h"
 
 using namespace lldb_private;
 
 class SymbolFileDWARFTests : public testing::Test {
 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.
     HostInfo::Initialize();
     ObjectFilePECOFF::Initialize();
     SymbolFileDWARF::Initialize();
     ClangASTContext::Initialize();
     SymbolFilePDB::Initialize();
 
-    llvm::StringRef exe_folder = llvm::sys::path::parent_path(TestMainArgv0);
-    llvm::SmallString<128> inputs_folder = exe_folder;
-    llvm::sys::path::append(inputs_folder, "Inputs");
-
-    m_dwarf_test_exe = inputs_folder;
-    llvm::sys::path::append(m_dwarf_test_exe, "test-dwarf.exe");
+    m_dwarf_test_exe = GetInputFile("test-dwarf.exe");
   }
 
   void TearDown() override {
     SymbolFilePDB::Terminate();
     ClangASTContext::Initialize();
     SymbolFileDWARF::Terminate();
     ObjectFilePECOFF::Terminate();
     HostInfo::Terminate();
   }
 
 protected:
-  llvm::SmallString<128> m_dwarf_test_exe;
+  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.c_str(), false);
+  FileSpec fspec(m_dwarf_test_exe, false);
   ArchSpec aspec("i686-pc-windows");
   lldb::ModuleSP module = std::make_shared<Module>(fspec, aspec);
 
   SymbolVendor *plugin = module->GetSymbolVendor();
   EXPECT_NE(nullptr, plugin);
   SymbolFile *symfile = plugin->GetSymbolFile();
   EXPECT_NE(nullptr, symfile);
   EXPECT_EQ(symfile->GetPluginName(), SymbolFileDWARF::GetPluginNameStatic());
 
   uint32_t expected_abilities = SymbolFile::kAllAbilities;
   EXPECT_EQ(expected_abilities, symfile->CalculateAbilities());
 }

unittests/SymbolFile/PDB/CMakeLists.txt

 add_lldb_unittest(SymbolFilePDBTests
   SymbolFilePDBTests.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbSymbol
     lldbPluginObjectFilePECOFF
     lldbPluginSymbolFileDWARF
     lldbPluginSymbolFilePDB
+    lldbUtiltyHelpers
   LINK_COMPONENTS
     Support
     DebugInfoPDB
   )
 
 set(test_inputs
    test-pdb.exe
    test-pdb.pdb
    test-pdb-types.exe
    test-pdb-types.pdb)
 
 add_unittest_inputs(SymbolFilePDBTests "${test_inputs}")

unittests/SymbolFile/PDB/SymbolFilePDBTests.cpp

 #include "gtest/gtest.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
+#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
+#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
+#include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Utility/FileSpec.h"
-
-#include "Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h"
-#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
-#include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
+#include "unittests/Utility/Helpers/TestUtilities.h"
 
 #if defined(_MSC_VER)
 #include "lldb/Host/windows/windows.h"
 #include <objbase.h>
 #endif
 
 #include <algorithm>
 
-extern const char *TestMainArgv0;
-
 using namespace lldb_private;
 
 class SymbolFilePDBTests : public testing::Test {
 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.
 #if defined(_MSC_VER)
     ::CoInitializeEx(nullptr, COINIT_MULTITHREADED);
 #endif
 
     HostInfo::Initialize();
     ObjectFilePECOFF::Initialize();
     SymbolFileDWARF::Initialize();
     ClangASTContext::Initialize();
     SymbolFilePDB::Initialize();
 
     llvm::StringRef exe_folder = llvm::sys::path::parent_path(TestMainArgv0);
     llvm::SmallString<128> inputs_folder = exe_folder;
     llvm::sys::path::append(inputs_folder, "Inputs");
 
-    m_pdb_test_exe = inputs_folder;
-    m_types_test_exe = inputs_folder;
-    llvm::sys::path::append(m_pdb_test_exe, "test-pdb.exe");
-    llvm::sys::path::append(m_types_test_exe, "test-pdb-types.exe");
+    m_pdb_test_exe = GetInputFile("test-pdb.exe");
+    m_types_test_exe = GetInputFile("test-pdb-types.exe");
   }
 
   void TearDown() override {
     SymbolFilePDB::Terminate();
     ClangASTContext::Initialize();
     SymbolFileDWARF::Terminate();
     ObjectFilePECOFF::Terminate();
     HostInfo::Terminate();
 
 #if defined(_MSC_VER)
     ::CoUninitialize();
 #endif
   }
 
 protected:
-  llvm::SmallString<128> m_pdb_test_exe;
-  llvm::SmallString<128> m_types_test_exe;
+  std::string m_pdb_test_exe;
+  std::string m_types_test_exe;
 
   bool FileSpecMatchesAsBaseOrFull(const FileSpec &left,
                                    const FileSpec &right) const {
     // If the filenames don't match, the paths can't be equal
     if (!left.FileEquals(right))
       return false;
     // If BOTH have a directory, also compare the directories.
     if (left.GetDirectory() && right.GetDirectory())

unittests/Target/CMakeLists.txt

 add_lldb_unittest(TargetTests
   MemoryRegionInfoTest.cpp
   ModuleCacheTest.cpp
 
   LINK_LIBS
       lldbCore
       lldbHost
       lldbSymbol
       lldbUtility
       lldbPluginObjectFileELF
+      lldbUtilityHelpers
     LINK_COMPONENTS
       Support
   )
 
 add_unittest_inputs(TargetTests TestModule.so)

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 "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ModuleCache.h"
-
-extern const char *TestMainArgv0;
+#include "unittests/Utility/Helpers/TestUtilities.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 namespace {
 
 class ModuleCacheTest : public testing::Test {
 public:
   static void SetUpTestCase();
 
   static void TearDownTestCase();
 
 protected:
   static FileSpec s_cache_dir;
-  static llvm::SmallString<128> s_test_executable;
+  static std::string s_test_executable;
 
   void TryGetAndPut(const FileSpec &cache_dir, const char *hostname,
                     bool expect_download);
 };
 }
 
 FileSpec ModuleCacheTest::s_cache_dir;
-llvm::SmallString<128> ModuleCacheTest::s_test_executable;
+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;

 }
 
 void ModuleCacheTest::SetUpTestCase() {
   HostInfo::Initialize();
   ObjectFileELF::Initialize();
 
   FileSpec tmpdir_spec;
   HostInfo::GetLLDBPath(lldb::ePathTypeLLDBTempSystemDir, s_cache_dir);
-
-  llvm::StringRef exe_folder = llvm::sys::path::parent_path(TestMainArgv0);
-  s_test_executable = exe_folder;
-  llvm::sys::path::append(s_test_executable, "Inputs", module_name);
+  s_test_executable = GetInputFile(module_name);
 }
 
 void ModuleCacheTest::TearDownTestCase() {
   ObjectFileELF::Terminate();
   HostInfo::Terminate();
 }
 
 static void VerifyDiskState(const FileSpec &cache_dir, const char *hostname) {

unittests/Utility/CMakeLists.txt

-add_subdirectory(Mocks)
+add_subdirectory(Helpers)
 
 add_lldb_unittest(UtilityTests
   ConstStringTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
   StatusTest.cpp
   StringExtractorTest.cpp
   StructuredDataTest.cpp
   TaskPoolTest.cpp
   TildeExpressionResolverTest.cpp
   TimeoutTest.cpp
   UriParserTest.cpp
   VASprintfTest.cpp
 
   LINK_LIBS
       lldbUtility
-      lldbUtilityMocks
+      lldbUtilityHelpers
   LINK_COMPONENTS
     Support
   )
 
 add_unittest_inputs(UtilityTests
   StructuredData-basic.json
   )

unittests/Utility/Helpers/CMakeLists.txt

-add_lldb_library(lldbUtilityMocks
+set(EXCLUDE_FROM_ALL ON)
+add_lldb_library(lldbUtilityHelpers
   MockTildeExpressionResolver.cpp
+  TestUtilities.cpp
 
   LINK_LIBS
     lldbUtility
 
   LINK_COMPONENTS
     Support
   )

unittests/Utility/Helpers/MockTildeExpressionResolver.h

 //===--------------------- TildeExpressionResolver.h ------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_UNITTESTS_UTILITY_MOCKS_MOCK_TILDE_EXPRESSION_RESOLVER_H
 #define LLDB_UNITTESTS_UTILITY_MOCKS_MOCK_TILDE_EXPRESSION_RESOLVER_H
 
 #include "lldb/Utility/TildeExpressionResolver.h"
 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 
 namespace lldb_private {
 class MockTildeExpressionResolver : public TildeExpressionResolver {
   llvm::StringRef CurrentUser;
   llvm::StringMap<llvm::StringRef> UserDirectories;
 
 public:
   MockTildeExpressionResolver(llvm::StringRef CurrentUser,
                               llvm::StringRef HomeDir);
 
   void AddKnownUser(llvm::StringRef User, llvm::StringRef HomeDir);
   void Clear();
   void SetCurrentUser(llvm::StringRef User);
 
   bool ResolveExact(llvm::StringRef Expr,
                     llvm::SmallVectorImpl<char> &Output) override;
   bool ResolvePartial(llvm::StringRef Expr, llvm::StringSet<> &Output) override;
 };
 }
 
 #endif

unittests/Utility/Helpers/MockTildeExpressionResolver.cpp

 //===----------------- MockTildeExpressionResolver.cpp ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MockTildeExpressionResolver.h"
 #include "llvm/Support/Path.h"
 
 using namespace lldb_private;
 using namespace llvm;
 
 MockTildeExpressionResolver::MockTildeExpressionResolver(StringRef CurrentUser,
                                                          StringRef HomeDir)
     : CurrentUser(CurrentUser) {
   UserDirectories.insert(std::make_pair(CurrentUser, HomeDir));
 }
 
 void MockTildeExpressionResolver::AddKnownUser(StringRef User,
                                                StringRef HomeDir) {
   assert(UserDirectories.find(User) == UserDirectories.end());
   UserDirectories.insert(std::make_pair(User, HomeDir));
 }
 
 void MockTildeExpressionResolver::Clear() {
   CurrentUser = StringRef();
   UserDirectories.clear();
 }
 
 void MockTildeExpressionResolver::SetCurrentUser(StringRef User) {
   assert(UserDirectories.find(User) != UserDirectories.end());
   CurrentUser = User;
 }
 
 bool MockTildeExpressionResolver::ResolveExact(StringRef Expr,
                                                SmallVectorImpl<char> &Output) {
   Output.clear();
 
   assert(!llvm::any_of(
       Expr, [](char c) { return llvm::sys::path::is_separator(c); }));
   assert(Expr.empty() || Expr[0] == '~');
   Expr = Expr.drop_front();
   if (Expr.empty()) {
     auto Dir = UserDirectories[CurrentUser];
     Output.append(Dir.begin(), Dir.end());
     return true;
   }
 
   for (const auto &User : UserDirectories) {
     if (User.getKey() != Expr)
       continue;
     Output.append(User.getValue().begin(), User.getValue().end());
     return true;
   }
   return false;
 }
 
 bool MockTildeExpressionResolver::ResolvePartial(StringRef Expr,
                                                  StringSet<> &Output) {
   Output.clear();
 
   assert(!llvm::any_of(
       Expr, [](char c) { return llvm::sys::path::is_separator(c); }));
   assert(Expr.empty() || Expr[0] == '~');
   Expr = Expr.drop_front();
 
   SmallString<16> QualifiedName("~");
   for (const auto &User : UserDirectories) {
     if (!User.getKey().startswith(Expr))
       continue;
     QualifiedName.resize(1);
     QualifiedName.append(User.getKey().begin(), User.getKey().end());
     Output.insert(QualifiedName);
   }
 
   return !Output.empty();
 }

unittests/Utility/Helpers/TestUtilities.h

+//===- TestUtilities.h ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UNITTESTS_UTILITY_HELPERS_TESTUTILITIES_H
+#define LLDB_UNITTESTS_UTILITY_HELPERS_TESTUTILITIES_H
+
+#include "llvm/ADT/Twine.h"
+#include <string>
+
+namespace lldb_private {
+std::string GetInputFile(llvm::Twine name);
+}
+
+#endif

unittests/Utility/Helpers/TestUtilities.cpp

+//===- TestUtilities.cpp ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "TestUtilities.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+extern const char *TestMainArgv0;
+
+std::string lldb_private::GetInputFile(llvm::Twine name) {
+  llvm::SmallString<128> result = llvm::sys::path::parent_path(TestMainArgv0);
+  llvm::sys::fs::make_absolute(result);
+  llvm::sys::path::append(result, "Inputs", name);
+  return result.str();
+}

unittests/Utility/StructuredDataTest.cpp

 //===-- StructuredDataTest.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 "Helpers/TestUtilities.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/StructuredData.h"
 #include "llvm/Support/Path.h"
 
-extern const char *TestMainArgv0;
-
 using namespace lldb;
 using namespace lldb_private;
 
-namespace {
-
-class StructuredDataTest : public testing::Test {
-public:
-  static void SetUpTestCase() {
-    s_inputs_folder = llvm::sys::path::parent_path(TestMainArgv0);
-    llvm::sys::path::append(s_inputs_folder, "Inputs");
-  }
-
-protected:
-  static llvm::SmallString<128> s_inputs_folder;
-};
-} // namespace
-
-llvm::SmallString<128> StructuredDataTest::s_inputs_folder;
-
-TEST_F(StructuredDataTest, StringDump) {
+TEST(StructuredDataTest, StringDump) {
   std::pair<llvm::StringRef, llvm::StringRef> TestCases[] = {
       {R"(asdfg)", R"("asdfg")"},
       {R"(as"df)", R"("as\"df")"},
       {R"(as\df)", R"("as\\df")"},
   };
   for (auto P : TestCases) {
     StreamString S;
     const bool pretty_print = false;
     StructuredData::String(P.first).Dump(S, pretty_print);
     EXPECT_EQ(P.second, S.GetString());
   }
 }
 
-TEST_F(StructuredDataTest, ParseJSONFromFile) {
+TEST(StructuredDataTest, ParseJSONFromFile) {
   Status status;
   auto object_sp = StructuredData::ParseJSONFromFile(
       FileSpec("non-existing-file.json", false), status);
   EXPECT_EQ(nullptr, object_sp);
 
-  llvm::SmallString<128> input = s_inputs_folder;
-  llvm::sys::path::append(input, "StructuredData-basic.json");
+  std::string input = GetInputFile("StructuredData-basic.json");
   object_sp = StructuredData::ParseJSONFromFile(FileSpec(input, false), status);
   ASSERT_NE(nullptr, object_sp);
 
   StreamString S;
   object_sp->Dump(S, false);
   EXPECT_EQ("[1,2,3]", S.GetString());
 }

unittests/Utility/TildeExpressionResolverTest.cpp

 #include "gtest/gtest.h"
 
-#include "Mocks/MockTildeExpressionResolver.h"
+#include "Helpers/MockTildeExpressionResolver.h"
 #include "lldb/Utility/TildeExpressionResolver.h"
 
 #include "llvm/ADT/SmallString.h"
 
 using namespace llvm;
 using namespace lldb_private;
 
 TEST(TildeExpressionResolver, ResolveFullPath) {