Run DCE after a LoopFlatten test to reduce spurious output [nfc]

[llvm-project.git] / llvm / unittests / Support / Path.cpp

//===- llvm/unittest/Support/Path.cpp - Path tests ------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "llvm/Support/Path.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/BinaryFormat/Magic.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ConvertUTF.h"
#include "llvm/Support/Duration.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/FileUtilities.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TargetParser/Host.h"
#include "llvm/TargetParser/Triple.h"
#include "llvm/Testing/Support/Error.h"
#include "llvm/Testing/Support/SupportHelpers.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

#ifdef _WIN32
#include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/Chrono.h"
#include "llvm/Support/Windows/WindowsSupport.h"
#include <windows.h>
#include <winerror.h>
#endif

#ifdef LLVM_ON_UNIX
#include <pwd.h>
#include <sys/stat.h>
#endif

using namespace llvm;
using namespace llvm::sys;

#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 {                                                                     \
  }

#define ASSERT_ERROR(x)                                                        \
  if (!x) {                                                                    \
    SmallString<128> MessageStorage;                                           \
    raw_svector_ostream Message(MessageStorage);                               \
    Message << #x ": did not return a failure error code.\n";                  \
    GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
  }

namespace {

void checkSeparators(StringRef Path) {
#ifdef _WIN32
  char UndesiredSeparator = sys::path::get_separator()[0] == '/' ? '\\' : '/';
  ASSERT_EQ(Path.find(UndesiredSeparator), StringRef::npos);
#endif
}

struct FileDescriptorCloser {
  explicit FileDescriptorCloser(int FD) : FD(FD) {}
  ~FileDescriptorCloser() { ::close(FD); }
  int FD;
};

TEST(is_style_Style, Works) {
  using namespace llvm::sys::path;
  // Check platform-independent results.
  EXPECT_TRUE(is_style_posix(Style::posix));
  EXPECT_TRUE(is_style_windows(Style::windows));
  EXPECT_TRUE(is_style_windows(Style::windows_slash));
  EXPECT_FALSE(is_style_posix(Style::windows));
  EXPECT_FALSE(is_style_posix(Style::windows_slash));
  EXPECT_FALSE(is_style_windows(Style::posix));

  // Check platform-dependent results.
#if defined(_WIN32)
  EXPECT_FALSE(is_style_posix(Style::native));
  EXPECT_TRUE(is_style_windows(Style::native));
#else
  EXPECT_TRUE(is_style_posix(Style::native));
  EXPECT_FALSE(is_style_windows(Style::native));
#endif
}

TEST(is_separator, Works) {
  EXPECT_TRUE(path::is_separator('/'));
  EXPECT_FALSE(path::is_separator('\0'));
  EXPECT_FALSE(path::is_separator('-'));
  EXPECT_FALSE(path::is_separator(' '));

  EXPECT_TRUE(path::is_separator('\\', path::Style::windows));
  EXPECT_TRUE(path::is_separator('\\', path::Style::windows_slash));
  EXPECT_FALSE(path::is_separator('\\', path::Style::posix));

  EXPECT_EQ(path::is_style_windows(path::Style::native),
            path::is_separator('\\'));
}

TEST(get_separator, Works) {
  EXPECT_EQ(path::get_separator(path::Style::posix), "/");
  EXPECT_EQ(path::get_separator(path::Style::windows_backslash), "\\");
  EXPECT_EQ(path::get_separator(path::Style::windows_slash), "/");
}

TEST(is_absolute_gnu, Works) {
  // Test tuple <Path, ExpectedPosixValue, ExpectedWindowsValue>.
  const std::tuple<StringRef, bool, bool> Paths[] = {
      std::make_tuple("", false, false),
      std::make_tuple("/", true, true),
      std::make_tuple("/foo", true, true),
      std::make_tuple("\\", false, true),
      std::make_tuple("\\foo", false, true),
      std::make_tuple("foo", false, false),
      std::make_tuple("c", false, false),
      std::make_tuple("c:", false, true),
      std::make_tuple("c:\\", false, true),
      std::make_tuple("!:", false, true),
      std::make_tuple("xx:", false, false),
      std::make_tuple("c:abc\\", false, true),
      std::make_tuple(":", false, false)};

  for (const auto &Path : Paths) {
    EXPECT_EQ(path::is_absolute_gnu(std::get<0>(Path), path::Style::posix),
              std::get<1>(Path));
    EXPECT_EQ(path::is_absolute_gnu(std::get<0>(Path), path::Style::windows),
              std::get<2>(Path));

    constexpr int Native = is_style_posix(path::Style::native) ? 1 : 2;
    EXPECT_EQ(path::is_absolute_gnu(std::get<0>(Path), path::Style::native),
              std::get<Native>(Path));
  }
}

TEST(Support, Path) {
  SmallVector<StringRef, 40> paths;
  paths.push_back("");
  paths.push_back(".");
  paths.push_back("..");
  paths.push_back("foo");
  paths.push_back("/");
  paths.push_back("/foo");
  paths.push_back("foo/");
  paths.push_back("/foo/");
  paths.push_back("foo/bar");
  paths.push_back("/foo/bar");
  paths.push_back("//net");
  paths.push_back("//net/");
  paths.push_back("//net/foo");
  paths.push_back("///foo///");
  paths.push_back("///foo///bar");
  paths.push_back("/.");
  paths.push_back("./");
  paths.push_back("/..");
  paths.push_back("../");
  paths.push_back("foo/.");
  paths.push_back("foo/..");
  paths.push_back("foo/./");
  paths.push_back("foo/./bar");
  paths.push_back("foo/..");
  paths.push_back("foo/../");
  paths.push_back("foo/../bar");
  paths.push_back("c:");
  paths.push_back("c:/");
  paths.push_back("c:foo");
  paths.push_back("c:/foo");
  paths.push_back("c:foo/");
  paths.push_back("c:/foo/");
  paths.push_back("c:/foo/bar");
  paths.push_back("prn:");
  paths.push_back("c:\\");
  paths.push_back("c:foo");
  paths.push_back("c:\\foo");
  paths.push_back("c:foo\\");
  paths.push_back("c:\\foo\\");
  paths.push_back("c:\\foo/");
  paths.push_back("c:/foo\\bar");

  for (SmallVector<StringRef, 40>::const_iterator i = paths.begin(),
                                                  e = paths.end();
                                                  i != e;
                                                  ++i) {
    SCOPED_TRACE(*i);
    SmallVector<StringRef, 5> ComponentStack;
    for (sys::path::const_iterator ci = sys::path::begin(*i),
                                   ce = sys::path::end(*i);
                                   ci != ce;
                                   ++ci) {
      EXPECT_FALSE(ci->empty());
      ComponentStack.push_back(*ci);
    }

    SmallVector<StringRef, 5> ReverseComponentStack;
    for (sys::path::reverse_iterator ci = sys::path::rbegin(*i),
                                     ce = sys::path::rend(*i);
                                     ci != ce;
                                     ++ci) {
      EXPECT_FALSE(ci->empty());
      ReverseComponentStack.push_back(*ci);
    }
    std::reverse(ReverseComponentStack.begin(), ReverseComponentStack.end());
    EXPECT_THAT(ComponentStack, testing::ContainerEq(ReverseComponentStack));

    // Crash test most of the API - since we're iterating over all of our paths
    // here there isn't really anything reasonable to assert on in the results.
    (void)path::has_root_path(*i);
    (void)path::root_path(*i);
    (void)path::has_root_name(*i);
    (void)path::root_name(*i);
    (void)path::has_root_directory(*i);
    (void)path::root_directory(*i);
    (void)path::has_parent_path(*i);
    (void)path::parent_path(*i);
    (void)path::has_filename(*i);
    (void)path::filename(*i);
    (void)path::has_stem(*i);
    (void)path::stem(*i);
    (void)path::has_extension(*i);
    (void)path::extension(*i);
    (void)path::is_absolute(*i);
    (void)path::is_absolute_gnu(*i);
    (void)path::is_relative(*i);

    SmallString<128> temp_store;
    temp_store = *i;
    ASSERT_NO_ERROR(fs::make_absolute(temp_store));
    temp_store = *i;
    path::remove_filename(temp_store);

    temp_store = *i;
    path::replace_extension(temp_store, "ext");
    StringRef filename(temp_store.begin(), temp_store.size()), stem, ext;
    stem = path::stem(filename);
    ext  = path::extension(filename);
    EXPECT_EQ(*sys::path::rbegin(filename), (stem + ext).str());

    path::native(*i, temp_store);
  }

  {
    SmallString<32> Relative("foo.cpp");
    sys::fs::make_absolute("/root", Relative);
    Relative[5] = '/'; // Fix up windows paths.
    ASSERT_EQ("/root/foo.cpp", Relative);
  }

  {
    SmallString<32> Relative("foo.cpp");
    sys::fs::make_absolute("//root", Relative);
    Relative[6] = '/'; // Fix up windows paths.
    ASSERT_EQ("//root/foo.cpp", Relative);
  }
}

TEST(Support, PathRoot) {
  ASSERT_EQ(path::root_name("//net/hello", path::Style::posix).str(), "//net");
  ASSERT_EQ(path::root_name("c:/hello", path::Style::posix).str(), "");
  ASSERT_EQ(path::root_name("c:/hello", path::Style::windows).str(), "c:");
  ASSERT_EQ(path::root_name("/hello", path::Style::posix).str(), "");

  ASSERT_EQ(path::root_directory("/goo/hello", path::Style::posix).str(), "/");
  ASSERT_EQ(path::root_directory("c:/hello", path::Style::windows).str(), "/");
  ASSERT_EQ(path::root_directory("d/file.txt", path::Style::posix).str(), "");
  ASSERT_EQ(path::root_directory("d/file.txt", path::Style::windows).str(), "");

  SmallVector<StringRef, 40> paths;
  paths.push_back("");
  paths.push_back(".");
  paths.push_back("..");
  paths.push_back("foo");
  paths.push_back("/");
  paths.push_back("/foo");
  paths.push_back("foo/");
  paths.push_back("/foo/");
  paths.push_back("foo/bar");
  paths.push_back("/foo/bar");
  paths.push_back("//net");
  paths.push_back("//net/");
  paths.push_back("//net/foo");
  paths.push_back("///foo///");
  paths.push_back("///foo///bar");
  paths.push_back("/.");
  paths.push_back("./");
  paths.push_back("/..");
  paths.push_back("../");
  paths.push_back("foo/.");
  paths.push_back("foo/..");
  paths.push_back("foo/./");
  paths.push_back("foo/./bar");
  paths.push_back("foo/..");
  paths.push_back("foo/../");
  paths.push_back("foo/../bar");
  paths.push_back("c:");
  paths.push_back("c:/");
  paths.push_back("c:foo");
  paths.push_back("c:/foo");
  paths.push_back("c:foo/");
  paths.push_back("c:/foo/");
  paths.push_back("c:/foo/bar");
  paths.push_back("prn:");
  paths.push_back("c:\\");
  paths.push_back("c:foo");
  paths.push_back("c:\\foo");
  paths.push_back("c:foo\\");
  paths.push_back("c:\\foo\\");
  paths.push_back("c:\\foo/");
  paths.push_back("c:/foo\\bar");

  for (StringRef p : paths) {
    ASSERT_EQ(
      path::root_name(p, path::Style::posix).str() + path::root_directory(p, path::Style::posix).str(),
      path::root_path(p, path::Style::posix).str());

    ASSERT_EQ(
      path::root_name(p, path::Style::windows).str() + path::root_directory(p, path::Style::windows).str(),
      path::root_path(p, path::Style::windows).str());
  }
}

TEST(Support, FilenameParent) {
  EXPECT_EQ("/", path::filename("/"));
  EXPECT_EQ("", path::parent_path("/"));

  EXPECT_EQ("\\", path::filename("c:\\", path::Style::windows));
  EXPECT_EQ("c:", path::parent_path("c:\\", path::Style::windows));

  EXPECT_EQ("/", path::filename("///"));
  EXPECT_EQ("", path::parent_path("///"));

  EXPECT_EQ("\\", path::filename("c:\\\\", path::Style::windows));
  EXPECT_EQ("c:", path::parent_path("c:\\\\", path::Style::windows));

  EXPECT_EQ("bar", path::filename("/foo/bar"));
  EXPECT_EQ("/foo", path::parent_path("/foo/bar"));

  EXPECT_EQ("foo", path::filename("/foo"));
  EXPECT_EQ("/", path::parent_path("/foo"));

  EXPECT_EQ("foo", path::filename("foo"));
  EXPECT_EQ("", path::parent_path("foo"));

  EXPECT_EQ(".", path::filename("foo/"));
  EXPECT_EQ("foo", path::parent_path("foo/"));

  EXPECT_EQ("//net", path::filename("//net"));
  EXPECT_EQ("", path::parent_path("//net"));

  EXPECT_EQ("/", path::filename("//net/"));
  EXPECT_EQ("//net", path::parent_path("//net/"));

  EXPECT_EQ("foo", path::filename("//net/foo"));
  EXPECT_EQ("//net/", path::parent_path("//net/foo"));

  // These checks are just to make sure we do something reasonable with the
  // paths below. They are not meant to prescribe the one true interpretation of
  // these paths. Other decompositions (e.g. "//" -> "" + "//") are also
  // possible.
  EXPECT_EQ("/", path::filename("//"));
  EXPECT_EQ("", path::parent_path("//"));

  EXPECT_EQ("\\", path::filename("\\\\", path::Style::windows));
  EXPECT_EQ("", path::parent_path("\\\\", path::Style::windows));

  EXPECT_EQ("\\", path::filename("\\\\\\", path::Style::windows));
  EXPECT_EQ("", path::parent_path("\\\\\\", path::Style::windows));
}

static std::vector<StringRef>
GetComponents(StringRef Path, path::Style S = path::Style::native) {
  return {path::begin(Path, S), path::end(Path)};
}

TEST(Support, PathIterator) {
  EXPECT_THAT(GetComponents("/foo"), testing::ElementsAre("/", "foo"));
  EXPECT_THAT(GetComponents("/"), testing::ElementsAre("/"));
  EXPECT_THAT(GetComponents("//"), testing::ElementsAre("/"));
  EXPECT_THAT(GetComponents("///"), testing::ElementsAre("/"));
  EXPECT_THAT(GetComponents("c/d/e/foo.txt"),
              testing::ElementsAre("c", "d", "e", "foo.txt"));
  EXPECT_THAT(GetComponents(".c/.d/../."),
              testing::ElementsAre(".c", ".d", "..", "."));
  EXPECT_THAT(GetComponents("/c/d/e/foo.txt"),
              testing::ElementsAre("/", "c", "d", "e", "foo.txt"));
  EXPECT_THAT(GetComponents("/.c/.d/../."),
              testing::ElementsAre("/", ".c", ".d", "..", "."));
  EXPECT_THAT(GetComponents("c:\\c\\e\\foo.txt", path::Style::windows),
              testing::ElementsAre("c:", "\\", "c", "e", "foo.txt"));
  EXPECT_THAT(GetComponents("c:\\c\\e\\foo.txt", path::Style::windows_slash),
              testing::ElementsAre("c:", "\\", "c", "e", "foo.txt"));
  EXPECT_THAT(GetComponents("//net/"), testing::ElementsAre("//net", "/"));
  EXPECT_THAT(GetComponents("//net/c/foo.txt"),
              testing::ElementsAre("//net", "/", "c", "foo.txt"));
}

TEST(Support, AbsolutePathIteratorEnd) {
  // Trailing slashes are converted to '.' unless they are part of the root path.
  SmallVector<std::pair<StringRef, path::Style>, 4> Paths;
  Paths.emplace_back("/foo/", path::Style::native);
  Paths.emplace_back("/foo//", path::Style::native);
  Paths.emplace_back("//net/foo/", path::Style::native);
  Paths.emplace_back("c:\\foo\\", path::Style::windows);

  for (auto &Path : Paths) {
    SCOPED_TRACE(Path.first);
    StringRef LastComponent = *path::rbegin(Path.first, Path.second);
    EXPECT_EQ(".", LastComponent);
  }

  SmallVector<std::pair<StringRef, path::Style>, 3> RootPaths;
  RootPaths.emplace_back("/", path::Style::native);
  RootPaths.emplace_back("//net/", path::Style::native);
  RootPaths.emplace_back("c:\\", path::Style::windows);
  RootPaths.emplace_back("//net//", path::Style::native);
  RootPaths.emplace_back("c:\\\\", path::Style::windows);

  for (auto &Path : RootPaths) {
    SCOPED_TRACE(Path.first);
    StringRef LastComponent = *path::rbegin(Path.first, Path.second);
    EXPECT_EQ(1u, LastComponent.size());
    EXPECT_TRUE(path::is_separator(LastComponent[0], Path.second));
  }
}

#ifdef _WIN32
std::string getEnvWin(const wchar_t *Var) {
  std::string expected;
  if (wchar_t const *path = ::_wgetenv(Var)) {
    auto pathLen = ::wcslen(path);
    ArrayRef<char> ref{reinterpret_cast<char const *>(path),
                       pathLen * sizeof(wchar_t)};
    convertUTF16ToUTF8String(ref, expected);
    SmallString<32> Buf(expected);
    path::make_preferred(Buf);
    expected.assign(Buf.begin(), Buf.end());
  }
  return expected;
}
#else
// RAII helper to set and restore an environment variable.
class WithEnv {
  const char *Var;
  std::optional<std::string> OriginalValue;

public:
  WithEnv(const char *Var, const char *Value) : Var(Var) {
    if (const char *V = ::getenv(Var))
      OriginalValue.emplace(V);
    if (Value)
      ::setenv(Var, Value, 1);
    else
      ::unsetenv(Var);
  }
  ~WithEnv() {
    if (OriginalValue)
      ::setenv(Var, OriginalValue->c_str(), 1);
    else
      ::unsetenv(Var);
  }
};
#endif

TEST(Support, HomeDirectory) {
  std::string expected;
#ifdef _WIN32
  expected = getEnvWin(L"USERPROFILE");
#else
  if (char const *path = ::getenv("HOME"))
    expected = path;
#endif
  // Do not try to test it if we don't know what to expect.
  // On Windows we use something better than env vars.
  if (expected.empty())
    GTEST_SKIP();
  SmallString<128> HomeDir;
  auto status = path::home_directory(HomeDir);
  EXPECT_TRUE(status);
  EXPECT_EQ(expected, HomeDir);
}

// Apple has their own solution for this.
#if defined(LLVM_ON_UNIX) && !defined(__APPLE__)
TEST(Support, HomeDirectoryWithNoEnv) {
  WithEnv Env("HOME", nullptr);

  // Don't run the test if we have nothing to compare against.
  struct passwd *pw = getpwuid(getuid());
  if (!pw || !pw->pw_dir)
    GTEST_SKIP();
  std::string PwDir = pw->pw_dir;

  SmallString<128> HomeDir;
  EXPECT_TRUE(path::home_directory(HomeDir));
  EXPECT_EQ(PwDir, HomeDir);
}

TEST(Support, ConfigDirectoryWithEnv) {
  WithEnv Env("XDG_CONFIG_HOME", "/xdg/config");

  SmallString<128> ConfigDir;
  EXPECT_TRUE(path::user_config_directory(ConfigDir));
  EXPECT_EQ("/xdg/config", ConfigDir);
}

TEST(Support, ConfigDirectoryNoEnv) {
  WithEnv Env("XDG_CONFIG_HOME", nullptr);

  SmallString<128> Fallback;
  ASSERT_TRUE(path::home_directory(Fallback));
  path::append(Fallback, ".config");

  SmallString<128> CacheDir;
  EXPECT_TRUE(path::user_config_directory(CacheDir));
  EXPECT_EQ(Fallback, CacheDir);
}

TEST(Support, CacheDirectoryWithEnv) {
  WithEnv Env("XDG_CACHE_HOME", "/xdg/cache");

  SmallString<128> CacheDir;
  EXPECT_TRUE(path::cache_directory(CacheDir));
  EXPECT_EQ("/xdg/cache", CacheDir);
}

TEST(Support, CacheDirectoryNoEnv) {
  WithEnv Env("XDG_CACHE_HOME", nullptr);

  SmallString<128> Fallback;
  ASSERT_TRUE(path::home_directory(Fallback));
  path::append(Fallback, ".cache");

  SmallString<128> CacheDir;
  EXPECT_TRUE(path::cache_directory(CacheDir));
  EXPECT_EQ(Fallback, CacheDir);
}
#endif

#ifdef __APPLE__
TEST(Support, ConfigDirectory) {
  SmallString<128> Fallback;
  ASSERT_TRUE(path::home_directory(Fallback));
  path::append(Fallback, "Library/Preferences");

  SmallString<128> ConfigDir;
  EXPECT_TRUE(path::user_config_directory(ConfigDir));
  EXPECT_EQ(Fallback, ConfigDir);
}
#endif

#ifdef _WIN32
TEST(Support, ConfigDirectory) {
  std::string Expected = getEnvWin(L"LOCALAPPDATA");
  // Do not try to test it if we don't know what to expect.
  if (Expected.empty())
    GTEST_SKIP();
  SmallString<128> CacheDir;
  EXPECT_TRUE(path::user_config_directory(CacheDir));
  EXPECT_EQ(Expected, CacheDir);
}

TEST(Support, CacheDirectory) {
  std::string Expected = getEnvWin(L"LOCALAPPDATA");
  // Do not try to test it if we don't know what to expect.
  if (Expected.empty())
    GTEST_SKIP();
  SmallString<128> CacheDir;
  EXPECT_TRUE(path::cache_directory(CacheDir));
  EXPECT_EQ(Expected, CacheDir);
}
#endif

TEST(Support, TempDirectory) {
  SmallString<32> TempDir;
  path::system_temp_directory(false, TempDir);
  EXPECT_TRUE(!TempDir.empty());
  TempDir.clear();
  path::system_temp_directory(true, TempDir);
  EXPECT_TRUE(!TempDir.empty());
}

#ifdef _WIN32
static std::string path2regex(std::string Path) {
  size_t Pos = 0;
  bool Forward = path::get_separator()[0] == '/';
  while ((Pos = Path.find('\\', Pos)) != std::string::npos) {
    if (Forward) {
      Path.replace(Pos, 1, "/");
      Pos += 1;
    } else {
      Path.replace(Pos, 1, "\\\\");
      Pos += 2;
    }
  }
  return Path;
}

/// Helper for running temp dir test in separated process. See below.
#define EXPECT_TEMP_DIR(prepare, expected)                                     \
  EXPECT_EXIT(                                                                 \
      {                                                                        \
        prepare;                                                               \
        SmallString<300> TempDir;                                              \
        path::system_temp_directory(true, TempDir);                            \
        raw_os_ostream(std::cerr) << TempDir;                                  \
        std::exit(0);                                                          \
      },                                                                       \
      ::testing::ExitedWithCode(0), path2regex(expected))

TEST(SupportDeathTest, TempDirectoryOnWindows) {
  // In this test we want to check how system_temp_directory responds to
  // different values of specific env vars. To prevent corrupting env vars of
  // the current process all checks are done in separated processes.
  EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"C:\\OtherFolder"), "C:\\OtherFolder");
  EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"C:/Unix/Path/Seperators"),
                  "C:\\Unix\\Path\\Seperators");
  EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"Local Path"), ".+\\Local Path$");
  EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"F:\\TrailingSep\\"), "F:\\TrailingSep");
  EXPECT_TEMP_DIR(
      _wputenv_s(L"TMP", L"C:\\2\x03C0r-\x00B5\x00B3\\\x2135\x2080"),
      "C:\\2\xCF\x80r-\xC2\xB5\xC2\xB3\\\xE2\x84\xB5\xE2\x82\x80");

  // Test $TMP empty, $TEMP set.
  EXPECT_TEMP_DIR(
      {
        _wputenv_s(L"TMP", L"");
        _wputenv_s(L"TEMP", L"C:\\Valid\\Path");
      },
      "C:\\Valid\\Path");

  // All related env vars empty
  EXPECT_TEMP_DIR(
  {
    _wputenv_s(L"TMP", L"");
    _wputenv_s(L"TEMP", L"");
    _wputenv_s(L"USERPROFILE", L"");
  },
    "C:\\Temp");

  // Test evn var / path with 260 chars.
  SmallString<270> Expected{"C:\\Temp\\AB\\123456789"};
  while (Expected.size() < 260)
    Expected.append("\\DirNameWith19Charss");
  ASSERT_EQ(260U, Expected.size());
  EXPECT_TEMP_DIR(_putenv_s("TMP", Expected.c_str()), Expected.c_str());
}
#endif

