Remove remaining platform specific code from FileSpec

[zturner]

Summary

This is the last step before I plan to move FileSpec to Utility, which should completely eliminate between 3 and 5 dependencies from other targets to Host.

[zturner]

Turns out ResolveUsername was only being called from one place outside of FileSpec and ResolvePartialUsername was dead code (since callers had already been updated to use TildeExpressionResolver. So I just deleted these two functions and replaced the calls to ResolveUsername with calls directly into TildeExpressionResolver.

[labath]

lldb/include/lldb/Utility/TildeExpressionResolver.h

61

I find it very strange to see the Mock object in a regular header file (and I also don't see a reason why we would need that). Could we get rid of this? (perhaps by declaring it in a test-only header file if necessary)

[zturner]

See what you think about this. I've created a folder called Mocks under Utility, and created a new target out of it. UtilityTests links against it, and so does InterpreterTests. To do this I had to add the lldb project root as an include directory, this way you can write #include "unittests/Utility/Mocks/MockTildeExpressionResolver.h". Another possibility would be to create lldb/unittests/Mocks/Mocks/Utility, and then add lldb/unittests/Mocks as an include folder. This way you could write #include "Mocks/Utility/MockTildeExpressionResolver.h". I don't have a strong preference either way.

I explicitly chose NOT to make one single target for all mocks (although there is only one right now obviously), because then you would have UtilityTests bringing in mocks from projects it doesn't depend on, and thus it would link against those projects as well, breaking the library layering.

[labath]

In D31129#705597, @zturner wrote:

See what you think about this. I've created a folder called Mocks under Utility, and created a new target out of it. UtilityTests links against it, and so does InterpreterTests. To do this I had to add the lldb project root as an include directory, this way you can write #include "unittests/Utility/Mocks/MockTildeExpressionResolver.h". Another possibility would be to create lldb/unittests/Mocks/Mocks/Utility, and then add lldb/unittests/Mocks as an include folder. This way you could write #include "Mocks/Utility/MockTildeExpressionResolver.h". I don't have a strong preference either way.

I explicitly chose NOT to make one single target for all mocks (although there is only one right now obviously), because then you would have UtilityTests bringing in mocks from projects it doesn't depend on, and thus it would link against those projects as well, breaking the library layering.

It's not exactly the pinnacle of elegance, but I think this is better (and I don't know how I would improve it). The only thing I am not sure about is the Mocks folder name. I am thinking that we may run into the situation where we have some other test-only code we want to share, but it is not strictly a "mock". The only function that comes to mind right now is the CreateConnectedSockets from SocketTest.cpp -- I could have to reused this in gdb-remote tests, although I eventually opted for reimplementing it, as I could make it a lot simpler for this special case. (Although in this case it may have made sense to add a function like that to the regular codebase). I don't really have a good suggestion for a name though, so maybe we can leave this until a real case for it comes up.

[eugene]

I like how much code you deleted.

lldb/include/lldb/Host/FileSpec.h

 
 // C Includes
 // C++ Includes
 #include <functional>
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 
 namespace lldb_private {
public:
 
   void AppendPathComponent(llvm::StringRef component);
   void AppendPathComponent(const FileSpec &new_path);
 
   void RemoveLastPathComponent();
 
   ConstString GetLastPathComponent() const;
 
-  //------------------------------------------------------------------
-  /// Resolves the user name at the beginning of \a src_path, and writes the
-  /// output
-  /// to \a dst_path.  Note, \a src_path can contain other path components after
-  /// the
-  /// user name, they will be copied over, and if the path doesn't start with
-  /// "~" it
-  /// will also be copied over to \a dst_path.
-  ///
-  /// @param[in] src_path
-  ///     Input path to be resolved.
-  ///
-  /// @param[in] dst_path
-  ///     Buffer to store the resolved path.
-  //------------------------------------------------------------------
-  static void ResolveUsername(llvm::SmallVectorImpl<char> &path);
-
-  static size_t ResolvePartialUsername(llvm::StringRef partial_name,
-                                       StringList &matches);
-
   enum EnumerateDirectoryResult {
     eEnumerateDirectoryResultNext,  // Enumerate next entry in the current
                                     // directory
     eEnumerateDirectoryResultEnter, // Recurse into the current entry if it is a
                                     // directory or symlink, or next if not
     eEnumerateDirectoryResultQuit   // Stop directory enumerations at any level
   };
 

lldb/include/lldb/Utility/TildeExpressionResolver.h

public:
   ///
   /// \param Output Contains all matching home directories, each one
   ///               itself unresolved (i.e. you need to call ResolveExact
   ///               on each item to turn it into a real path).
   ///
   /// \returns true if there were any matches, false otherwise.
   virtual bool ResolvePartial(llvm::StringRef Expr,
                               llvm::StringSet<> &Output) = 0;
+
+  /// \brief Resolve an entire path that begins with a tilde expression,
+  /// replacing the username portion with the matched result.
+  bool ResolveFullPath(llvm::StringRef Expr,
+                       llvm::SmallVectorImpl<char> &Output);
 };
 
 class StandardTildeExpressionResolver : public TildeExpressionResolver {
 public:
   bool ResolveExact(llvm::StringRef Expr,
                     llvm::SmallVectorImpl<char> &Output) override;
   bool ResolvePartial(llvm::StringRef Expr, llvm::StringSet<> &Output) override;
 };
 }
 
 #endif // #ifndef LLDB_UTILITY_TILDE_EXPRESSION_RESOLVER_H