class FileSystemTest : public testing::Test {
protected:
  /// Unique temporary directory in which all created filesystem entities must
  /// be placed. It is removed at the end of each test (must be empty).
  SmallString<128> TestDirectory;
  SmallString<128> NonExistantFile;

  void SetUp() override {
    ASSERT_NO_ERROR(
        fs::createUniqueDirectory("file-system-test", TestDirectory));
    // We don't care about this specific file.
    errs() << "Test Directory: " << TestDirectory << '\n';
    errs().flush();
    NonExistantFile = TestDirectory;

    // Even though this value is hardcoded, is a 128-bit GUID, so we should be
    // guaranteed that this file will never exist.
    sys::path::append(NonExistantFile, "1B28B495C16344CB9822E588CD4C3EF0");
  }

  void TearDown() override { ASSERT_NO_ERROR(fs::remove(TestDirectory.str())); }
};

TEST_F(FileSystemTest, Unique) {
  // Create a temp file.
  int FileDescriptor;
  SmallString<64> TempPath;
  ASSERT_NO_ERROR(
      fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));

  // The same file should return an identical unique id.
  fs::UniqueID F1, F2;
  ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), F1));
  ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), F2));
  ASSERT_EQ(F1, F2);

  // Different files should return different unique ids.
  int FileDescriptor2;
  SmallString<64> TempPath2;
  ASSERT_NO_ERROR(
      fs::createTemporaryFile("prefix", "temp", FileDescriptor2, TempPath2));

  fs::UniqueID D;
  ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath2), D));
  ASSERT_NE(D, F1);
  ::close(FileDescriptor2);

  ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));