lldb/source/API/SBDeclaration.cpp

-//===-- SBDeclaration.cpp -----------------------------------------*- C++
-//-*-===//
+//===-- SBDeclaration.cpp ----------------------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/Host/PosixApi.h"
 #include "lldb/Symbol/Declaration.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include <limits.h>
 
 using namespace lldb;
 using namespace lldb_private;

lldb/source/API/SBFileSpec.cpp

 //===-- SBFileSpec.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <inttypes.h> // PRIu64
 #include <limits.h>
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/SmallString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

lldb/source/API/SBFileSpecList.cpp

 //===-- SBFileSpecList.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <limits.h>
 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/PosixApi.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBFileSpecList::SBFileSpecList() : m_opaque_ap(new FileSpecList()) {}
 

lldb/source/API/SBLineEntry.cpp

 //===-- SBLineEntry.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <limits.h>
 
 #include "lldb/API/SBLineEntry.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/Host/PosixApi.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBLineEntry::SBLineEntry() : m_opaque_ap() {}

lldb/source/Host/common/FileSpec.cpp

 //===-- FileSpec.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include <fstream>
-#include <set>
-#include <string.h>
-
-#include "llvm/Config/llvm-config.h"
-#ifndef LLVM_ON_WIN32
-#include <pwd.h>
-#endif
-
-#include "lldb/Core/StringList.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/TildeExpressionResolver.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
 
size_t ParentPathEnd(llvm::StringRef path, FileSpec::PathSyntax syntax) {
   if (end_pos == 1 && root_dir_pos == 0 && filename_was_sep)
     return llvm::StringRef::npos;
 
   return end_pos;
 }
 
 } // end anonymous namespace
 