#ifndef _WIN32
  // Two paths representing the same file on disk should still provide the
  // same unique id.  We can test this by making a hard link.
  // FIXME: Our implementation of getUniqueID on Windows doesn't consider hard
  // links to be the same file.
  ASSERT_NO_ERROR(fs::create_link(Twine(TempPath), Twine(TempPath2)));
  fs::UniqueID D2;
  ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath2), D2));
  ASSERT_EQ(D2, F1);
#endif

  ::close(FileDescriptor);

  SmallString<128> Dir1;
  ASSERT_NO_ERROR(
     fs::createUniqueDirectory("dir1", Dir1));
  ASSERT_NO_ERROR(fs::getUniqueID(Dir1.c_str(), F1));
  ASSERT_NO_ERROR(fs::getUniqueID(Dir1.c_str(), F2));
  ASSERT_EQ(F1, F2);

  SmallString<128> Dir2;
  ASSERT_NO_ERROR(
     fs::createUniqueDirectory("dir2", Dir2));
  ASSERT_NO_ERROR(fs::getUniqueID(Dir2.c_str(), F2));
  ASSERT_NE(F1, F2);
  ASSERT_NO_ERROR(fs::remove(Dir1));
  ASSERT_NO_ERROR(fs::remove(Dir2));
  ASSERT_NO_ERROR(fs::remove(TempPath2));
  ASSERT_NO_ERROR(fs::remove(TempPath));
}

TEST_F(FileSystemTest, RealPath) {
  ASSERT_NO_ERROR(
      fs::create_directories(Twine(TestDirectory) + "/test1/test2/test3"));
  ASSERT_TRUE(fs::exists(Twine(TestDirectory) + "/test1/test2/test3"));

  SmallString<64> RealBase;
  SmallString<64> Expected;
  SmallString<64> Actual;

  // TestDirectory itself might be under a symlink or have been specified with
  // a different case than the existing temp directory.  In such cases real_path
  // on the concatenated path will differ in the TestDirectory portion from
  // how we specified it.  Make sure to compare against the real_path of the
  // TestDirectory, and not just the value of TestDirectory.
  ASSERT_NO_ERROR(fs::real_path(TestDirectory, RealBase));
  checkSeparators(RealBase);
  path::native(Twine(RealBase) + "/test1/test2", Expected);

  ASSERT_NO_ERROR(fs::real_path(
      Twine(TestDirectory) + "/././test1/../test1/test2/./test3/..", Actual));
  checkSeparators(Actual);

  EXPECT_EQ(Expected, Actual);

  SmallString<64> HomeDir;

  // This can fail if $HOME is not set and getpwuid fails.
  bool Result = llvm::sys::path::home_directory(HomeDir);
  if (Result) {
    checkSeparators(HomeDir);
    ASSERT_NO_ERROR(fs::real_path(HomeDir, Expected));
    checkSeparators(Expected);
    ASSERT_NO_ERROR(fs::real_path("~", Actual, true));
    EXPECT_EQ(Expected, Actual);
    ASSERT_NO_ERROR(fs::real_path("~/", Actual, true));
    EXPECT_EQ(Expected, Actual);
  }

  ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) + "/test1"));
}

TEST_F(FileSystemTest, ExpandTilde) {
  SmallString<64> Expected;
  SmallString<64> Actual;
  SmallString<64> HomeDir;

  // This can fail if $HOME is not set and getpwuid fails.
  bool Result = llvm::sys::path::home_directory(HomeDir);
  if (Result) {
    fs::expand_tilde(HomeDir, Expected);

    fs::expand_tilde("~", Actual);
    EXPECT_EQ(Expected, Actual);

#ifdef _WIN32
    Expected += "\\foo";
    fs::expand_tilde("~\\foo", Actual);
#else
    Expected += "/foo";
    fs::expand_tilde("~/foo", Actual);
#endif

    EXPECT_EQ(Expected, Actual);
  }
}

#ifdef LLVM_ON_UNIX
TEST_F(FileSystemTest, RealPathNoReadPerm) {
  SmallString<64> Expanded;

  ASSERT_NO_ERROR(
    fs::create_directories(Twine(TestDirectory) + "/noreadperm"));
  ASSERT_TRUE(fs::exists(Twine(TestDirectory) + "/noreadperm"));

  fs::setPermissions(Twine(TestDirectory) + "/noreadperm", fs::no_perms);
  fs::setPermissions(Twine(TestDirectory) + "/noreadperm", fs::all_exe);

  ASSERT_NO_ERROR(fs::real_path(Twine(TestDirectory) + "/noreadperm", Expanded,
                                false));

  ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) + "/noreadperm"));
}
TEST_F(FileSystemTest, RemoveDirectoriesNoExePerm) {
  SmallString<64> Expanded;

  ASSERT_NO_ERROR(
      fs::create_directories(Twine(TestDirectory) + "/noexeperm/foo"));
  ASSERT_TRUE(fs::exists(Twine(TestDirectory) + "/noexeperm/foo"));

  fs::setPermissions(Twine(TestDirectory) + "/noexeperm",
                     fs::all_read | fs::all_write);

  ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) + "/noexeperm",
                                         /*IgnoreErrors=*/true));

  // It's expected that the directory exists, but some environments appear to
  // allow the removal despite missing the 'x' permission, so be flexible.
  if (fs::exists(Twine(TestDirectory) + "/noexeperm")) {
    fs::setPermissions(Twine(TestDirectory) + "/noexeperm", fs::all_perms);
    ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) + "/noexeperm",
                                           /*IgnoreErrors=*/false));
  }
}
#endif


TEST_F(FileSystemTest, TempFileKeepDiscard) {
  // We can keep then discard.
  auto TempFileOrError = fs::TempFile::create(TestDirectory + "/test-%%%%");
  ASSERT_TRUE((bool)TempFileOrError);
  fs::TempFile File = std::move(*TempFileOrError);
  ASSERT_EQ(-1, TempFileOrError->FD);
  ASSERT_FALSE((bool)File.keep(TestDirectory + "/keep"));
  ASSERT_FALSE((bool)File.discard());
  ASSERT_TRUE(fs::exists(TestDirectory + "/keep"));
  ASSERT_NO_ERROR(fs::remove(TestDirectory + "/keep"));
}

TEST_F(FileSystemTest, TempFileDiscardDiscard) {
  // We can discard twice.
  auto TempFileOrError = fs::TempFile::create(TestDirectory + "/test-%%%%");
  ASSERT_TRUE((bool)TempFileOrError);
  fs::TempFile File = std::move(*TempFileOrError);
  ASSERT_EQ(-1, TempFileOrError->FD);
  ASSERT_FALSE((bool)File.discard());
  ASSERT_FALSE((bool)File.discard());
  ASSERT_FALSE(fs::exists(TestDirectory + "/keep"));
}

TEST_F(FileSystemTest, TempFiles) {
  // Create a temp file.
  int FileDescriptor;
  SmallString<64> TempPath;
  ASSERT_NO_ERROR(
      fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));

  // Make sure it exists.
  ASSERT_TRUE(sys::fs::exists(Twine(TempPath)));

  // Create another temp tile.
  int FD2;
  SmallString<64> TempPath2;
  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD2, TempPath2));
  ASSERT_TRUE(TempPath2.endswith(".temp"));
  ASSERT_NE(TempPath.str(), TempPath2.str());

  fs::file_status A, B;
  ASSERT_NO_ERROR(fs::status(Twine(TempPath), A));
  ASSERT_NO_ERROR(fs::status(Twine(TempPath2), B));
  EXPECT_FALSE(fs::equivalent(A, B));

  ::close(FD2);

  // Remove Temp2.
  ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));
  ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));
  ASSERT_EQ(fs::remove(Twine(TempPath2), false),
            errc::no_such_file_or_directory);

  std::error_code EC = fs::status(TempPath2.c_str(), B);
  EXPECT_EQ(EC, errc::no_such_file_or_directory);
  EXPECT_EQ(B.type(), fs::file_type::file_not_found);

  // Make sure Temp2 doesn't exist.
  ASSERT_EQ(fs::access(Twine(TempPath2), sys::fs::AccessMode::Exist),
            errc::no_such_file_or_directory);

  SmallString<64> TempPath3;
  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "", TempPath3));
  ASSERT_FALSE(TempPath3.endswith("."));
  FileRemover Cleanup3(TempPath3);

  // Create a hard link to Temp1.
  ASSERT_NO_ERROR(fs::create_link(Twine(TempPath), Twine(TempPath2)));
#ifndef _WIN32
  // FIXME: Our implementation of equivalent() on Windows doesn't consider hard
  // links to be the same file.
  bool equal;
  ASSERT_NO_ERROR(fs::equivalent(Twine(TempPath), Twine(TempPath2), equal));
  EXPECT_TRUE(equal);
  ASSERT_NO_ERROR(fs::status(Twine(TempPath), A));
  ASSERT_NO_ERROR(fs::status(Twine(TempPath2), B));
  EXPECT_TRUE(fs::equivalent(A, B));
#endif

  // Remove Temp1.
  ::close(FileDescriptor);
  ASSERT_NO_ERROR(fs::remove(Twine(TempPath)));

  // Remove the hard link.
  ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));

  // Make sure Temp1 doesn't exist.
  ASSERT_EQ(fs::access(Twine(TempPath), sys::fs::AccessMode::Exist),
            errc::no_such_file_or_directory);

#ifdef _WIN32
  // Path name > 260 chars should get an error.
  const char *Path270 =
    "abcdefghijklmnopqrstuvwxyz9abcdefghijklmnopqrstuvwxyz8"
    "abcdefghijklmnopqrstuvwxyz7abcdefghijklmnopqrstuvwxyz6"
    "abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz4"
    "abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz2"
    "abcdefghijklmnopqrstuvwxyz1abcdefghijklmnopqrstuvwxyz0";
  EXPECT_EQ(fs::createUniqueFile(Path270, FileDescriptor, TempPath),
            errc::invalid_argument);
  // Relative path < 247 chars, no problem.
  const char *Path216 =
    "abcdefghijklmnopqrstuvwxyz7abcdefghijklmnopqrstuvwxyz6"
    "abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz4"
    "abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz2"
    "abcdefghijklmnopqrstuvwxyz1abcdefghijklmnopqrstuvwxyz0";
  ASSERT_NO_ERROR(fs::createTemporaryFile(Path216, "", TempPath));
  ASSERT_NO_ERROR(fs::remove(Twine(TempPath)));
#endif
}

TEST_F(FileSystemTest, TempFileCollisions) {
  SmallString<128> TestDirectory;
  ASSERT_NO_ERROR(
      fs::createUniqueDirectory("CreateUniqueFileTest", TestDirectory));
  FileRemover Cleanup(TestDirectory);
  SmallString<128> Model = TestDirectory;
  path::append(Model, "%.tmp");
  SmallString<128> Path;
  std::vector<fs::TempFile> TempFiles;

  auto TryCreateTempFile = [&]() {
    Expected<fs::TempFile> T = fs::TempFile::create(Model);
    if (T) {
      TempFiles.push_back(std::move(*T));
      return true;
    } else {
      logAllUnhandledErrors(T.takeError(), errs(),
                            "Failed to create temporary file: ");
      return false;
    }
  };

  // Our single-character template allows for 16 unique names. Check that
  // calling TryCreateTempFile repeatedly results in 16 successes.
  // Because the test depends on random numbers, it could theoretically fail.
  // However, the probability of this happening is tiny: with 32 calls, each
  // of which will retry up to 128 times, to not get a given digit we would
  // have to fail at least 15 + 17 * 128 = 2191 attempts. The probability of
  // 2191 attempts not producing a given hexadecimal digit is
  // (1 - 1/16) ** 2191 or 3.88e-62.
  int Successes = 0;
  for (int i = 0; i < 32; ++i)
    if (TryCreateTempFile()) ++Successes;
  EXPECT_EQ(Successes, 16);

  for (fs::TempFile &T : TempFiles)
    cantFail(T.discard());
}

TEST_F(FileSystemTest, CreateDir) {
  ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "foo"));
  ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "foo"));
  ASSERT_EQ(fs::create_directory(Twine(TestDirectory) + "foo", false),
            errc::file_exists);
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "foo"));

#ifdef LLVM_ON_UNIX
  // Set a 0000 umask so that we can test our directory permissions.
  mode_t OldUmask = ::umask(0000);

  fs::file_status Status;
  ASSERT_NO_ERROR(
      fs::create_directory(Twine(TestDirectory) + "baz500", false,
                           fs::perms::owner_read | fs::perms::owner_exe));
  ASSERT_NO_ERROR(fs::status(Twine(TestDirectory) + "baz500", Status));
  ASSERT_EQ(Status.permissions() & fs::perms::all_all,
            fs::perms::owner_read | fs::perms::owner_exe);
  ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "baz777", false,
                                       fs::perms::all_all));
  ASSERT_NO_ERROR(fs::status(Twine(TestDirectory) + "baz777", Status));
  ASSERT_EQ(Status.permissions() & fs::perms::all_all, fs::perms::all_all);

  // Restore umask to be safe.
  ::umask(OldUmask);
#endif

#ifdef _WIN32
  // Prove that create_directories() can handle a pathname > 248 characters,
  // which is the documented limit for CreateDirectory().
  // (248 is MAX_PATH subtracting room for an 8.3 filename.)
  // Generate a directory path guaranteed to fall into that range.
  size_t TmpLen = TestDirectory.size();
  const char *OneDir = "\\123456789";
  size_t OneDirLen = strlen(OneDir);
  ASSERT_LT(OneDirLen, 12U);
  size_t NLevels = ((248 - TmpLen) / OneDirLen) + 1;
  SmallString<260> LongDir(TestDirectory);
  for (size_t I = 0; I < NLevels; ++I)
    LongDir.append(OneDir);
  ASSERT_NO_ERROR(fs::create_directories(Twine(LongDir)));
  ASSERT_NO_ERROR(fs::create_directories(Twine(LongDir)));
  ASSERT_EQ(fs::create_directories(Twine(LongDir), false),
            errc::file_exists);
  // Tidy up, "recursively" removing the directories.
  StringRef ThisDir(LongDir);
  for (size_t J = 0; J < NLevels; ++J) {
    ASSERT_NO_ERROR(fs::remove(ThisDir));
    ThisDir = path::parent_path(ThisDir);
  }

  // Also verify that paths with Unix separators are handled correctly.
  std::string LongPathWithUnixSeparators(TestDirectory.str());
  // Add at least one subdirectory to TestDirectory, and replace slashes with
  // backslashes
  do {
    LongPathWithUnixSeparators.append("/DirNameWith19Charss");
  } while (LongPathWithUnixSeparators.size() < 260);
  std::replace(LongPathWithUnixSeparators.begin(),
               LongPathWithUnixSeparators.end(),
               '\\', '/');
  ASSERT_NO_ERROR(fs::create_directories(Twine(LongPathWithUnixSeparators)));
  // cleanup
  ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) +
                                         "/DirNameWith19Charss"));

  // Similarly for a relative pathname.  Need to set the current directory to
  // TestDirectory so that the one we create ends up in the right place.
  char PreviousDir[260];
  size_t PreviousDirLen = ::GetCurrentDirectoryA(260, PreviousDir);
  ASSERT_GT(PreviousDirLen, 0U);
  ASSERT_LT(PreviousDirLen, 260U);
  ASSERT_NE(::SetCurrentDirectoryA(TestDirectory.c_str()), 0);
  LongDir.clear();
  // Generate a relative directory name with absolute length > 248.
  size_t LongDirLen = 249 - TestDirectory.size();
  LongDir.assign(LongDirLen, 'a');
  ASSERT_NO_ERROR(fs::create_directory(Twine(LongDir)));
  // While we're here, prove that .. and . handling works in these long paths.
  const char *DotDotDirs = "\\..\\.\\b";
  LongDir.append(DotDotDirs);
  ASSERT_NO_ERROR(fs::create_directory("b"));
  ASSERT_EQ(fs::create_directory(Twine(LongDir), false), errc::file_exists);
  // And clean up.
  ASSERT_NO_ERROR(fs::remove("b"));
  ASSERT_NO_ERROR(fs::remove(
    Twine(LongDir.substr(0, LongDir.size() - strlen(DotDotDirs)))));
  ASSERT_NE(::SetCurrentDirectoryA(PreviousDir), 0);
#endif
}

TEST_F(FileSystemTest, DirectoryIteration) {
  std::error_code ec;
  for (fs::directory_iterator i(".", ec), e; i != e; i.increment(ec))
    ASSERT_NO_ERROR(ec);

  // Create a known hierarchy to recurse over.
  ASSERT_NO_ERROR(
      fs::create_directories(Twine(TestDirectory) + "/recursive/a0/aa1"));
  ASSERT_NO_ERROR(
      fs::create_directories(Twine(TestDirectory) + "/recursive/a0/ab1"));
  ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) +
                                         "/recursive/dontlookhere/da1"));
  ASSERT_NO_ERROR(
      fs::create_directories(Twine(TestDirectory) + "/recursive/z0/za1"));
  ASSERT_NO_ERROR(
      fs::create_directories(Twine(TestDirectory) + "/recursive/pop/p1"));
  typedef std::vector<std::string> v_t;
  v_t visited;
  for (fs::recursive_directory_iterator i(Twine(TestDirectory)
         + "/recursive", ec), e; i != e; i.increment(ec)){
    ASSERT_NO_ERROR(ec);
    if (path::filename(i->path()) == "p1") {
      i.pop();
      // FIXME: recursive_directory_iterator should be more robust.
      if (i == e) break;
    }
    if (path::filename(i->path()) == "dontlookhere")
      i.no_push();
    visited.push_back(std::string(path::filename(i->path())));
  }
  v_t::const_iterator a0 = find(visited, "a0");
  v_t::const_iterator aa1 = find(visited, "aa1");
  v_t::const_iterator ab1 = find(visited, "ab1");
  v_t::const_iterator dontlookhere = find(visited, "dontlookhere");
  v_t::const_iterator da1 = find(visited, "da1");
  v_t::const_iterator z0 = find(visited, "z0");
  v_t::const_iterator za1 = find(visited, "za1");
  v_t::const_iterator pop = find(visited, "pop");
  v_t::const_iterator p1 = find(visited, "p1");

  // Make sure that each path was visited correctly.
  ASSERT_NE(a0, visited.end());
  ASSERT_NE(aa1, visited.end());
  ASSERT_NE(ab1, visited.end());
  ASSERT_NE(dontlookhere, visited.end());
  ASSERT_EQ(da1, visited.end()); // Not visited.
  ASSERT_NE(z0, visited.end());
  ASSERT_NE(za1, visited.end());
  ASSERT_NE(pop, visited.end());
  ASSERT_EQ(p1, visited.end()); // Not visited.

  // Make sure that parents were visited before children. No other ordering
  // guarantees can be made across siblings.
  ASSERT_LT(a0, aa1);
  ASSERT_LT(a0, ab1);
  ASSERT_LT(z0, za1);

  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0/aa1"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0/ab1"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0"));
  ASSERT_NO_ERROR(
      fs::remove(Twine(TestDirectory) + "/recursive/dontlookhere/da1"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/dontlookhere"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/pop/p1"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/pop"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/z0/za1"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/z0"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive"));

  // Test recursive_directory_iterator level()
  ASSERT_NO_ERROR(
      fs::create_directories(Twine(TestDirectory) + "/reclevel/a/b/c"));
  fs::recursive_directory_iterator I(Twine(TestDirectory) + "/reclevel", ec), E;
  for (int l = 0; I != E; I.increment(ec), ++l) {
    ASSERT_NO_ERROR(ec);
    EXPECT_EQ(I.level(), l);
  }
  EXPECT_EQ(I, E);
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel/a/b/c"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel/a/b"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel/a"));
  ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel"));
}

TEST_F(FileSystemTest, DirectoryNotExecutable) {
  ASSERT_EQ(fs::access(TestDirectory, sys::fs::AccessMode::Execute),
            errc::permission_denied);
}

#ifdef LLVM_ON_UNIX
TEST_F(FileSystemTest, BrokenSymlinkDirectoryIteration) {
  // Create a known hierarchy to recurse over.
  ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) + "/symlink"));
  ASSERT_NO_ERROR(
      fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/a"));
  ASSERT_NO_ERROR(
      fs::create_directories(Twine(TestDirectory) + "/symlink/b/bb"));
  ASSERT_NO_ERROR(
      fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/b/ba"));
  ASSERT_NO_ERROR(
      fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/b/bc"));
  ASSERT_NO_ERROR(
      fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/c"));
  ASSERT_NO_ERROR(
      fs::create_directories(Twine(TestDirectory) + "/symlink/d/dd/ddd"));
  ASSERT_NO_ERROR(fs::create_link(Twine(TestDirectory) + "/symlink/d/dd",
                                  Twine(TestDirectory) + "/symlink/d/da"));
  ASSERT_NO_ERROR(
      fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/e"));

  typedef std::vector<std::string> v_t;
  v_t VisitedNonBrokenSymlinks;
  v_t VisitedBrokenSymlinks;
  std::error_code ec;
  using testing::UnorderedElementsAre;
  using testing::UnorderedElementsAreArray;

  // Broken symbol links are expected to throw an error.
  for (fs::directory_iterator i(Twine(TestDirectory) + "/symlink", ec), e;
       i != e; i.increment(ec)) {
    ASSERT_NO_ERROR(ec);
    if (i->status().getError() ==
        std::make_error_code(std::errc::no_such_file_or_directory)) {
      VisitedBrokenSymlinks.push_back(std::string(path::filename(i->path())));
      continue;
    }
    VisitedNonBrokenSymlinks.push_back(std::string(path::filename(i->path())));
  }
  EXPECT_THAT(VisitedNonBrokenSymlinks, UnorderedElementsAre("b", "d"));
  VisitedNonBrokenSymlinks.clear();

  EXPECT_THAT(VisitedBrokenSymlinks, UnorderedElementsAre("a", "c", "e"));
  VisitedBrokenSymlinks.clear();

  // Broken symbol links are expected to throw an error.
  for (fs::recursive_directory_iterator i(
      Twine(TestDirectory) + "/symlink", ec), e; i != e; i.increment(ec)) {
    ASSERT_NO_ERROR(ec);
    if (i->status().getError() ==
        std::make_error_code(std::errc::no_such_file_or_directory)) {
      VisitedBrokenSymlinks.push_back(std::string(path::filename(i->path())));
      continue;
    }
    VisitedNonBrokenSymlinks.push_back(std::string(path::filename(i->path())));
  }
  EXPECT_THAT(VisitedNonBrokenSymlinks,
              UnorderedElementsAre("b", "bb", "d", "da", "dd", "ddd", "ddd"));
  VisitedNonBrokenSymlinks.clear();

  EXPECT_THAT(VisitedBrokenSymlinks,
              UnorderedElementsAre("a", "ba", "bc", "c", "e"));
  VisitedBrokenSymlinks.clear();

  for (fs::recursive_directory_iterator i(
      Twine(TestDirectory) + "/symlink", ec, /*follow_symlinks=*/false), e;
       i != e; i.increment(ec)) {
    ASSERT_NO_ERROR(ec);
    if (i->status().getError() ==
        std::make_error_code(std::errc::no_such_file_or_directory)) {
      VisitedBrokenSymlinks.push_back(std::string(path::filename(i->path())));
      continue;
    }
    VisitedNonBrokenSymlinks.push_back(std::string(path::filename(i->path())));
  }
  EXPECT_THAT(VisitedNonBrokenSymlinks,
              UnorderedElementsAreArray({"a", "b", "ba", "bb", "bc", "c", "d",
                                         "da", "dd", "ddd", "e"}));
  VisitedNonBrokenSymlinks.clear();

  EXPECT_THAT(VisitedBrokenSymlinks, UnorderedElementsAre());
  VisitedBrokenSymlinks.clear();

  ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) + "/symlink"));
}
#endif

#ifdef _WIN32
TEST_F(FileSystemTest, UTF8ToUTF16DirectoryIteration) {
  // The Windows filesystem support uses UTF-16 and converts paths from the
  // input UTF-8. The UTF-16 equivalent of the input path can be shorter in
  // length.

  // This test relies on TestDirectory not being so long such that MAX_PATH
  // would be exceeded (see widenPath). If that were the case, the UTF-16
  // path is likely to be longer than the input.
  const char *Pi = "\xcf\x80"; // UTF-8 lower case pi.
  std::string RootDir = (TestDirectory + "/" + Pi).str();

  // Create test directories.
  ASSERT_NO_ERROR(fs::create_directories(Twine(RootDir) + "/a"));
  ASSERT_NO_ERROR(fs::create_directories(Twine(RootDir) + "/b"));

  std::error_code EC;
  unsigned Count = 0;
  for (fs::directory_iterator I(Twine(RootDir), EC), E; I != E;
       I.increment(EC)) {
    ASSERT_NO_ERROR(EC);
    StringRef DirName = path::filename(I->path());
    EXPECT_TRUE(DirName == "a" || DirName == "b");
    ++Count;
  }
  EXPECT_EQ(Count, 2U);

  ASSERT_NO_ERROR(fs::remove(Twine(RootDir) + "/a"));
  ASSERT_NO_ERROR(fs::remove(Twine(RootDir) + "/b"));
  ASSERT_NO_ERROR(fs::remove(Twine(RootDir)));
}
#endif

TEST_F(FileSystemTest, Remove) {
  SmallString<64> BaseDir;
  SmallString<64> Paths[4];
  int fds[4];
  ASSERT_NO_ERROR(fs::createUniqueDirectory("fs_remove", BaseDir));

  ASSERT_NO_ERROR(fs::create_directories(Twine(BaseDir) + "/foo/bar/baz"));
  ASSERT_NO_ERROR(fs::create_directories(Twine(BaseDir) + "/foo/bar/buzz"));
  ASSERT_NO_ERROR(fs::createUniqueFile(
      Twine(BaseDir) + "/foo/bar/baz/%%%%%%.tmp", fds[0], Paths[0]));
  ASSERT_NO_ERROR(fs::createUniqueFile(
      Twine(BaseDir) + "/foo/bar/baz/%%%%%%.tmp", fds[1], Paths[1]));
  ASSERT_NO_ERROR(fs::createUniqueFile(
      Twine(BaseDir) + "/foo/bar/buzz/%%%%%%.tmp", fds[2], Paths[2]));
  ASSERT_NO_ERROR(fs::createUniqueFile(
      Twine(BaseDir) + "/foo/bar/buzz/%%%%%%.tmp", fds[3], Paths[3]));

  for (int fd : fds)
    ::close(fd);

  EXPECT_TRUE(fs::exists(Twine(BaseDir) + "/foo/bar/baz"));
  EXPECT_TRUE(fs::exists(Twine(BaseDir) + "/foo/bar/buzz"));
  EXPECT_TRUE(fs::exists(Paths[0]));
  EXPECT_TRUE(fs::exists(Paths[1]));
  EXPECT_TRUE(fs::exists(Paths[2]));
  EXPECT_TRUE(fs::exists(Paths[3]));

  ASSERT_NO_ERROR(fs::remove_directories("D:/footest"));

  ASSERT_NO_ERROR(fs::remove_directories(BaseDir));
  ASSERT_FALSE(fs::exists(BaseDir));
}

#ifdef _WIN32
TEST_F(FileSystemTest, CarriageReturn) {
  SmallString<128> FilePathname(TestDirectory);
  std::error_code EC;
  path::append(FilePathname, "test");

  {
    raw_fd_ostream File(FilePathname, EC, sys::fs::OF_TextWithCRLF);
    ASSERT_NO_ERROR(EC);
    File << '\n';
  }
  {
    auto Buf = MemoryBuffer::getFile(FilePathname.str());
    EXPECT_TRUE((bool)Buf);
    EXPECT_EQ(Buf.get()->getBuffer(), "\r\n");
  }

  {
    raw_fd_ostream File(FilePathname, EC, sys::fs::OF_None);
    ASSERT_NO_ERROR(EC);
    File << '\n';
  }
  {
    auto Buf = MemoryBuffer::getFile(FilePathname.str());
    EXPECT_TRUE((bool)Buf);
    EXPECT_EQ(Buf.get()->getBuffer(), "\n");
  }
  ASSERT_NO_ERROR(fs::remove(Twine(FilePathname)));
}
#endif

TEST_F(FileSystemTest, Resize) {
  int FD;
  SmallString<64> TempPath;
  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath));
  ASSERT_NO_ERROR(fs::resize_file(FD, 123));
  fs::file_status Status;
  ASSERT_NO_ERROR(fs::status(FD, Status));
  ASSERT_EQ(Status.getSize(), 123U);
  ::close(FD);
  ASSERT_NO_ERROR(fs::remove(TempPath));
}