-// Resolves the username part of a path of the form ~user/other/directories, and
-// writes the result into dst_path.  This will also resolve "~" to the current
-// user.
-// If you want to complete "~" to the list of users, pass it to
-// ResolvePartialUsername.
-void FileSpec::ResolveUsername(llvm::SmallVectorImpl<char> &path) {
-#ifndef LLVM_ON_WIN32
-  if (path.empty() || path[0] != '~')
-    return;
-
-  llvm::StringRef path_str(path.data(), path.size());
-  size_t slash_pos = path_str.find('/', 1);
-  if (slash_pos == 1 || path.size() == 1) {
-    // A path of ~/ resolves to the current user's home dir
-    llvm::SmallString<64> home_dir;
-    // llvm::sys::path::home_directory() only checks if "HOME" is set in the
-    // environment and does nothing else to locate the user home directory
-    if (!llvm::sys::path::home_directory(home_dir)) {
-      struct passwd *pw = getpwuid(getuid());
-      if (pw && pw->pw_dir && pw->pw_dir[0]) {
-        // Update our environemnt so llvm::sys::path::home_directory() works
-        // next time
-        setenv("HOME", pw->pw_dir, 0);
-        home_dir.assign(llvm::StringRef(pw->pw_dir));
-      } else {
-        return;
-      }
-    }
-
-    // Overwrite the ~ with the first character of the homedir, and insert
-    // the rest.  This way we only trigger one move, whereas an insert
-    // followed by a delete (or vice versa) would trigger two.
-    path[0] = home_dir[0];
-    path.insert(path.begin() + 1, home_dir.begin() + 1, home_dir.end());
-    return;
-  }
-
-  auto username_begin = path.begin() + 1;
-  auto username_end = (slash_pos == llvm::StringRef::npos)
-                          ? path.end()
-                          : (path.begin() + slash_pos);
-  size_t replacement_length = std::distance(path.begin(), username_end);
-
-  llvm::SmallString<20> username(username_begin, username_end);
-  struct passwd *user_entry = ::getpwnam(username.c_str());
-  if (user_entry != nullptr) {
-    // Copy over the first n characters of the path, where n is the smaller of
-    // the length
-    // of the home directory and the slash pos.
-    llvm::StringRef homedir(user_entry->pw_dir);
-    size_t initial_copy_length = std::min(homedir.size(), replacement_length);
-    auto src_begin = homedir.begin();
-    auto src_end = src_begin + initial_copy_length;
-    std::copy(src_begin, src_end, path.begin());
-    if (replacement_length > homedir.size()) {
-      // We copied the entire home directory, but the ~username portion of the
-      // path was
-      // longer, so there's characters that need to be removed.
-      path.erase(path.begin() + initial_copy_length, username_end);
-    } else if (replacement_length < homedir.size()) {
-      // We copied all the way up to the slash in the destination, but there's
-      // still more
-      // characters that need to be inserted.
-      path.insert(username_end, src_end, homedir.end());
-    }
-  } else {
-    // Unable to resolve username (user doesn't exist?)
-    path.clear();
-  }
-#endif
-}
-
-size_t FileSpec::ResolvePartialUsername(llvm::StringRef partial_name,
-                                        StringList &matches) {
-#if !defined(LLVM_ON_WIN32) && !defined(__ANDROID__)
-  size_t extant_entries = matches.GetSize();
-
-  setpwent();
-  struct passwd *user_entry;
-  partial_name = partial_name.drop_front();
-  std::set<std::string> name_list;
-
-  while ((user_entry = getpwent()) != NULL) {
-    if (llvm::StringRef(user_entry->pw_name).startswith(partial_name)) {
-      std::string tmp_buf("~");
-      tmp_buf.append(user_entry->pw_name);
-      tmp_buf.push_back('/');
-      name_list.insert(tmp_buf);
-    }
-  }
-
-  for (auto &name : name_list) {
-    matches.AppendString(name);
-  }
-  return matches.GetSize() - extant_entries;
-#else
-  // Resolving home directories is not supported, just copy the path...
-  return 0;
-#endif // #ifdef LLVM_ON_WIN32
-}
-
 void FileSpec::Resolve(llvm::SmallVectorImpl<char> &path) {
   if (path.empty())
     return;
 
-#ifndef LLVM_ON_WIN32
-  if (path[0] == '~')
-    ResolveUsername(path);
-#endif // #ifdef LLVM_ON_WIN32
+  llvm::SmallString<32> Source(path.begin(), path.end());
+  StandardTildeExpressionResolver Resolver;
+  Resolver.ResolveFullPath(Source, path);
 
   // Save a copy of the original path that's passed in
   llvm::SmallString<128> original_path(path.begin(), path.end());
 
   llvm::sys::fs::make_absolute(path);
   if (!llvm::sys::fs::exists(path)) {
     path.clear();
     path.append(original_path.begin(), original_path.end());

lldb/source/Host/windows/FileSystem.cpp

 #include "lldb/Host/windows/windows.h"
 
 #include <shellapi.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/windows/AutoHandle.h"
+#include "lldb/Host/windows/PosixApi.h"
 
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb_private;
 
 const char *FileSystem::DEV_NULL = "nul";
 

lldb/source/Host/windows/HostInfoWindows.cpp

 //===-- HostInfoWindows.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/windows/windows.h"
 
 #include <objbase.h>
 
 #include <mutex> // std::once
 
 #include "lldb/Host/windows/HostInfoWindows.h"
+#include "lldb/Host/windows/PosixApi.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace lldb_private;

lldb/source/Target/TargetList.cpp

 #include "lldb/Core/Timer.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Utility/TildeExpressionResolver.h"
 
 // Other libraries and framework includes
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
if (!platform_sp)
     platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
 
   if (!arch.IsValid())
     arch = specified_arch;
 
   FileSpec file(user_exe_path, false);
   if (!file.Exists() && user_exe_path.startswith("~")) {
     // we want to expand the tilde but we don't want to resolve any symbolic
-    // links
-    // so we can't use the FileSpec constructor's resolve flag
-    llvm::SmallString<64> unglobbed_path(user_exe_path);
-    FileSpec::ResolveUsername(unglobbed_path);
+    // links so we can't use the FileSpec constructor's resolve flag
+    llvm::SmallString<64> unglobbed_path;
+    StandardTildeExpressionResolver Resolver;
+    Resolver.ResolveFullPath(user_exe_path, unglobbed_path);
 
     if (unglobbed_path.empty())
       file = FileSpec(user_exe_path, false);
     else
       file = FileSpec(unglobbed_path.c_str(), false);
   }
 
   bool user_exe_path_is_bundle = false;

lldb/source/Utility/TildeExpressionResolver.cpp

while ((user_entry = getpwent()) != NULL) {
     Buffer.append(ThisName);
     Buffer.append(path::get_separator());
     Output.insert(Buffer);
   }
 
   return true;
 #endif
 }
+
+bool TildeExpressionResolver::ResolveFullPath(
+    StringRef Expr, llvm::SmallVectorImpl<char> &Output) {
+  Output.clear();
+  if (!Expr.startswith("~")) {
+    Output.append(Expr.begin(), Expr.end());
+    return false;
+  }
+
+  namespace path = llvm::sys::path;
+  StringRef Left =
+      Expr.take_until([](char c) { return path::is_separator(c); });
+
+  if (!ResolveExact(Left, Output))
+    return false;
+
+  Output.append(Expr.begin() + Left.size(), Expr.end());
+  return true;
+}

lldb/unittests/CMakeLists.txt

 add_custom_target(LLDBUnitTests)
 set_target_properties(LLDBUnitTests PROPERTIES FOLDER "LLDB tests")
 
 include_directories(${LLDB_SOURCE_ROOT})
+include_directories(${LLDB_PROJECT_ROOT})
 
 set(LLDB_GTEST_COMMON_INCLUDE ${CMAKE_CURRENT_SOURCE_DIR}/gtest_common.h)
 if (MSVC)
   list(APPEND LLVM_COMPILE_FLAGS /FI ${LLDB_GTEST_COMMON_INCLUDE})
 else ()
   list(APPEND LLVM_COMPILE_FLAGS -include ${LLDB_GTEST_COMMON_INCLUDE})
 endif ()
 

lldb/unittests/Interpreter/CMakeLists.txt

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

lldb/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/Core/StringList.h"
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Utility/TildeExpressionResolver.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;                                           \
     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 {
 
-class MockTildeExpressionResolver : public TildeExpressionResolver {
-  StringRef CurrentUser;
-  StringMap<StringRef> UserDirectories;
-
-public:
-  explicit MockTildeExpressionResolver(StringRef CurrentUser, StringRef HomeDir)
-      : CurrentUser(CurrentUser) {
-    UserDirectories.insert(std::make_pair(CurrentUser, HomeDir));
-  }
-
-  void AddKnownUser(StringRef User, StringRef HomeDir) {
-    assert(UserDirectories.find(User) == UserDirectories.end());
-    UserDirectories.insert(std::make_pair(User, HomeDir));
-  }
-
-  void Clear() {
-    CurrentUser = StringRef();
-    UserDirectories.clear();
-  }
-
-  void SetCurrentUser(StringRef User) {
-    assert(UserDirectories.find(User) != UserDirectories.end());
-    CurrentUser = User;
-  }
-
-  bool ResolveExact(StringRef Expr, SmallVectorImpl<char> &Output) override {
-    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 ResolvePartial(StringRef Expr, StringSet<> &Output) override {
-    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();
-  }
-};
-
 class CompletionTest : public testing::Test {
 protected:
   /// Unique temporary directory in which all created filesystem entities must
   /// be placed. It is removed at the end of the test suite.
   static SmallString<128> BaseDir;
 
   static SmallString<128> DirFoo;
   static SmallString<128> DirFooA;

lldb/unittests/Utility/CMakeLists.txt

+add_subdirectory(Mocks)
+
 add_lldb_unittest(UtilityTests
   ConstStringTest.cpp
   ErrorTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
   StringExtractorTest.cpp
   TaskPoolTest.cpp
+  TildeExpressionResolverTest.cpp
   TimeoutTest.cpp
   UriParserTest.cpp
   VASprintfTest.cpp
 
   LINK_LIBS
       lldbUtility
+      lldbUtilityMocks
   LINK_COMPONENTS
     Support
   )

lldb/unittests/Utility/Mocks/CMakeLists.txt

+add_lldb_library(lldbUtilityMocks
+  MockTildeExpressionResolver.cpp
+
+  LINK_LIBS
+    lldbUtility
+
+  LINK_COMPONENTS
+    Support
+  )

lldb/unittests/Utility/Mocks/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

lldb/unittests/Utility/Mocks/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();
+}

lldb/unittests/Utility/TildeExpressionResolverTest.cpp

+#include "gtest/gtest.h"
+
+#include "Mocks/MockTildeExpressionResolver.h"
+#include "lldb/Utility/TildeExpressionResolver.h"
+
+#include "llvm/ADT/SmallString.h"
+
+using namespace llvm;
+using namespace lldb_private;
+
+TEST(TildeExpressionResolver, ResolveFullPath) {
+  MockTildeExpressionResolver Resolver("James", "/james");
+  Resolver.AddKnownUser("Kirk", "/kirk");
+  Resolver.AddKnownUser("Lars", "/lars");
+  Resolver.AddKnownUser("Jason", "/jason");
+  Resolver.AddKnownUser("Larry", "/larry");
+
+  SmallString<32> Result;
+  ASSERT_TRUE(Resolver.ResolveFullPath("~", Result));
+  EXPECT_EQ("/james", Result);
+  ASSERT_TRUE(Resolver.ResolveFullPath("~/", Result));
+  EXPECT_EQ("/james/", Result);
+
+  ASSERT_TRUE(Resolver.ResolveFullPath("~James/bar/baz", Result));
+  EXPECT_EQ("/james/bar/baz", Result);
+
+  ASSERT_TRUE(Resolver.ResolveFullPath("~Jason/", Result));
+  EXPECT_EQ("/jason/", Result);
+
+  ASSERT_TRUE(Resolver.ResolveFullPath("~Lars", Result));
+  EXPECT_EQ("/lars", Result);
+
+  ASSERT_FALSE(Resolver.ResolveFullPath("~Jaso", Result));
+  ASSERT_FALSE(Resolver.ResolveFullPath("", Result));
+  ASSERT_FALSE(Resolver.ResolveFullPath("Jason", Result));
+}