TEST_F(FileSystemTest, ResizeBeforeMapping) {
  // Create a temp file.
  int FD;
  SmallString<64> TempPath;
  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath));
  ASSERT_NO_ERROR(fs::resize_file_before_mapping_readwrite(FD, 123));

  // Map in temp file. On Windows, fs::resize_file_before_mapping_readwrite is
  // a no-op and the mapping itself will resize the file.
  std::error_code EC;
  {
    fs::mapped_file_region mfr(fs::convertFDToNativeFile(FD),
                               fs::mapped_file_region::readwrite, 123, 0, EC);
    ASSERT_NO_ERROR(EC);
    // Unmap temp file
  }

  // Check the size.
  fs::file_status Status;
  ASSERT_NO_ERROR(fs::status(FD, Status));
  ASSERT_EQ(Status.getSize(), 123U);
  ::close(FD);
  ASSERT_NO_ERROR(fs::remove(TempPath));
}

TEST_F(FileSystemTest, MD5) {
  int FD;
  SmallString<64> TempPath;
  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath));
  StringRef Data("abcdefghijklmnopqrstuvwxyz");
  ASSERT_EQ(write(FD, Data.data(), Data.size()), static_cast<ssize_t>(Data.size()));
  lseek(FD, 0, SEEK_SET);
  auto Hash = fs::md5_contents(FD);
  ::close(FD);
  ASSERT_NO_ERROR(Hash.getError());

  EXPECT_STREQ("c3fcd3d76192e4007dfb496cca67e13b", Hash->digest().c_str());
}

TEST_F(FileSystemTest, FileMapping) {
  // Create a temp file.
  int FileDescriptor;
  SmallString<64> TempPath;
  ASSERT_NO_ERROR(
      fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));
  unsigned Size = 4096;
  ASSERT_NO_ERROR(
      fs::resize_file_before_mapping_readwrite(FileDescriptor, Size));

  // Map in temp file and add some content
  std::error_code EC;
  StringRef Val("hello there");
  fs::mapped_file_region MaybeMFR;
  EXPECT_FALSE(MaybeMFR);
  {
    fs::mapped_file_region mfr(fs::convertFDToNativeFile(FileDescriptor),
                               fs::mapped_file_region::readwrite, Size, 0, EC);
    ASSERT_NO_ERROR(EC);
    std::copy(Val.begin(), Val.end(), mfr.data());
    // Explicitly add a 0.
    mfr.data()[Val.size()] = 0;

    // Move it out of the scope and confirm mfr is reset.
    MaybeMFR = std::move(mfr);
    EXPECT_FALSE(mfr);
#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
    EXPECT_DEATH(mfr.data(), "Mapping failed but used anyway!");
    EXPECT_DEATH(mfr.size(), "Mapping failed but used anyway!");
#endif
  }

  // Check that the moved-to region is still valid.
  EXPECT_EQ(Val, StringRef(MaybeMFR.data()));
  EXPECT_EQ(Size, MaybeMFR.size());

  // Unmap temp file.
  MaybeMFR.unmap();

  ASSERT_EQ(close(FileDescriptor), 0);

  // Map it back in read-only
  {
    int FD;
    EC = fs::openFileForRead(Twine(TempPath), FD);
    ASSERT_NO_ERROR(EC);
    fs::mapped_file_region mfr(fs::convertFDToNativeFile(FD),
                               fs::mapped_file_region::readonly, Size, 0, EC);
    ASSERT_NO_ERROR(EC);

    // Verify content
    EXPECT_EQ(StringRef(mfr.const_data()), Val);

    // Unmap temp file
    fs::mapped_file_region m(fs::convertFDToNativeFile(FD),
                             fs::mapped_file_region::readonly, Size, 0, EC);
    ASSERT_NO_ERROR(EC);
    ASSERT_EQ(close(FD), 0);
  }
  ASSERT_NO_ERROR(fs::remove(TempPath));
}

TEST(Support, NormalizePath) {
  //                           Input,        Expected Win, Expected Posix
  using TestTuple = std::tuple<const char *, const char *, const char *>;
  std::vector<TestTuple> Tests;
  Tests.emplace_back("a", "a", "a");
  Tests.emplace_back("a/b", "a\\b", "a/b");
  Tests.emplace_back("a\\b", "a\\b", "a/b");
  Tests.emplace_back("a\\\\b", "a\\\\b", "a//b");
  Tests.emplace_back("\\a", "\\a", "/a");
  Tests.emplace_back("a\\", "a\\", "a/");
  Tests.emplace_back("a\\t", "a\\t", "a/t");

  for (auto &T : Tests) {
    SmallString<64> Win(std::get<0>(T));
    SmallString<64> Posix(Win);
    SmallString<64> WinSlash(Win);
    path::native(Win, path::Style::windows);
    path::native(Posix, path::Style::posix);
    path::native(WinSlash, path::Style::windows_slash);
    EXPECT_EQ(std::get<1>(T), Win);
    EXPECT_EQ(std::get<2>(T), Posix);
    EXPECT_EQ(std::get<2>(T), WinSlash);
  }

  for (auto &T : Tests) {
    SmallString<64> WinBackslash(std::get<0>(T));
    SmallString<64> Posix(WinBackslash);
    SmallString<64> WinSlash(WinBackslash);
    path::make_preferred(WinBackslash, path::Style::windows_backslash);
    path::make_preferred(Posix, path::Style::posix);
    path::make_preferred(WinSlash, path::Style::windows_slash);
    EXPECT_EQ(std::get<1>(T), WinBackslash);
    EXPECT_EQ(std::get<0>(T), Posix); // Posix remains unchanged here
    EXPECT_EQ(std::get<2>(T), WinSlash);
  }

#if defined(_WIN32)
  SmallString<64> PathHome;
  path::home_directory(PathHome);

  const char *Path7a = "~/aaa";
  SmallString<64> Path7(Path7a);
  path::native(Path7, path::Style::windows_backslash);
  EXPECT_TRUE(Path7.endswith("\\aaa"));
  EXPECT_TRUE(Path7.startswith(PathHome));
  EXPECT_EQ(Path7.size(), PathHome.size() + strlen(Path7a + 1));
  Path7 = Path7a;
  path::native(Path7, path::Style::windows_slash);
  EXPECT_TRUE(Path7.endswith("/aaa"));
  EXPECT_TRUE(Path7.startswith(PathHome));
  EXPECT_EQ(Path7.size(), PathHome.size() + strlen(Path7a + 1));

  const char *Path8a = "~";
  SmallString<64> Path8(Path8a);
  path::native(Path8);
  EXPECT_EQ(Path8, PathHome);

  const char *Path9a = "~aaa";
  SmallString<64> Path9(Path9a);
  path::native(Path9);
  EXPECT_EQ(Path9, "~aaa");

  const char *Path10a = "aaa/~/b";
  SmallString<64> Path10(Path10a);
  path::native(Path10, path::Style::windows_backslash);
  EXPECT_EQ(Path10, "aaa\\~\\b");
#endif
}

TEST(Support, RemoveLeadingDotSlash) {
  StringRef Path1("././/foolz/wat");
  StringRef Path2("./////");

  Path1 = path::remove_leading_dotslash(Path1);
  EXPECT_EQ(Path1, "foolz/wat");
  Path2 = path::remove_leading_dotslash(Path2);
  EXPECT_EQ(Path2, "");
}

static std::string remove_dots(StringRef path, bool remove_dot_dot,
                               path::Style style) {
  SmallString<256> buffer(path);
  path::remove_dots(buffer, remove_dot_dot, style);
  return std::string(buffer.str());
}

TEST(Support, RemoveDots) {
  EXPECT_EQ("foolz\\wat",
            remove_dots(".\\.\\\\foolz\\wat", false, path::Style::windows));
  EXPECT_EQ("", remove_dots(".\\\\\\\\\\", false, path::Style::windows));

  EXPECT_EQ("a\\..\\b\\c",
            remove_dots(".\\a\\..\\b\\c", false, path::Style::windows));
  EXPECT_EQ("b\\c", remove_dots(".\\a\\..\\b\\c", true, path::Style::windows));
  EXPECT_EQ("c", remove_dots(".\\.\\c", true, path::Style::windows));
  EXPECT_EQ("..\\a\\c",
            remove_dots("..\\a\\b\\..\\c", true, path::Style::windows));
  EXPECT_EQ("..\\..\\a\\c",
            remove_dots("..\\..\\a\\b\\..\\c", true, path::Style::windows));
  EXPECT_EQ("C:\\a\\c", remove_dots("C:\\foo\\bar//..\\..\\a\\c", true,
                                    path::Style::windows));

  EXPECT_EQ("C:\\bar",
            remove_dots("C:/foo/../bar", true, path::Style::windows));
  EXPECT_EQ("C:\\foo\\bar",
            remove_dots("C:/foo/bar", true, path::Style::windows));
  EXPECT_EQ("C:\\foo\\bar",
            remove_dots("C:/foo\\bar", true, path::Style::windows));
  EXPECT_EQ("\\", remove_dots("/", true, path::Style::windows));
  EXPECT_EQ("C:\\", remove_dots("C:/", true, path::Style::windows));

  // Some clients of remove_dots expect it to remove trailing slashes. Again,
  // this is emergent behavior that VFS relies on, and not inherently part of
  // the specification.
  EXPECT_EQ("C:\\foo\\bar",
            remove_dots("C:\\foo\\bar\\", true, path::Style::windows));
  EXPECT_EQ("/foo/bar",
            remove_dots("/foo/bar/", true, path::Style::posix));

  // A double separator is rewritten.
  EXPECT_EQ("C:\\foo\\bar",
            remove_dots("C:/foo//bar", true, path::Style::windows));

  SmallString<64> Path1(".\\.\\c");
  EXPECT_TRUE(path::remove_dots(Path1, true, path::Style::windows));
  EXPECT_EQ("c", Path1);

  EXPECT_EQ("foolz/wat",
            remove_dots("././/foolz/wat", false, path::Style::posix));
  EXPECT_EQ("", remove_dots("./////", false, path::Style::posix));

  EXPECT_EQ("a/../b/c", remove_dots("./a/../b/c", false, path::Style::posix));
  EXPECT_EQ("b/c", remove_dots("./a/../b/c", true, path::Style::posix));
  EXPECT_EQ("c", remove_dots("././c", true, path::Style::posix));
  EXPECT_EQ("../a/c", remove_dots("../a/b/../c", true, path::Style::posix));
  EXPECT_EQ("../../a/c",
            remove_dots("../../a/b/../c", true, path::Style::posix));
  EXPECT_EQ("/a/c", remove_dots("/../../a/c", true, path::Style::posix));
  EXPECT_EQ("/a/c",
            remove_dots("/../a/b//../././/c", true, path::Style::posix));
  EXPECT_EQ("/", remove_dots("/", true, path::Style::posix));

  // FIXME: Leaving behind this double leading slash seems like a bug.
  EXPECT_EQ("//foo/bar",
            remove_dots("//foo/bar/", true, path::Style::posix));

  SmallString<64> Path2("././c");
  EXPECT_TRUE(path::remove_dots(Path2, true, path::Style::posix));
  EXPECT_EQ("c", Path2);
}

TEST(Support, ReplacePathPrefix) {
  SmallString<64> Path1("/foo");
  SmallString<64> Path2("/old/foo");
  SmallString<64> Path3("/oldnew/foo");
  SmallString<64> Path4("C:\\old/foo\\bar");
  SmallString<64> OldPrefix("/old");
  SmallString<64> OldPrefixSep("/old/");
  SmallString<64> OldPrefixWin("c:/oLD/F");
  SmallString<64> NewPrefix("/new");
  SmallString<64> NewPrefix2("/longernew");
  SmallString<64> EmptyPrefix("");
  bool Found;

  SmallString<64> Path = Path1;
  Found = path::replace_path_prefix(Path, OldPrefix, NewPrefix);
  EXPECT_FALSE(Found);
  EXPECT_EQ(Path, "/foo");
  Path = Path2;
  Found = path::replace_path_prefix(Path, OldPrefix, NewPrefix);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "/new/foo");
  Path = Path2;
  Found = path::replace_path_prefix(Path, OldPrefix, NewPrefix2);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "/longernew/foo");
  Path = Path1;
  Found = path::replace_path_prefix(Path, EmptyPrefix, NewPrefix);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "/new/foo");
  Path = Path2;
  Found = path::replace_path_prefix(Path, OldPrefix, EmptyPrefix);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "/foo");
  Path = Path2;
  Found = path::replace_path_prefix(Path, OldPrefixSep, EmptyPrefix);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "foo");
  Path = Path3;
  Found = path::replace_path_prefix(Path, OldPrefix, NewPrefix);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "/newnew/foo");
  Path = Path3;
  Found = path::replace_path_prefix(Path, OldPrefix, NewPrefix2);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "/longernewnew/foo");
  Path = Path1;
  Found = path::replace_path_prefix(Path, EmptyPrefix, NewPrefix);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "/new/foo");
  Path = OldPrefix;
  Found = path::replace_path_prefix(Path, OldPrefix, NewPrefix);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "/new");
  Path = OldPrefixSep;
  Found = path::replace_path_prefix(Path, OldPrefix, NewPrefix);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "/new/");
  Path = OldPrefix;
  Found = path::replace_path_prefix(Path, OldPrefixSep, NewPrefix);
  EXPECT_FALSE(Found);
  EXPECT_EQ(Path, "/old");
  Path = Path4;
  Found = path::replace_path_prefix(Path, OldPrefixWin, NewPrefix,
                                    path::Style::windows);
  EXPECT_TRUE(Found);
  EXPECT_EQ(Path, "/newoo\\bar");
  Path = Path4;
  Found = path::replace_path_prefix(Path, OldPrefixWin, NewPrefix,
                                    path::Style::posix);
  EXPECT_FALSE(Found);
  EXPECT_EQ(Path, "C:\\old/foo\\bar");
}

TEST_F(FileSystemTest, OpenFileForRead) {
  // Create a temp file.
  int FileDescriptor;
  SmallString<64> TempPath;
  ASSERT_NO_ERROR(
      fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));
  FileRemover Cleanup(TempPath);

  // Make sure it exists.
  ASSERT_TRUE(sys::fs::exists(Twine(TempPath)));

  // Open the file for read
  int FileDescriptor2;
  SmallString<64> ResultPath;
  ASSERT_NO_ERROR(fs::openFileForRead(Twine(TempPath), FileDescriptor2,
                                      fs::OF_None, &ResultPath))

  // If we succeeded, check that the paths are the same (modulo case):
  if (!ResultPath.empty()) {
    // The paths returned by createTemporaryFile and getPathFromOpenFD
    // should reference the same file on disk.
    fs::UniqueID D1, D2;
    ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), D1));
    ASSERT_NO_ERROR(fs::getUniqueID(Twine(ResultPath), D2));
    ASSERT_EQ(D1, D2);
  }
  ::close(FileDescriptor);
  ::close(FileDescriptor2);

#ifdef _WIN32
  // Since Windows Vista, file access time is not updated by default.
  // This is instead updated manually by openFileForRead.
  // https://blogs.technet.microsoft.com/filecab/2006/11/07/disabling-last-access-time-in-windows-vista-to-improve-ntfs-performance/
  // This part of the unit test is Windows specific as the updating of
  // access times can be disabled on Linux using /etc/fstab.

  // Set access time to UNIX epoch.
  ASSERT_NO_ERROR(sys::fs::openFileForWrite(Twine(TempPath), FileDescriptor,
                                            fs::CD_OpenExisting));
  TimePoint<> Epoch(std::chrono::milliseconds(0));
  ASSERT_NO_ERROR(fs::setLastAccessAndModificationTime(FileDescriptor, Epoch));
  ::close(FileDescriptor);

  // Open the file and ensure access time is updated, when forced.
  ASSERT_NO_ERROR(fs::openFileForRead(Twine(TempPath), FileDescriptor,
                                      fs::OF_UpdateAtime, &ResultPath));

  sys::fs::file_status Status;
  ASSERT_NO_ERROR(sys::fs::status(FileDescriptor, Status));
  auto FileAccessTime = Status.getLastAccessedTime();

  ASSERT_NE(Epoch, FileAccessTime);
  ::close(FileDescriptor);

  // Ideally this test would include a case when ATime is not forced to update,
  // however the expected behaviour will differ depending on the configuration
  // of the Windows file system.
#endif
}

static void createFileWithData(const Twine &Path, bool ShouldExistBefore,
                               fs::CreationDisposition Disp, StringRef Data) {
  int FD;
  ASSERT_EQ(ShouldExistBefore, fs::exists(Path));
  ASSERT_NO_ERROR(fs::openFileForWrite(Path, FD, Disp));
  FileDescriptorCloser Closer(FD);
  ASSERT_TRUE(fs::exists(Path));

  ASSERT_EQ(Data.size(), (size_t)write(FD, Data.data(), Data.size()));
}

static void verifyFileContents(const Twine &Path, StringRef Contents) {
  auto Buffer = MemoryBuffer::getFile(Path);
  ASSERT_TRUE((bool)Buffer);
  StringRef Data = Buffer.get()->getBuffer();
  ASSERT_EQ(Data, Contents);
}

TEST_F(FileSystemTest, CreateNew) {
  int FD;
  std::optional<FileDescriptorCloser> Closer;

  // Succeeds if the file does not exist.
  ASSERT_FALSE(fs::exists(NonExistantFile));
  ASSERT_NO_ERROR(fs::openFileForWrite(NonExistantFile, FD, fs::CD_CreateNew));
  ASSERT_TRUE(fs::exists(NonExistantFile));

  FileRemover Cleanup(NonExistantFile);
  Closer.emplace(FD);

  // And creates a file of size 0.
  sys::fs::file_status Status;
  ASSERT_NO_ERROR(sys::fs::status(FD, Status));
  EXPECT_EQ(0ULL, Status.getSize());

  // Close this first, before trying to re-open the file.
  Closer.reset();

  // But fails if the file does exist.
  ASSERT_ERROR(fs::openFileForWrite(NonExistantFile, FD, fs::CD_CreateNew));
}

TEST_F(FileSystemTest, CreateAlways) {
  int FD;
  std::optional<FileDescriptorCloser> Closer;

  // Succeeds if the file does not exist.
  ASSERT_FALSE(fs::exists(NonExistantFile));
  ASSERT_NO_ERROR(
      fs::openFileForWrite(NonExistantFile, FD, fs::CD_CreateAlways));

  Closer.emplace(FD);

  ASSERT_TRUE(fs::exists(NonExistantFile));

  FileRemover Cleanup(NonExistantFile);

  // And creates a file of size 0.
  uint64_t FileSize;
  ASSERT_NO_ERROR(sys::fs::file_size(NonExistantFile, FileSize));
  ASSERT_EQ(0ULL, FileSize);

  // If we write some data to it re-create it with CreateAlways, it succeeds and
  // truncates to 0 bytes.
  ASSERT_EQ(4, write(FD, "Test", 4));

  Closer.reset();

  ASSERT_NO_ERROR(sys::fs::file_size(NonExistantFile, FileSize));
  ASSERT_EQ(4ULL, FileSize);

  ASSERT_NO_ERROR(
      fs::openFileForWrite(NonExistantFile, FD, fs::CD_CreateAlways));
  Closer.emplace(FD);
  ASSERT_NO_ERROR(sys::fs::file_size(NonExistantFile, FileSize));
  ASSERT_EQ(0ULL, FileSize);
}

TEST_F(FileSystemTest, OpenExisting) {
  int FD;

  // Fails if the file does not exist.
  ASSERT_FALSE(fs::exists(NonExistantFile));
  ASSERT_ERROR(fs::openFileForWrite(NonExistantFile, FD, fs::CD_OpenExisting));
  ASSERT_FALSE(fs::exists(NonExistantFile));

  // Make a dummy file now so that we can try again when the file does exist.
  createFileWithData(NonExistantFile, false, fs::CD_CreateNew, "Fizz");
  FileRemover Cleanup(NonExistantFile);
  uint64_t FileSize;
  ASSERT_NO_ERROR(sys::fs::file_size(NonExistantFile, FileSize));
  ASSERT_EQ(4ULL, FileSize);

  // If we re-create it with different data, it overwrites rather than
  // appending.
  createFileWithData(NonExistantFile, true, fs::CD_OpenExisting, "Buzz");
  verifyFileContents(NonExistantFile, "Buzz");
}

TEST_F(FileSystemTest, OpenAlways) {
  // Succeeds if the file does not exist.
  createFileWithData(NonExistantFile, false, fs::CD_OpenAlways, "Fizz");
  FileRemover Cleanup(NonExistantFile);
  uint64_t FileSize;
  ASSERT_NO_ERROR(sys::fs::file_size(NonExistantFile, FileSize));
  ASSERT_EQ(4ULL, FileSize);

  // Now re-open it and write again, verifying the contents get over-written.
  createFileWithData(NonExistantFile, true, fs::CD_OpenAlways, "Bu");
  verifyFileContents(NonExistantFile, "Buzz");
}

TEST_F(FileSystemTest, AppendSetsCorrectFileOffset) {
  fs::CreationDisposition Disps[] = {fs::CD_CreateAlways, fs::CD_OpenAlways,
                                     fs::CD_OpenExisting};

  // Write some data and re-open it with every possible disposition (this is a
  // hack that shouldn't work, but is left for compatibility.  OF_Append
  // overrides
  // the specified disposition.
  for (fs::CreationDisposition Disp : Disps) {
    int FD;
    std::optional<FileDescriptorCloser> Closer;

    createFileWithData(NonExistantFile, false, fs::CD_CreateNew, "Fizz");

    FileRemover Cleanup(NonExistantFile);

    uint64_t FileSize;
    ASSERT_NO_ERROR(sys::fs::file_size(NonExistantFile, FileSize));
    ASSERT_EQ(4ULL, FileSize);
    ASSERT_NO_ERROR(
        fs::openFileForWrite(NonExistantFile, FD, Disp, fs::OF_Append));
    Closer.emplace(FD);
    ASSERT_NO_ERROR(sys::fs::file_size(NonExistantFile, FileSize));
    ASSERT_EQ(4ULL, FileSize);

    ASSERT_EQ(4, write(FD, "Buzz", 4));
    Closer.reset();

    verifyFileContents(NonExistantFile, "FizzBuzz");
  }
}

static void verifyRead(int FD, StringRef Data, bool ShouldSucceed) {
  std::vector<char> Buffer;
  Buffer.resize(Data.size());
  int Result = ::read(FD, Buffer.data(), Buffer.size());
  if (ShouldSucceed) {
    ASSERT_EQ((size_t)Result, Data.size());
    ASSERT_EQ(Data, StringRef(Buffer.data(), Buffer.size()));
  } else {
    ASSERT_EQ(-1, Result);
    ASSERT_EQ(EBADF, errno);
  }
}

static void verifyWrite(int FD, StringRef Data, bool ShouldSucceed) {
  int Result = ::write(FD, Data.data(), Data.size());
  if (ShouldSucceed)
    ASSERT_EQ((size_t)Result, Data.size());
  else {
    ASSERT_EQ(-1, Result);
    ASSERT_EQ(EBADF, errno);
  }
}

TEST_F(FileSystemTest, ReadOnlyFileCantWrite) {
  createFileWithData(NonExistantFile, false, fs::CD_CreateNew, "Fizz");
  FileRemover Cleanup(NonExistantFile);

  int FD;
  ASSERT_NO_ERROR(fs::openFileForRead(NonExistantFile, FD));
  FileDescriptorCloser Closer(FD);

  verifyWrite(FD, "Buzz", false);
  verifyRead(FD, "Fizz", true);
}

TEST_F(FileSystemTest, WriteOnlyFileCantRead) {
  createFileWithData(NonExistantFile, false, fs::CD_CreateNew, "Fizz");
  FileRemover Cleanup(NonExistantFile);

  int FD;
  ASSERT_NO_ERROR(
      fs::openFileForWrite(NonExistantFile, FD, fs::CD_OpenExisting));
  FileDescriptorCloser Closer(FD);
  verifyRead(FD, "Fizz", false);
  verifyWrite(FD, "Buzz", true);
}

TEST_F(FileSystemTest, ReadWriteFileCanReadOrWrite) {
  createFileWithData(NonExistantFile, false, fs::CD_CreateNew, "Fizz");
  FileRemover Cleanup(NonExistantFile);

  int FD;
  ASSERT_NO_ERROR(fs::openFileForReadWrite(NonExistantFile, FD,
                                           fs::CD_OpenExisting, fs::OF_None));
  FileDescriptorCloser Closer(FD);
  verifyRead(FD, "Fizz", true);
  verifyWrite(FD, "Buzz", true);
}

TEST_F(FileSystemTest, readNativeFile) {
  createFileWithData(NonExistantFile, false, fs::CD_CreateNew, "01234");
  FileRemover Cleanup(NonExistantFile);
  const auto &Read = [&](size_t ToRead) -> Expected<std::string> {
    std::string Buf(ToRead, '?');
    Expected<fs::file_t> FD = fs::openNativeFileForRead(NonExistantFile);
    if (!FD)
      return FD.takeError();
    auto Close = make_scope_exit([&] { fs::closeFile(*FD); });
    if (Expected<size_t> BytesRead = fs::readNativeFile(
            *FD, MutableArrayRef(&*Buf.begin(), Buf.size())))
      return Buf.substr(0, *BytesRead);
    else
      return BytesRead.takeError();
  };
  EXPECT_THAT_EXPECTED(Read(5), HasValue("01234"));
  EXPECT_THAT_EXPECTED(Read(3), HasValue("012"));
  EXPECT_THAT_EXPECTED(Read(6), HasValue("01234"));
}

TEST_F(FileSystemTest, readNativeFileToEOF) {
  constexpr StringLiteral Content = "0123456789";
  createFileWithData(NonExistantFile, false, fs::CD_CreateNew, Content);
  FileRemover Cleanup(NonExistantFile);
  const auto &Read = [&](SmallVectorImpl<char> &V,
                         std::optional<ssize_t> ChunkSize) {
    Expected<fs::file_t> FD = fs::openNativeFileForRead(NonExistantFile);
    if (!FD)
      return FD.takeError();
    auto Close = make_scope_exit([&] { fs::closeFile(*FD); });
    if (ChunkSize)
      return fs::readNativeFileToEOF(*FD, V, *ChunkSize);
    return fs::readNativeFileToEOF(*FD, V);
  };

  // Check basic operation.
  {
    SmallString<0> NoSmall;
    SmallString<fs::DefaultReadChunkSize + Content.size()> StaysSmall;
    SmallVectorImpl<char> *Vectors[] = {
        static_cast<SmallVectorImpl<char> *>(&NoSmall),
        static_cast<SmallVectorImpl<char> *>(&StaysSmall),
    };
    for (SmallVectorImpl<char> *V : Vectors) {
      ASSERT_THAT_ERROR(Read(*V, std::nullopt), Succeeded());
      ASSERT_EQ(Content, StringRef(V->begin(), V->size()));
    }
    ASSERT_EQ(fs::DefaultReadChunkSize + Content.size(), StaysSmall.capacity());

    // Check appending.
    {
      constexpr StringLiteral Prefix = "prefix-";
      for (SmallVectorImpl<char> *V : Vectors) {
        V->assign(Prefix.begin(), Prefix.end());
        ASSERT_THAT_ERROR(Read(*V, std::nullopt), Succeeded());
        ASSERT_EQ((Prefix + Content).str(), StringRef(V->begin(), V->size()));
      }
    }
  }

  // Check that the chunk size (if specified) is respected.
  SmallString<Content.size() + 5> SmallChunks;
  ASSERT_THAT_ERROR(Read(SmallChunks, 5), Succeeded());
  ASSERT_EQ(SmallChunks, Content);
  ASSERT_EQ(Content.size() + 5, SmallChunks.capacity());
}

TEST_F(FileSystemTest, readNativeFileSlice) {
  createFileWithData(NonExistantFile, false, fs::CD_CreateNew, "01234");
  FileRemover Cleanup(NonExistantFile);
  Expected<fs::file_t> FD = fs::openNativeFileForRead(NonExistantFile);
  ASSERT_THAT_EXPECTED(FD, Succeeded());
  auto Close = make_scope_exit([&] { fs::closeFile(*FD); });
  const auto &Read = [&](size_t Offset,
                         size_t ToRead) -> Expected<std::string> {
    std::string Buf(ToRead, '?');
    if (Expected<size_t> BytesRead = fs::readNativeFileSlice(
            *FD, MutableArrayRef(&*Buf.begin(), Buf.size()), Offset))
      return Buf.substr(0, *BytesRead);
    else
      return BytesRead.takeError();
  };
  EXPECT_THAT_EXPECTED(Read(0, 5), HasValue("01234"));
  EXPECT_THAT_EXPECTED(Read(0, 3), HasValue("012"));
  EXPECT_THAT_EXPECTED(Read(2, 3), HasValue("234"));
  EXPECT_THAT_EXPECTED(Read(0, 6), HasValue("01234"));
  EXPECT_THAT_EXPECTED(Read(2, 6), HasValue("234"));
  EXPECT_THAT_EXPECTED(Read(5, 5), HasValue(""));
}

TEST_F(FileSystemTest, is_local) {
  bool TestDirectoryIsLocal;
  ASSERT_NO_ERROR(fs::is_local(TestDirectory, TestDirectoryIsLocal));
  EXPECT_EQ(TestDirectoryIsLocal, fs::is_local(TestDirectory));

  int FD;
  SmallString<128> TempPath;
  ASSERT_NO_ERROR(
      fs::createUniqueFile(Twine(TestDirectory) + "/temp", FD, TempPath));
  FileRemover Cleanup(TempPath);

  // Make sure it exists.
  ASSERT_TRUE(sys::fs::exists(Twine(TempPath)));

  bool TempFileIsLocal;
  ASSERT_NO_ERROR(fs::is_local(FD, TempFileIsLocal));
  EXPECT_EQ(TempFileIsLocal, fs::is_local(FD));
  ::close(FD);

  // Expect that the file and its parent directory are equally local or equally
  // remote.
  EXPECT_EQ(TestDirectoryIsLocal, TempFileIsLocal);
}

TEST_F(FileSystemTest, getUmask) {
#ifdef _WIN32
  EXPECT_EQ(fs::getUmask(), 0U) << "Should always be 0 on Windows.";
#else
  unsigned OldMask = ::umask(0022);
  unsigned CurrentMask = fs::getUmask();
  EXPECT_EQ(CurrentMask, 0022U)
      << "getUmask() didn't return previously set umask()";
  EXPECT_EQ(::umask(OldMask), mode_t(0022U))
      << "getUmask() may have changed umask()";
#endif
}

TEST_F(FileSystemTest, RespectUmask) {
#ifndef _WIN32
  unsigned OldMask = ::umask(0022);

  int FD;
  SmallString<128> TempPath;
  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath));

  fs::perms AllRWE = static_cast<fs::perms>(0777);

  ASSERT_NO_ERROR(fs::setPermissions(TempPath, AllRWE));

  ErrorOr<fs::perms> Perms = fs::getPermissions(TempPath);
  ASSERT_TRUE(!!Perms);
  EXPECT_EQ(Perms.get(), AllRWE) << "Should have ignored umask by default";

  ASSERT_NO_ERROR(fs::setPermissions(TempPath, AllRWE));

  Perms = fs::getPermissions(TempPath);
  ASSERT_TRUE(!!Perms);
  EXPECT_EQ(Perms.get(), AllRWE) << "Should have ignored umask";

  ASSERT_NO_ERROR(
      fs::setPermissions(FD, static_cast<fs::perms>(AllRWE & ~fs::getUmask())));
  Perms = fs::getPermissions(TempPath);
  ASSERT_TRUE(!!Perms);
  EXPECT_EQ(Perms.get(), static_cast<fs::perms>(0755))
      << "Did not respect umask";

  (void)::umask(0057);

  ASSERT_NO_ERROR(
      fs::setPermissions(FD, static_cast<fs::perms>(AllRWE & ~fs::getUmask())));
  Perms = fs::getPermissions(TempPath);
  ASSERT_TRUE(!!Perms);
  EXPECT_EQ(Perms.get(), static_cast<fs::perms>(0720))
      << "Did not respect umask";

  (void)::umask(OldMask);
  (void)::close(FD);
#endif
}

TEST_F(FileSystemTest, set_current_path) {
  SmallString<128> path;

  ASSERT_NO_ERROR(fs::current_path(path));
  ASSERT_NE(TestDirectory, path);

  struct RestorePath {
    SmallString<128> path;
    RestorePath(const SmallString<128> &path) : path(path) {}
    ~RestorePath() { fs::set_current_path(path); }
  } restore_path(path);

  ASSERT_NO_ERROR(fs::set_current_path(TestDirectory));

  ASSERT_NO_ERROR(fs::current_path(path));

  fs::UniqueID D1, D2;
  ASSERT_NO_ERROR(fs::getUniqueID(TestDirectory, D1));
  ASSERT_NO_ERROR(fs::getUniqueID(path, D2));
  ASSERT_EQ(D1, D2) << "D1: " << TestDirectory << "\nD2: " << path;
}

TEST_F(FileSystemTest, permissions) {
  int FD;
  SmallString<64> TempPath;
  ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath));
  FileRemover Cleanup(TempPath);

  // Make sure it exists.
  ASSERT_TRUE(fs::exists(Twine(TempPath)));

  auto CheckPermissions = [&](fs::perms Expected) {
    ErrorOr<fs::perms> Actual = fs::getPermissions(TempPath);
    return Actual && *Actual == Expected;
  };

  std::error_code NoError;
  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_all), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read | fs::all_exe), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_read | fs::all_exe));

#if defined(_WIN32)
  fs::perms ReadOnly = fs::all_read | fs::all_exe;
  EXPECT_EQ(fs::setPermissions(TempPath, fs::no_perms), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_read), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_write), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_exe), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_all), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_read), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_write), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_exe), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_all), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_read), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_write), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_exe), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_all), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_write), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_exe), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_gid_on_exe), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::sticky_bit), NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe |
                                             fs::set_gid_on_exe |
                                             fs::sticky_bit),
            NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, ReadOnly | fs::set_uid_on_exe |
                                             fs::set_gid_on_exe |
                                             fs::sticky_bit),
            NoError);
  EXPECT_TRUE(CheckPermissions(ReadOnly));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_all));
#else
  EXPECT_EQ(fs::setPermissions(TempPath, fs::no_perms), NoError);
  EXPECT_TRUE(CheckPermissions(fs::no_perms));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_read), NoError);
  EXPECT_TRUE(CheckPermissions(fs::owner_read));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_write), NoError);
  EXPECT_TRUE(CheckPermissions(fs::owner_write));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_exe), NoError);
  EXPECT_TRUE(CheckPermissions(fs::owner_exe));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_all), NoError);
  EXPECT_TRUE(CheckPermissions(fs::owner_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_read), NoError);
  EXPECT_TRUE(CheckPermissions(fs::group_read));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_write), NoError);
  EXPECT_TRUE(CheckPermissions(fs::group_write));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_exe), NoError);
  EXPECT_TRUE(CheckPermissions(fs::group_exe));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::group_all), NoError);
  EXPECT_TRUE(CheckPermissions(fs::group_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_read), NoError);
  EXPECT_TRUE(CheckPermissions(fs::others_read));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_write), NoError);
  EXPECT_TRUE(CheckPermissions(fs::others_write));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_exe), NoError);
  EXPECT_TRUE(CheckPermissions(fs::others_exe));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::others_all), NoError);
  EXPECT_TRUE(CheckPermissions(fs::others_all));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_read));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_write), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_write));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_exe), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_exe));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe), NoError);
  EXPECT_TRUE(CheckPermissions(fs::set_uid_on_exe));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_gid_on_exe), NoError);
  EXPECT_TRUE(CheckPermissions(fs::set_gid_on_exe));

  // Modern BSDs require root to set the sticky bit on files.
  // AIX and Solaris without root will mask off (i.e., lose) the sticky bit
  // on files.
#if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) &&  \
    !defined(_AIX) && !(defined(__sun__) && defined(__svr4__))
  EXPECT_EQ(fs::setPermissions(TempPath, fs::sticky_bit), NoError);
  EXPECT_TRUE(CheckPermissions(fs::sticky_bit));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe |
                                             fs::set_gid_on_exe |
                                             fs::sticky_bit),
            NoError);
  EXPECT_TRUE(CheckPermissions(fs::set_uid_on_exe | fs::set_gid_on_exe |
                               fs::sticky_bit));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read | fs::set_uid_on_exe |
                                             fs::set_gid_on_exe |
                                             fs::sticky_bit),
            NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_read | fs::set_uid_on_exe |
                               fs::set_gid_on_exe | fs::sticky_bit));

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms), NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_perms));
#endif // !FreeBSD && !NetBSD && !OpenBSD && !AIX

  EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms & ~fs::sticky_bit),
                               NoError);
  EXPECT_TRUE(CheckPermissions(fs::all_perms & ~fs::sticky_bit));
#endif
}

#ifdef _WIN32
TEST_F(FileSystemTest, widenPath) {
  const std::wstring LongPathPrefix(L"\\\\?\\");

  // Test that the length limit is checked against the UTF-16 length and not the
  // UTF-8 length.
  std::string Input("C:\\foldername\\");
  const std::string Pi("\xcf\x80"); // UTF-8 lower case pi.
  // Add Pi up to the MAX_PATH limit.
  const size_t NumChars = MAX_PATH - Input.size() - 1;
  for (size_t i = 0; i < NumChars; ++i)
    Input += Pi;
  // Check that UTF-8 length already exceeds MAX_PATH.
  EXPECT_GT(Input.size(), (size_t)MAX_PATH);
  SmallVector<wchar_t, MAX_PATH + 16> Result;
  ASSERT_NO_ERROR(windows::widenPath(Input, Result));
  // Result should not start with the long path prefix.
  EXPECT_TRUE(std::wmemcmp(Result.data(), LongPathPrefix.c_str(),
                           LongPathPrefix.size()) != 0);
  EXPECT_EQ(Result.size(), (size_t)MAX_PATH - 1);

  // Add another Pi to exceed the MAX_PATH limit.
  Input += Pi;
  // Construct the expected result.
  SmallVector<wchar_t, MAX_PATH + 16> Expected;
  ASSERT_NO_ERROR(windows::UTF8ToUTF16(Input, Expected));
  Expected.insert(Expected.begin(), LongPathPrefix.begin(),
                  LongPathPrefix.end());

  ASSERT_NO_ERROR(windows::widenPath(Input, Result));
  EXPECT_EQ(Result, Expected);
  // Pass a path with forward slashes, check that it ends up with
  // backslashes when widened with the long path prefix.
  SmallString<MAX_PATH + 16> InputForward(Input);
  path::make_preferred(InputForward, path::Style::windows_slash);
  ASSERT_NO_ERROR(windows::widenPath(InputForward, Result));
  EXPECT_EQ(Result, Expected);

  // Pass a path which has the long path prefix prepended originally, but
  // which is short enough to not require the long path prefix. If such a
  // path is passed with forward slashes, make sure it gets normalized to
  // backslashes.
  SmallString<MAX_PATH + 16> PrefixedPath("\\\\?\\C:\\foldername");
  ASSERT_NO_ERROR(windows::UTF8ToUTF16(PrefixedPath, Expected));
  // Mangle the input to forward slashes.
  path::make_preferred(PrefixedPath, path::Style::windows_slash);
  ASSERT_NO_ERROR(windows::widenPath(PrefixedPath, Result));
  EXPECT_EQ(Result, Expected);

  // A short path with an inconsistent prefix is passed through as-is; this
  // is a degenerate case that we currently don't care about handling.
  PrefixedPath.assign("/\\?/C:/foldername");
  ASSERT_NO_ERROR(windows::UTF8ToUTF16(PrefixedPath, Expected));
  ASSERT_NO_ERROR(windows::widenPath(PrefixedPath, Result));
  EXPECT_EQ(Result, Expected);

  // Test that UNC paths are handled correctly.
  const std::string ShareName("\\\\sharename\\");
  const std::string FileName("\\filename");
  // Initialize directory name so that the input is within the MAX_PATH limit.
  const char DirChar = 'x';
  std::string DirName(MAX_PATH - ShareName.size() - FileName.size() - 1,
                      DirChar);

  Input = ShareName + DirName + FileName;
  ASSERT_NO_ERROR(windows::widenPath(Input, Result));
  // Result should not start with the long path prefix.
  EXPECT_TRUE(std::wmemcmp(Result.data(), LongPathPrefix.c_str(),
                           LongPathPrefix.size()) != 0);
  EXPECT_EQ(Result.size(), (size_t)MAX_PATH - 1);

  // Extend the directory name so the input exceeds the MAX_PATH limit.
  DirName += DirChar;
  Input = ShareName + DirName + FileName;
  // Construct the expected result.
  ASSERT_NO_ERROR(windows::UTF8ToUTF16(StringRef(Input).substr(2), Expected));
  const std::wstring UNCPrefix(LongPathPrefix + L"UNC\\");
  Expected.insert(Expected.begin(), UNCPrefix.begin(), UNCPrefix.end());

  ASSERT_NO_ERROR(windows::widenPath(Input, Result));
  EXPECT_EQ(Result, Expected);

  // Check that Unix separators are handled correctly.
  std::replace(Input.begin(), Input.end(), '\\', '/');
  ASSERT_NO_ERROR(windows::widenPath(Input, Result));
  EXPECT_EQ(Result, Expected);

  // Check the removal of "dots".
  Input = ShareName + DirName + "\\.\\foo\\.\\.." + FileName;
  ASSERT_NO_ERROR(windows::widenPath(Input, Result));
  EXPECT_EQ(Result, Expected);
}
#endif

#ifdef _WIN32
// Windows refuses lock request if file region is already locked by the same
// process. POSIX system in this case updates the existing lock.
TEST_F(FileSystemTest, FileLocker) {
  using namespace std::chrono;
  int FD;
  std::error_code EC;
  SmallString<64> TempPath;
  EC = fs::createTemporaryFile("test", "temp", FD, TempPath);
  ASSERT_NO_ERROR(EC);
  FileRemover Cleanup(TempPath);
  raw_fd_ostream Stream(TempPath, EC);

  EC = fs::tryLockFile(FD);
  ASSERT_NO_ERROR(EC);
  EC = fs::unlockFile(FD);
  ASSERT_NO_ERROR(EC);

  if (auto L = Stream.lock()) {
    ASSERT_ERROR(fs::tryLockFile(FD));
    ASSERT_NO_ERROR(L->unlock());
    ASSERT_NO_ERROR(fs::tryLockFile(FD));
    ASSERT_NO_ERROR(fs::unlockFile(FD));
  } else {
    ADD_FAILURE();
    handleAllErrors(L.takeError(), [&](ErrorInfoBase &EIB) {});
  }

  ASSERT_NO_ERROR(fs::tryLockFile(FD));
  ASSERT_NO_ERROR(fs::unlockFile(FD));

  {
    Expected<fs::FileLocker> L1 = Stream.lock();
    ASSERT_THAT_EXPECTED(L1, Succeeded());
    raw_fd_ostream Stream2(FD, false);
    Expected<fs::FileLocker> L2 = Stream2.tryLockFor(250ms);
    ASSERT_THAT_EXPECTED(L2, Failed());
    ASSERT_NO_ERROR(L1->unlock());
    Expected<fs::FileLocker> L3 = Stream.tryLockFor(0ms);
    ASSERT_THAT_EXPECTED(L3, Succeeded());
  }

  ASSERT_NO_ERROR(fs::tryLockFile(FD));
  ASSERT_NO_ERROR(fs::unlockFile(FD));
}
#endif

TEST_F(FileSystemTest, CopyFile) {
  unittest::TempDir RootTestDirectory("CopyFileTest", /*Unique=*/true);

  SmallVector<std::string> Data;
  SmallVector<SmallString<128>> Sources;
  for (int I = 0, E = 3; I != E; ++I) {
    Data.push_back(Twine(I).str());
    Sources.emplace_back(RootTestDirectory.path());
    path::append(Sources.back(), "source" + Data.back() + ".txt");
    createFileWithData(Sources.back(), /*ShouldExistBefore=*/false,
                       fs::CD_CreateNew, Data.back());
  }

  // Copy the first file to a non-existing file.
  SmallString<128> Destination(RootTestDirectory.path());
  path::append(Destination, "destination");
  ASSERT_FALSE(fs::exists(Destination));
  fs::copy_file(Sources[0], Destination);
  verifyFileContents(Destination, Data[0]);

  // Copy the second file to an existing file.
  fs::copy_file(Sources[1], Destination);
  verifyFileContents(Destination, Data[1]);

  // Note: The remaining logic is targeted at a potential failure case related
  // to file cloning and symlinks on Darwin. On Windows, fs::create_link() does
  // not return success here so the test is skipped.
#if !defined(_WIN32)
  // Set up a symlink to the third file.
  SmallString<128> Symlink(RootTestDirectory.path());
  path::append(Symlink, "symlink");
  ASSERT_NO_ERROR(fs::create_link(path::filename(Sources[2]), Symlink));
  verifyFileContents(Symlink, Data[2]);

  // fs::getUniqueID() should follow symlinks. Otherwise, this isn't good test
  // coverage.
  fs::UniqueID SymlinkID;
  fs::UniqueID Data2ID;
  ASSERT_NO_ERROR(fs::getUniqueID(Symlink, SymlinkID));
  ASSERT_NO_ERROR(fs::getUniqueID(Sources[2], Data2ID));
  ASSERT_EQ(SymlinkID, Data2ID);

  // Copy the third file through the symlink.
  fs::copy_file(Symlink, Destination);
  verifyFileContents(Destination, Data[2]);

  // Confirm the destination is not a link to the original file, and not a
  // symlink.
  bool IsDestinationSymlink;
  ASSERT_NO_ERROR(fs::is_symlink_file(Destination, IsDestinationSymlink));
  ASSERT_FALSE(IsDestinationSymlink);
  fs::UniqueID DestinationID;
  ASSERT_NO_ERROR(fs::getUniqueID(Destination, DestinationID));
  ASSERT_NE(SymlinkID, DestinationID);
#endif
}

} // anonymous namespace