unittests/Support/Path.cpp

   1 //===- llvm/unittest/Support/Path.cpp - Path tests ------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/Support/Path.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/ADT/SmallVector.h"
  13 #include "llvm/ADT/Triple.h"
  14 #include "llvm/BinaryFormat/Magic.h"
  15 #include "llvm/Support/ConvertUTF.h"
  16 #include "llvm/Support/Errc.h"
  17 #include "llvm/Support/ErrorHandling.h"
  18 #include "llvm/Support/FileSystem.h"
  19 #include "llvm/Support/FileUtilities.h"
  20 #include "llvm/Support/Host.h"
  21 #include "llvm/Support/MemoryBuffer.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 #include "gtest/gtest.h"
  24
  25 #ifdef LLVM_ON_WIN32
  26 #include "llvm/ADT/ArrayRef.h"
  27 #include <windows.h>
  28 #include <winerror.h>
  29 #endif
  30
  31 #ifdef LLVM_ON_UNIX
  32 #include <pwd.h>
  33 #include <sys/stat.h>
  34 #endif
  35
  36 using namespace llvm;
  37 using namespace llvm::sys;
  38
  39 #define ASSERT_NO_ERROR(x)                                                     \
  40   if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
  41     SmallString<128> MessageStorage;                                           \
  42     raw_svector_ostream Message(MessageStorage);                               \
  43     Message << #x ": did not return errc::success.\n"                          \
  44             << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
  45             << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
  46     GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
  47   } else {                                                                     \
  48   }
  49
  50 namespace {
  51
  52 TEST(is_separator, Works) {
  53   EXPECT_TRUE(path::is_separator('/'));
  54   EXPECT_FALSE(path::is_separator('\0'));
  55   EXPECT_FALSE(path::is_separator('-'));
  56   EXPECT_FALSE(path::is_separator(' '));
  57
  58   EXPECT_TRUE(path::is_separator('\\', path::Style::windows));
  59   EXPECT_FALSE(path::is_separator('\\', path::Style::posix));
  60
  61 #ifdef LLVM_ON_WIN32
  62   EXPECT_TRUE(path::is_separator('\\'));
  63 #else
  64   EXPECT_FALSE(path::is_separator('\\'));
  65 #endif
  66 }
  67
  68 TEST(Support, Path) {
  69   SmallVector<StringRef, 40> paths;
  70   paths.push_back("");
  71   paths.push_back(".");
  72   paths.push_back("..");
  73   paths.push_back("foo");
  74   paths.push_back("/");
  75   paths.push_back("/foo");
  76   paths.push_back("foo/");
  77   paths.push_back("/foo/");
  78   paths.push_back("foo/bar");
  79   paths.push_back("/foo/bar");
  80   paths.push_back("//net");
  81   paths.push_back("//net/foo");
  82   paths.push_back("///foo///");
  83   paths.push_back("///foo///bar");
  84   paths.push_back("/.");
  85   paths.push_back("./");
  86   paths.push_back("/..");
  87   paths.push_back("../");
  88   paths.push_back("foo/.");
  89   paths.push_back("foo/..");
  90   paths.push_back("foo/./");
  91   paths.push_back("foo/./bar");
  92   paths.push_back("foo/..");
  93   paths.push_back("foo/../");
  94   paths.push_back("foo/../bar");
  95   paths.push_back("c:");
  96   paths.push_back("c:/");
  97   paths.push_back("c:foo");
  98   paths.push_back("c:/foo");
  99   paths.push_back("c:foo/");
 100   paths.push_back("c:/foo/");
 101   paths.push_back("c:/foo/bar");
 102   paths.push_back("prn:");
 103   paths.push_back("c:\\");
 104   paths.push_back("c:foo");
 105   paths.push_back("c:\\foo");
 106   paths.push_back("c:foo\\");
 107   paths.push_back("c:\\foo\\");
 108   paths.push_back("c:\\foo/");
 109   paths.push_back("c:/foo\\bar");
 110
 111   SmallVector<StringRef, 5> ComponentStack;
 112   for (SmallVector<StringRef, 40>::const_iterator i = paths.begin(),
 113                                                   e = paths.end();
 114                                                   i != e;
 115                                                   ++i) {
 116     for (sys::path::const_iterator ci = sys::path::begin(*i),
 117                                    ce = sys::path::end(*i);
 118                                    ci != ce;
 119                                    ++ci) {
 120       ASSERT_FALSE(ci->empty());
 121       ComponentStack.push_back(*ci);
 122     }
 123
 124     for (sys::path::reverse_iterator ci = sys::path::rbegin(*i),
 125                                      ce = sys::path::rend(*i);
 126                                      ci != ce;
 127                                      ++ci) {
 128       ASSERT_TRUE(*ci == ComponentStack.back());
 129       ComponentStack.pop_back();
 130     }
 131     ASSERT_TRUE(ComponentStack.empty());
 132
 133     // Crash test most of the API - since we're iterating over all of our paths
 134     // here there isn't really anything reasonable to assert on in the results.
 135     (void)path::has_root_path(*i);
 136     (void)path::root_path(*i);
 137     (void)path::has_root_name(*i);
 138     (void)path::root_name(*i);
 139     (void)path::has_root_directory(*i);
 140     (void)path::root_directory(*i);
 141     (void)path::has_parent_path(*i);
 142     (void)path::parent_path(*i);
 143     (void)path::has_filename(*i);
 144     (void)path::filename(*i);
 145     (void)path::has_stem(*i);
 146     (void)path::stem(*i);
 147     (void)path::has_extension(*i);
 148     (void)path::extension(*i);
 149     (void)path::is_absolute(*i);
 150     (void)path::is_relative(*i);
 151
 152     SmallString<128> temp_store;
 153     temp_store = *i;
 154     ASSERT_NO_ERROR(fs::make_absolute(temp_store));
 155     temp_store = *i;
 156     path::remove_filename(temp_store);
 157
 158     temp_store = *i;
 159     path::replace_extension(temp_store, "ext");
 160     StringRef filename(temp_store.begin(), temp_store.size()), stem, ext;
 161     stem = path::stem(filename);
 162     ext  = path::extension(filename);
 163     EXPECT_EQ(*sys::path::rbegin(filename), (stem + ext).str());
 164
 165     path::native(*i, temp_store);
 166   }
 167
 168   SmallString<32> Relative("foo.cpp");
 169   ASSERT_NO_ERROR(sys::fs::make_absolute("/root", Relative));
 170   Relative[5] = '/'; // Fix up windows paths.
 171   ASSERT_EQ("/root/foo.cpp", Relative);
 172 }
 173
 174 TEST(Support, RelativePathIterator) {
 175   SmallString<64> Path(StringRef("c/d/e/foo.txt"));
 176   typedef SmallVector<StringRef, 4> PathComponents;
 177   PathComponents ExpectedPathComponents;
 178   PathComponents ActualPathComponents;
 179
 180   StringRef(Path).split(ExpectedPathComponents, '/');
 181
 182   for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
 183        ++I) {
 184     ActualPathComponents.push_back(*I);
 185   }
 186
 187   ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
 188
 189   for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
 190     EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
 191   }
 192 }
 193
 194 TEST(Support, RelativePathDotIterator) {
 195   SmallString<64> Path(StringRef(".c/.d/../."));
 196   typedef SmallVector<StringRef, 4> PathComponents;
 197   PathComponents ExpectedPathComponents;
 198   PathComponents ActualPathComponents;
 199
 200   StringRef(Path).split(ExpectedPathComponents, '/');
 201
 202   for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
 203        ++I) {
 204     ActualPathComponents.push_back(*I);
 205   }
 206
 207   ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
 208
 209   for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
 210     EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
 211   }
 212 }
 213
 214 TEST(Support, AbsolutePathIterator) {
 215   SmallString<64> Path(StringRef("/c/d/e/foo.txt"));
 216   typedef SmallVector<StringRef, 4> PathComponents;
 217   PathComponents ExpectedPathComponents;
 218   PathComponents ActualPathComponents;
 219
 220   StringRef(Path).split(ExpectedPathComponents, '/');
 221
 222   // The root path will also be a component when iterating
 223   ExpectedPathComponents[0] = "/";
 224
 225   for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
 226        ++I) {
 227     ActualPathComponents.push_back(*I);
 228   }
 229
 230   ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
 231
 232   for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
 233     EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
 234   }
 235 }
 236
 237 TEST(Support, AbsolutePathDotIterator) {
 238   SmallString<64> Path(StringRef("/.c/.d/../."));
 239   typedef SmallVector<StringRef, 4> PathComponents;
 240   PathComponents ExpectedPathComponents;
 241   PathComponents ActualPathComponents;
 242
 243   StringRef(Path).split(ExpectedPathComponents, '/');
 244
 245   // The root path will also be a component when iterating
 246   ExpectedPathComponents[0] = "/";
 247
 248   for (path::const_iterator I = path::begin(Path), E = path::end(Path); I != E;
 249        ++I) {
 250     ActualPathComponents.push_back(*I);
 251   }
 252
 253   ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
 254
 255   for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
 256     EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
 257   }
 258 }
 259
 260 TEST(Support, AbsolutePathIteratorWin32) {
 261   SmallString<64> Path(StringRef("c:\\c\\e\\foo.txt"));
 262   typedef SmallVector<StringRef, 4> PathComponents;
 263   PathComponents ExpectedPathComponents;
 264   PathComponents ActualPathComponents;
 265
 266   StringRef(Path).split(ExpectedPathComponents, "\\");
 267
 268   // The root path (which comes after the drive name) will also be a component
 269   // when iterating.
 270   ExpectedPathComponents.insert(ExpectedPathComponents.begin()+1, "\\");
 271
 272   for (path::const_iterator I = path::begin(Path, path::Style::windows),
 273                             E = path::end(Path);
 274        I != E; ++I) {
 275     ActualPathComponents.push_back(*I);
 276   }
 277
 278   ASSERT_EQ(ExpectedPathComponents.size(), ActualPathComponents.size());
 279
 280   for (size_t i = 0; i <ExpectedPathComponents.size(); ++i) {
 281     EXPECT_EQ(ExpectedPathComponents[i].str(), ActualPathComponents[i].str());
 282   }
 283 }
 284
 285 TEST(Support, AbsolutePathIteratorEnd) {
 286   // Trailing slashes are converted to '.' unless they are part of the root path.
 287   SmallVector<std::pair<StringRef, path::Style>, 4> Paths;
 288   Paths.emplace_back("/foo/", path::Style::native);
 289   Paths.emplace_back("/foo//", path::Style::native);
 290   Paths.emplace_back("//net//", path::Style::native);
 291   Paths.emplace_back("c:\\\\", path::Style::windows);
 292
 293   for (auto &Path : Paths) {
 294     StringRef LastComponent = *path::rbegin(Path.first, Path.second);
 295     EXPECT_EQ(".", LastComponent);
 296   }
 297
 298   SmallVector<std::pair<StringRef, path::Style>, 3> RootPaths;
 299   RootPaths.emplace_back("/", path::Style::native);
 300   RootPaths.emplace_back("//net/", path::Style::native);
 301   RootPaths.emplace_back("c:\\", path::Style::windows);
 302
 303   for (auto &Path : RootPaths) {
 304     StringRef LastComponent = *path::rbegin(Path.first, Path.second);
 305     EXPECT_EQ(1u, LastComponent.size());
 306     EXPECT_TRUE(path::is_separator(LastComponent[0], Path.second));
 307   }
 308 }
 309
 310 TEST(Support, HomeDirectory) {
 311   std::string expected;
 312 #ifdef LLVM_ON_WIN32
 313   if (wchar_t const *path = ::_wgetenv(L"USERPROFILE")) {
 314     auto pathLen = ::wcslen(path);
 315     ArrayRef<char> ref{reinterpret_cast<char const *>(path),
 316                        pathLen * sizeof(wchar_t)};
 317     convertUTF16ToUTF8String(ref, expected);
 318   }
 319 #else
 320   if (char const *path = ::getenv("HOME"))
 321     expected = path;
 322 #endif
 323   // Do not try to test it if we don't know what to expect.
 324   // On Windows we use something better than env vars.
 325   if (!expected.empty()) {
 326     SmallString<128> HomeDir;
 327     auto status = path::home_directory(HomeDir);
 328     EXPECT_TRUE(status);
 329     EXPECT_EQ(expected, HomeDir);
 330   }
 331 }
 332
 333 #ifdef LLVM_ON_UNIX
 334 TEST(Support, HomeDirectoryWithNoEnv) {
 335   std::string OriginalStorage;
 336   char const *OriginalEnv = ::getenv("HOME");
 337   if (OriginalEnv) {
 338     // We're going to unset it, so make a copy and save a pointer to the copy
 339     // so that we can reset it at the end of the test.
 340     OriginalStorage = OriginalEnv;
 341     OriginalEnv = OriginalStorage.c_str();
 342   }
 343
 344   // Don't run the test if we have nothing to compare against.
 345   struct passwd *pw = getpwuid(getuid());
 346   if (!pw || !pw->pw_dir) return;
 347
 348   ::unsetenv("HOME");
 349   EXPECT_EQ(nullptr, ::getenv("HOME"));
 350   std::string PwDir = pw->pw_dir;
 351
 352   SmallString<128> HomeDir;
 353   auto status = path::home_directory(HomeDir);
 354   EXPECT_TRUE(status);
 355   EXPECT_EQ(PwDir, HomeDir);
 356
 357   // Now put the environment back to its original state (meaning that if it was
 358   // unset before, we don't reset it).
 359   if (OriginalEnv) ::setenv("HOME", OriginalEnv, 1);
 360 }
 361 #endif
 362
 363 TEST(Support, UserCacheDirectory) {
 364   SmallString<13> CacheDir;
 365   SmallString<20> CacheDir2;
 366   auto Status = path::user_cache_directory(CacheDir, "");
 367   EXPECT_TRUE(Status ^ CacheDir.empty());
 368
 369   if (Status) {
 370     EXPECT_TRUE(path::user_cache_directory(CacheDir2, "")); // should succeed
 371     EXPECT_EQ(CacheDir, CacheDir2); // and return same paths
 372
 373     EXPECT_TRUE(path::user_cache_directory(CacheDir, "A", "B", "file.c"));
 374     auto It = path::rbegin(CacheDir);
 375     EXPECT_EQ("file.c", *It);
 376     EXPECT_EQ("B", *++It);
 377     EXPECT_EQ("A", *++It);
 378     auto ParentDir = *++It;
 379
 380     // Test Unicode: "<user_cache_dir>/(pi)r^2/aleth.0"
 381     EXPECT_TRUE(path::user_cache_directory(CacheDir2, "\xCF\x80r\xC2\xB2",
 382                                            "\xE2\x84\xB5.0"));
 383     auto It2 = path::rbegin(CacheDir2);
 384     EXPECT_EQ("\xE2\x84\xB5.0", *It2);
 385     EXPECT_EQ("\xCF\x80r\xC2\xB2", *++It2);
 386     auto ParentDir2 = *++It2;
 387
 388     EXPECT_EQ(ParentDir, ParentDir2);
 389   }
 390 }
 391
 392 TEST(Support, TempDirectory) {
 393   SmallString<32> TempDir;
 394   path::system_temp_directory(false, TempDir);
 395   EXPECT_TRUE(!TempDir.empty());
 396   TempDir.clear();
 397   path::system_temp_directory(true, TempDir);
 398   EXPECT_TRUE(!TempDir.empty());
 399 }
 400
 401 #ifdef LLVM_ON_WIN32
 402 static std::string path2regex(std::string Path) {
 403   size_t Pos = 0;
 404   while ((Pos = Path.find('\\', Pos)) != std::string::npos) {
 405     Path.replace(Pos, 1, "\\\\");
 406     Pos += 2;
 407   }
 408   return Path;
 409 }
 410
 411 /// Helper for running temp dir test in separated process. See below.
 412 #define EXPECT_TEMP_DIR(prepare, expected)                                     \
 413   EXPECT_EXIT(                                                                 \
 414       {                                                                        \
 415         prepare;                                                               \
 416         SmallString<300> TempDir;                                              \
 417         path::system_temp_directory(true, TempDir);                            \
 418         raw_os_ostream(std::cerr) << TempDir;                                  \
 419         std::exit(0);                                                          \
 420       },                                                                       \
 421       ::testing::ExitedWithCode(0), path2regex(expected))
 422
 423 TEST(SupportDeathTest, TempDirectoryOnWindows) {
 424   // In this test we want to check how system_temp_directory responds to
 425   // different values of specific env vars. To prevent corrupting env vars of
 426   // the current process all checks are done in separated processes.
 427   EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"C:\\OtherFolder"), "C:\\OtherFolder");
 428   EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"C:/Unix/Path/Seperators"),
 429                   "C:\\Unix\\Path\\Seperators");
 430   EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"Local Path"), ".+\\Local Path$");
 431   EXPECT_TEMP_DIR(_wputenv_s(L"TMP", L"F:\\TrailingSep\\"), "F:\\TrailingSep");
 432   EXPECT_TEMP_DIR(
 433       _wputenv_s(L"TMP", L"C:\\2\x03C0r-\x00B5\x00B3\\\x2135\x2080"),
 434       "C:\\2\xCF\x80r-\xC2\xB5\xC2\xB3\\\xE2\x84\xB5\xE2\x82\x80");
 435
 436   // Test $TMP empty, $TEMP set.
 437   EXPECT_TEMP_DIR(
 438       {
 439         _wputenv_s(L"TMP", L"");
 440         _wputenv_s(L"TEMP", L"C:\\Valid\\Path");
 441       },
 442       "C:\\Valid\\Path");
 443
 444   // All related env vars empty
 445   EXPECT_TEMP_DIR(
 446   {
 447     _wputenv_s(L"TMP", L"");
 448     _wputenv_s(L"TEMP", L"");
 449     _wputenv_s(L"USERPROFILE", L"");
 450   },
 451     "C:\\Temp");
 452
 453   // Test evn var / path with 260 chars.
 454   SmallString<270> Expected{"C:\\Temp\\AB\\123456789"};
 455   while (Expected.size() < 260)
 456     Expected.append("\\DirNameWith19Charss");
 457   ASSERT_EQ(260U, Expected.size());
 458   EXPECT_TEMP_DIR(_putenv_s("TMP", Expected.c_str()), Expected.c_str());
 459 }
 460 #endif
 461
 462 class FileSystemTest : public testing::Test {
 463 protected:
 464   /// Unique temporary directory in which all created filesystem entities must
 465   /// be placed. It is removed at the end of each test (must be empty).
 466   SmallString<128> TestDirectory;
 467
 468   void SetUp() override {
 469     ASSERT_NO_ERROR(
 470         fs::createUniqueDirectory("file-system-test", TestDirectory));
 471     // We don't care about this specific file.
 472     errs() << "Test Directory: " << TestDirectory << '\n';
 473     errs().flush();
 474   }
 475
 476   void TearDown() override { ASSERT_NO_ERROR(fs::remove(TestDirectory.str())); }
 477 };
 478
 479 TEST_F(FileSystemTest, Unique) {
 480   // Create a temp file.
 481   int FileDescriptor;
 482   SmallString<64> TempPath;
 483   ASSERT_NO_ERROR(
 484       fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));
 485
 486   // The same file should return an identical unique id.
 487   fs::UniqueID F1, F2;
 488   ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), F1));
 489   ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), F2));
 490   ASSERT_EQ(F1, F2);
 491
 492   // Different files should return different unique ids.
 493   int FileDescriptor2;
 494   SmallString<64> TempPath2;
 495   ASSERT_NO_ERROR(
 496       fs::createTemporaryFile("prefix", "temp", FileDescriptor2, TempPath2));
 497
 498   fs::UniqueID D;
 499   ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath2), D));
 500   ASSERT_NE(D, F1);
 501   ::close(FileDescriptor2);
 502
 503   ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));
 504
 505   // Two paths representing the same file on disk should still provide the
 506   // same unique id.  We can test this by making a hard link.
 507   ASSERT_NO_ERROR(fs::create_link(Twine(TempPath), Twine(TempPath2)));
 508   fs::UniqueID D2;
 509   ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath2), D2));
 510   ASSERT_EQ(D2, F1);
 511
 512   ::close(FileDescriptor);
 513
 514   SmallString<128> Dir1;
 515   ASSERT_NO_ERROR(
 516      fs::createUniqueDirectory("dir1", Dir1));
 517   ASSERT_NO_ERROR(fs::getUniqueID(Dir1.c_str(), F1));
 518   ASSERT_NO_ERROR(fs::getUniqueID(Dir1.c_str(), F2));
 519   ASSERT_EQ(F1, F2);
 520
 521   SmallString<128> Dir2;
 522   ASSERT_NO_ERROR(
 523      fs::createUniqueDirectory("dir2", Dir2));
 524   ASSERT_NO_ERROR(fs::getUniqueID(Dir2.c_str(), F2));
 525   ASSERT_NE(F1, F2);
 526   ASSERT_NO_ERROR(fs::remove(Dir1));
 527   ASSERT_NO_ERROR(fs::remove(Dir2));
 528   ASSERT_NO_ERROR(fs::remove(TempPath2));
 529   ASSERT_NO_ERROR(fs::remove(TempPath));
 530 }
 531
 532 TEST_F(FileSystemTest, RealPath) {
 533   ASSERT_NO_ERROR(
 534       fs::create_directories(Twine(TestDirectory) + "/test1/test2/test3"));
 535   ASSERT_TRUE(fs::exists(Twine(TestDirectory) + "/test1/test2/test3"));
 536
 537   SmallString<64> RealBase;
 538   SmallString<64> Expected;
 539   SmallString<64> Actual;
 540
 541   // TestDirectory itself might be under a symlink or have been specified with
 542   // a different case than the existing temp directory.  In such cases real_path
 543   // on the concatenated path will differ in the TestDirectory portion from
 544   // how we specified it.  Make sure to compare against the real_path of the
 545   // TestDirectory, and not just the value of TestDirectory.
 546   ASSERT_NO_ERROR(fs::real_path(TestDirectory, RealBase));
 547   path::native(Twine(RealBase) + "/test1/test2", Expected);
 548
 549   ASSERT_NO_ERROR(fs::real_path(
 550       Twine(TestDirectory) + "/././test1/../test1/test2/./test3/..", Actual));
 551
 552   EXPECT_EQ(Expected, Actual);
 553
 554   SmallString<64> HomeDir;
 555   bool Result = llvm::sys::path::home_directory(HomeDir);
 556   if (Result) {
 557     ASSERT_NO_ERROR(fs::real_path(HomeDir, Expected));
 558     ASSERT_NO_ERROR(fs::real_path("~", Actual, true));
 559     EXPECT_EQ(Expected, Actual);
 560     ASSERT_NO_ERROR(fs::real_path("~/", Actual, true));
 561     EXPECT_EQ(Expected, Actual);
 562   }
 563
 564   ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) + "/test1"));
 565 }
 566
 567 #ifdef LLVM_ON_UNIX
 568 TEST_F(FileSystemTest, RealPathNoReadPerm) {
 569   SmallString<64> Expanded;
 570
 571   ASSERT_NO_ERROR(
 572     fs::create_directories(Twine(TestDirectory) + "/noreadperm"));
 573   ASSERT_TRUE(fs::exists(Twine(TestDirectory) + "/noreadperm"));
 574
 575   fs::setPermissions(Twine(TestDirectory) + "/noreadperm", fs::no_perms);
 576   fs::setPermissions(Twine(TestDirectory) + "/noreadperm", fs::all_exe);
 577
 578   ASSERT_NO_ERROR(fs::real_path(Twine(TestDirectory) + "/noreadperm", Expanded,
 579                                 false));
 580
 581   ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) + "/noreadperm"));
 582 }
 583 #endif
 584
 585
 586 TEST_F(FileSystemTest, TempFileKeepDiscard) {
 587   // We can keep then discard.
 588   auto TempFileOrError = fs::TempFile::create(TestDirectory + "/test-%%%%");
 589   ASSERT_TRUE((bool)TempFileOrError);
 590   fs::TempFile File = std::move(*TempFileOrError);
 591   ASSERT_FALSE((bool)File.keep(TestDirectory + "/keep"));
 592   ASSERT_FALSE((bool)File.discard());
 593   ASSERT_TRUE(fs::exists(TestDirectory + "/keep"));
 594   ASSERT_NO_ERROR(fs::remove(TestDirectory + "/keep"));
 595 }
 596
 597 TEST_F(FileSystemTest, TempFileDiscardDiscard) {
 598   // We can discard twice.
 599   auto TempFileOrError = fs::TempFile::create(TestDirectory + "/test-%%%%");
 600   ASSERT_TRUE((bool)TempFileOrError);
 601   fs::TempFile File = std::move(*TempFileOrError);
 602   ASSERT_FALSE((bool)File.discard());
 603   ASSERT_FALSE((bool)File.discard());
 604   ASSERT_FALSE(fs::exists(TestDirectory + "/keep"));
 605 }
 606
 607 TEST_F(FileSystemTest, TempFiles) {
 608   // Create a temp file.
 609   int FileDescriptor;
 610   SmallString<64> TempPath;
 611   ASSERT_NO_ERROR(
 612       fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));
 613
 614   // Make sure it exists.
 615   ASSERT_TRUE(sys::fs::exists(Twine(TempPath)));
 616
 617   // Create another temp tile.
 618   int FD2;
 619   SmallString<64> TempPath2;
 620   ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD2, TempPath2));
 621   ASSERT_TRUE(TempPath2.endswith(".temp"));
 622   ASSERT_NE(TempPath.str(), TempPath2.str());
 623
 624   fs::file_status A, B;
 625   ASSERT_NO_ERROR(fs::status(Twine(TempPath), A));
 626   ASSERT_NO_ERROR(fs::status(Twine(TempPath2), B));
 627   EXPECT_FALSE(fs::equivalent(A, B));
 628
 629   ::close(FD2);
 630
 631   // Remove Temp2.
 632   ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));
 633   ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));
 634   ASSERT_EQ(fs::remove(Twine(TempPath2), false),
 635             errc::no_such_file_or_directory);
 636
 637   std::error_code EC = fs::status(TempPath2.c_str(), B);
 638   EXPECT_EQ(EC, errc::no_such_file_or_directory);
 639   EXPECT_EQ(B.type(), fs::file_type::file_not_found);
 640
 641   // Make sure Temp2 doesn't exist.
 642   ASSERT_EQ(fs::access(Twine(TempPath2), sys::fs::AccessMode::Exist),
 643             errc::no_such_file_or_directory);
 644
 645   SmallString<64> TempPath3;
 646   ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "", TempPath3));
 647   ASSERT_FALSE(TempPath3.endswith("."));
 648   FileRemover Cleanup3(TempPath3);
 649
 650   // Create a hard link to Temp1.
 651   ASSERT_NO_ERROR(fs::create_link(Twine(TempPath), Twine(TempPath2)));
 652   bool equal;
 653   ASSERT_NO_ERROR(fs::equivalent(Twine(TempPath), Twine(TempPath2), equal));
 654   EXPECT_TRUE(equal);
 655   ASSERT_NO_ERROR(fs::status(Twine(TempPath), A));
 656   ASSERT_NO_ERROR(fs::status(Twine(TempPath2), B));
 657   EXPECT_TRUE(fs::equivalent(A, B));
 658
 659   // Remove Temp1.
 660   ::close(FileDescriptor);
 661   ASSERT_NO_ERROR(fs::remove(Twine(TempPath)));
 662
 663   // Remove the hard link.
 664   ASSERT_NO_ERROR(fs::remove(Twine(TempPath2)));
 665
 666   // Make sure Temp1 doesn't exist.
 667   ASSERT_EQ(fs::access(Twine(TempPath), sys::fs::AccessMode::Exist),
 668             errc::no_such_file_or_directory);
 669
 670 #ifdef LLVM_ON_WIN32
 671   // Path name > 260 chars should get an error.
 672   const char *Path270 =
 673     "abcdefghijklmnopqrstuvwxyz9abcdefghijklmnopqrstuvwxyz8"
 674     "abcdefghijklmnopqrstuvwxyz7abcdefghijklmnopqrstuvwxyz6"
 675     "abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz4"
 676     "abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz2"
 677     "abcdefghijklmnopqrstuvwxyz1abcdefghijklmnopqrstuvwxyz0";
 678   EXPECT_EQ(fs::createUniqueFile(Path270, FileDescriptor, TempPath),
 679             errc::invalid_argument);
 680   // Relative path < 247 chars, no problem.
 681   const char *Path216 =
 682     "abcdefghijklmnopqrstuvwxyz7abcdefghijklmnopqrstuvwxyz6"
 683     "abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz4"
 684     "abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz2"
 685     "abcdefghijklmnopqrstuvwxyz1abcdefghijklmnopqrstuvwxyz0";
 686   ASSERT_NO_ERROR(fs::createTemporaryFile(Path216, "", TempPath));
 687   ASSERT_NO_ERROR(fs::remove(Twine(TempPath)));
 688 #endif
 689 }
 690
 691 TEST_F(FileSystemTest, CreateDir) {
 692   ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "foo"));
 693   ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "foo"));
 694   ASSERT_EQ(fs::create_directory(Twine(TestDirectory) + "foo", false),
 695             errc::file_exists);
 696   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "foo"));
 697
 698 #ifdef LLVM_ON_UNIX
 699   // Set a 0000 umask so that we can test our directory permissions.
 700   mode_t OldUmask = ::umask(0000);
 701
 702   fs::file_status Status;
 703   ASSERT_NO_ERROR(
 704       fs::create_directory(Twine(TestDirectory) + "baz500", false,
 705                            fs::perms::owner_read | fs::perms::owner_exe));
 706   ASSERT_NO_ERROR(fs::status(Twine(TestDirectory) + "baz500", Status));
 707   ASSERT_EQ(Status.permissions() & fs::perms::all_all,
 708             fs::perms::owner_read | fs::perms::owner_exe);
 709   ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "baz777", false,
 710                                        fs::perms::all_all));
 711   ASSERT_NO_ERROR(fs::status(Twine(TestDirectory) + "baz777", Status));
 712   ASSERT_EQ(Status.permissions() & fs::perms::all_all, fs::perms::all_all);
 713
 714   // Restore umask to be safe.
 715   ::umask(OldUmask);
 716 #endif
 717
 718 #ifdef LLVM_ON_WIN32
 719   // Prove that create_directories() can handle a pathname > 248 characters,
 720   // which is the documented limit for CreateDirectory().
 721   // (248 is MAX_PATH subtracting room for an 8.3 filename.)
 722   // Generate a directory path guaranteed to fall into that range.
 723   size_t TmpLen = TestDirectory.size();
 724   const char *OneDir = "\\123456789";
 725   size_t OneDirLen = strlen(OneDir);
 726   ASSERT_LT(OneDirLen, 12U);
 727   size_t NLevels = ((248 - TmpLen) / OneDirLen) + 1;
 728   SmallString<260> LongDir(TestDirectory);
 729   for (size_t I = 0; I < NLevels; ++I)
 730     LongDir.append(OneDir);
 731   ASSERT_NO_ERROR(fs::create_directories(Twine(LongDir)));
 732   ASSERT_NO_ERROR(fs::create_directories(Twine(LongDir)));
 733   ASSERT_EQ(fs::create_directories(Twine(LongDir), false),
 734             errc::file_exists);
 735   // Tidy up, "recursively" removing the directories.
 736   StringRef ThisDir(LongDir);
 737   for (size_t J = 0; J < NLevels; ++J) {
 738     ASSERT_NO_ERROR(fs::remove(ThisDir));
 739     ThisDir = path::parent_path(ThisDir);
 740   }
 741
 742   // Also verify that paths with Unix separators are handled correctly.
 743   std::string LongPathWithUnixSeparators(TestDirectory.str());
 744   // Add at least one subdirectory to TestDirectory, and replace slashes with
 745   // backslashes
 746   do {
 747     LongPathWithUnixSeparators.append("/DirNameWith19Charss");
 748   } while (LongPathWithUnixSeparators.size() < 260);
 749   std::replace(LongPathWithUnixSeparators.begin(),
 750                LongPathWithUnixSeparators.end(),
 751                '\\', '/');
 752   ASSERT_NO_ERROR(fs::create_directories(Twine(LongPathWithUnixSeparators)));
 753   // cleanup
 754   ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) +
 755                                          "/DirNameWith19Charss"));
 756
 757   // Similarly for a relative pathname.  Need to set the current directory to
 758   // TestDirectory so that the one we create ends up in the right place.
 759   char PreviousDir[260];
 760   size_t PreviousDirLen = ::GetCurrentDirectoryA(260, PreviousDir);
 761   ASSERT_GT(PreviousDirLen, 0U);
 762   ASSERT_LT(PreviousDirLen, 260U);
 763   ASSERT_NE(::SetCurrentDirectoryA(TestDirectory.c_str()), 0);
 764   LongDir.clear();
 765   // Generate a relative directory name with absolute length > 248.
 766   size_t LongDirLen = 249 - TestDirectory.size();
 767   LongDir.assign(LongDirLen, 'a');
 768   ASSERT_NO_ERROR(fs::create_directory(Twine(LongDir)));
 769   // While we're here, prove that .. and . handling works in these long paths.
 770   const char *DotDotDirs = "\\..\\.\\b";
 771   LongDir.append(DotDotDirs);
 772   ASSERT_NO_ERROR(fs::create_directory("b"));
 773   ASSERT_EQ(fs::create_directory(Twine(LongDir), false), errc::file_exists);
 774   // And clean up.
 775   ASSERT_NO_ERROR(fs::remove("b"));
 776   ASSERT_NO_ERROR(fs::remove(
 777     Twine(LongDir.substr(0, LongDir.size() - strlen(DotDotDirs)))));
 778   ASSERT_NE(::SetCurrentDirectoryA(PreviousDir), 0);
 779 #endif
 780 }
 781
 782 TEST_F(FileSystemTest, DirectoryIteration) {
 783   std::error_code ec;
 784   for (fs::directory_iterator i(".", ec), e; i != e; i.increment(ec))
 785     ASSERT_NO_ERROR(ec);
 786
 787   // Create a known hierarchy to recurse over.
 788   ASSERT_NO_ERROR(
 789       fs::create_directories(Twine(TestDirectory) + "/recursive/a0/aa1"));
 790   ASSERT_NO_ERROR(
 791       fs::create_directories(Twine(TestDirectory) + "/recursive/a0/ab1"));
 792   ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) +
 793                                          "/recursive/dontlookhere/da1"));
 794   ASSERT_NO_ERROR(
 795       fs::create_directories(Twine(TestDirectory) + "/recursive/z0/za1"));
 796   ASSERT_NO_ERROR(
 797       fs::create_directories(Twine(TestDirectory) + "/recursive/pop/p1"));
 798   typedef std::vector<std::string> v_t;
 799   v_t visited;
 800   for (fs::recursive_directory_iterator i(Twine(TestDirectory)
 801          + "/recursive", ec), e; i != e; i.increment(ec)){
 802     ASSERT_NO_ERROR(ec);
 803     if (path::filename(i->path()) == "p1") {
 804       i.pop();
 805       // FIXME: recursive_directory_iterator should be more robust.
 806       if (i == e) break;
 807     }
 808     if (path::filename(i->path()) == "dontlookhere")
 809       i.no_push();
 810     visited.push_back(path::filename(i->path()));
 811   }
 812   v_t::const_iterator a0 = find(visited, "a0");
 813   v_t::const_iterator aa1 = find(visited, "aa1");
 814   v_t::const_iterator ab1 = find(visited, "ab1");
 815   v_t::const_iterator dontlookhere = find(visited, "dontlookhere");
 816   v_t::const_iterator da1 = find(visited, "da1");
 817   v_t::const_iterator z0 = find(visited, "z0");
 818   v_t::const_iterator za1 = find(visited, "za1");
 819   v_t::const_iterator pop = find(visited, "pop");
 820   v_t::const_iterator p1 = find(visited, "p1");
 821
 822   // Make sure that each path was visited correctly.
 823   ASSERT_NE(a0, visited.end());
 824   ASSERT_NE(aa1, visited.end());
 825   ASSERT_NE(ab1, visited.end());
 826   ASSERT_NE(dontlookhere, visited.end());
 827   ASSERT_EQ(da1, visited.end()); // Not visited.
 828   ASSERT_NE(z0, visited.end());
 829   ASSERT_NE(za1, visited.end());
 830   ASSERT_NE(pop, visited.end());
 831   ASSERT_EQ(p1, visited.end()); // Not visited.
 832
 833   // Make sure that parents were visited before children. No other ordering
 834   // guarantees can be made across siblings.
 835   ASSERT_LT(a0, aa1);
 836   ASSERT_LT(a0, ab1);
 837   ASSERT_LT(z0, za1);
 838
 839   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0/aa1"));
 840   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0/ab1"));
 841   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0"));
 842   ASSERT_NO_ERROR(
 843       fs::remove(Twine(TestDirectory) + "/recursive/dontlookhere/da1"));
 844   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/dontlookhere"));
 845   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/pop/p1"));
 846   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/pop"));
 847   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/z0/za1"));
 848   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/z0"));
 849   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive"));
 850
 851   // Test recursive_directory_iterator level()
 852   ASSERT_NO_ERROR(
 853       fs::create_directories(Twine(TestDirectory) + "/reclevel/a/b/c"));
 854   fs::recursive_directory_iterator I(Twine(TestDirectory) + "/reclevel", ec), E;
 855   for (int l = 0; I != E; I.increment(ec), ++l) {
 856     ASSERT_NO_ERROR(ec);
 857     EXPECT_EQ(I.level(), l);
 858   }
 859   EXPECT_EQ(I, E);
 860   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel/a/b/c"));
 861   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel/a/b"));
 862   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel/a"));
 863   ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel"));
 864 }
 865
 866 #ifdef LLVM_ON_UNIX
 867 TEST_F(FileSystemTest, BrokenSymlinkDirectoryIteration) {
 868   // Create a known hierarchy to recurse over.
 869   ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) + "/symlink"));
 870   ASSERT_NO_ERROR(
 871       fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/a"));
 872   ASSERT_NO_ERROR(
 873       fs::create_directories(Twine(TestDirectory) + "/symlink/b/bb"));
 874   ASSERT_NO_ERROR(
 875       fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/b/ba"));
 876   ASSERT_NO_ERROR(
 877       fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/b/bc"));
 878   ASSERT_NO_ERROR(
 879       fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/c"));
 880   ASSERT_NO_ERROR(
 881       fs::create_directories(Twine(TestDirectory) + "/symlink/d/dd/ddd"));
 882   ASSERT_NO_ERROR(fs::create_link(Twine(TestDirectory) + "/symlink/d/dd",
 883                                   Twine(TestDirectory) + "/symlink/d/da"));
 884   ASSERT_NO_ERROR(
 885       fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/e"));
 886
 887   typedef std::vector<std::string> v_t;
 888   v_t VisitedNonBrokenSymlinks;
 889   v_t VisitedBrokenSymlinks;
 890   std::error_code ec;
 891
 892   // Broken symbol links are expected to throw an error.
 893   for (fs::directory_iterator i(Twine(TestDirectory) + "/symlink", ec), e;
 894        i != e; i.increment(ec)) {
 895     if (ec == std::make_error_code(std::errc::no_such_file_or_directory)) {
 896       VisitedBrokenSymlinks.push_back(path::filename(i->path()));
 897       continue;
 898     }
 899
 900     ASSERT_NO_ERROR(ec);
 901     VisitedNonBrokenSymlinks.push_back(path::filename(i->path()));
 902   }
 903   llvm::sort(VisitedNonBrokenSymlinks.begin(), VisitedNonBrokenSymlinks.end());
 904   llvm::sort(VisitedBrokenSymlinks.begin(), VisitedBrokenSymlinks.end());
 905   v_t ExpectedNonBrokenSymlinks = {"b", "d"};
 906   ASSERT_EQ(ExpectedNonBrokenSymlinks.size(), VisitedNonBrokenSymlinks.size());
 907   ASSERT_TRUE(std::equal(VisitedNonBrokenSymlinks.begin(),
 908                          VisitedNonBrokenSymlinks.end(),
 909                          ExpectedNonBrokenSymlinks.begin()));
 910   VisitedNonBrokenSymlinks.clear();
 911
 912   v_t ExpectedBrokenSymlinks = {"a", "c", "e"};
 913   ASSERT_EQ(ExpectedBrokenSymlinks.size(), VisitedBrokenSymlinks.size());
 914   ASSERT_TRUE(std::equal(VisitedBrokenSymlinks.begin(),
 915                          VisitedBrokenSymlinks.end(),
 916                          ExpectedBrokenSymlinks.begin()));
 917   VisitedBrokenSymlinks.clear();
 918
 919   // Broken symbol links are expected to throw an error.
 920   for (fs::recursive_directory_iterator i(
 921       Twine(TestDirectory) + "/symlink", ec), e; i != e; i.increment(ec)) {
 922     if (ec == std::make_error_code(std::errc::no_such_file_or_directory)) {
 923       VisitedBrokenSymlinks.push_back(path::filename(i->path()));
 924       continue;
 925     }
 926
 927     ASSERT_NO_ERROR(ec);
 928     VisitedNonBrokenSymlinks.push_back(path::filename(i->path()));
 929   }
 930   llvm::sort(VisitedNonBrokenSymlinks.begin(), VisitedNonBrokenSymlinks.end());
 931   llvm::sort(VisitedBrokenSymlinks.begin(), VisitedBrokenSymlinks.end());
 932   ExpectedNonBrokenSymlinks = {"b", "bb", "d", "da", "dd", "ddd", "ddd"};
 933   ASSERT_EQ(ExpectedNonBrokenSymlinks.size(), VisitedNonBrokenSymlinks.size());
 934   ASSERT_TRUE(std::equal(VisitedNonBrokenSymlinks.begin(),
 935                          VisitedNonBrokenSymlinks.end(),
 936                          ExpectedNonBrokenSymlinks.begin()));
 937   VisitedNonBrokenSymlinks.clear();
 938
 939   ExpectedBrokenSymlinks = {"a", "ba", "bc", "c", "e"};
 940   ASSERT_EQ(ExpectedBrokenSymlinks.size(), VisitedBrokenSymlinks.size());
 941   ASSERT_TRUE(std::equal(VisitedBrokenSymlinks.begin(),
 942                          VisitedBrokenSymlinks.end(),
 943                          ExpectedBrokenSymlinks.begin()));
 944   VisitedBrokenSymlinks.clear();
 945
 946   for (fs::recursive_directory_iterator i(
 947       Twine(TestDirectory) + "/symlink", ec, /*follow_symlinks=*/false), e;
 948        i != e; i.increment(ec)) {
 949     if (ec == std::make_error_code(std::errc::no_such_file_or_directory)) {
 950       VisitedBrokenSymlinks.push_back(path::filename(i->path()));
 951       continue;
 952     }
 953
 954     ASSERT_NO_ERROR(ec);
 955     VisitedNonBrokenSymlinks.push_back(path::filename(i->path()));
 956   }
 957   llvm::sort(VisitedNonBrokenSymlinks.begin(), VisitedNonBrokenSymlinks.end());
 958   llvm::sort(VisitedBrokenSymlinks.begin(), VisitedBrokenSymlinks.end());
 959   ExpectedNonBrokenSymlinks = {"a", "b", "ba", "bb", "bc", "c", "d", "da", "dd",
 960                                "ddd", "e"};
 961   ASSERT_EQ(ExpectedNonBrokenSymlinks.size(), VisitedNonBrokenSymlinks.size());
 962   ASSERT_TRUE(std::equal(VisitedNonBrokenSymlinks.begin(),
 963                          VisitedNonBrokenSymlinks.end(),
 964                          ExpectedNonBrokenSymlinks.begin()));
 965   VisitedNonBrokenSymlinks.clear();
 966
 967   ExpectedBrokenSymlinks = {};
 968   ASSERT_EQ(ExpectedBrokenSymlinks.size(), VisitedBrokenSymlinks.size());
 969   ASSERT_TRUE(std::equal(VisitedBrokenSymlinks.begin(),
 970                          VisitedBrokenSymlinks.end(),
 971                          ExpectedBrokenSymlinks.begin()));
 972   VisitedBrokenSymlinks.clear();
 973
 974   ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) + "/symlink"));
 975 }
 976 #endif
 977
 978 TEST_F(FileSystemTest, Remove) {
 979   SmallString<64> BaseDir;
 980   SmallString<64> Paths[4];
 981   int fds[4];
 982   ASSERT_NO_ERROR(fs::createUniqueDirectory("fs_remove", BaseDir));
 983
 984   ASSERT_NO_ERROR(fs::create_directories(Twine(BaseDir) + "/foo/bar/baz"));
 985   ASSERT_NO_ERROR(fs::create_directories(Twine(BaseDir) + "/foo/bar/buzz"));
 986   ASSERT_NO_ERROR(fs::createUniqueFile(
 987       Twine(BaseDir) + "/foo/bar/baz/%%%%%%.tmp", fds[0], Paths[0]));
 988   ASSERT_NO_ERROR(fs::createUniqueFile(
 989       Twine(BaseDir) + "/foo/bar/baz/%%%%%%.tmp", fds[1], Paths[1]));
 990   ASSERT_NO_ERROR(fs::createUniqueFile(
 991       Twine(BaseDir) + "/foo/bar/buzz/%%%%%%.tmp", fds[2], Paths[2]));
 992   ASSERT_NO_ERROR(fs::createUniqueFile(
 993       Twine(BaseDir) + "/foo/bar/buzz/%%%%%%.tmp", fds[3], Paths[3]));
 994
 995   for (int fd : fds)
 996     ::close(fd);
 997
 998   EXPECT_TRUE(fs::exists(Twine(BaseDir) + "/foo/bar/baz"));
 999   EXPECT_TRUE(fs::exists(Twine(BaseDir) + "/foo/bar/buzz"));
1000   EXPECT_TRUE(fs::exists(Paths[0]));
1001   EXPECT_TRUE(fs::exists(Paths[1]));
1002   EXPECT_TRUE(fs::exists(Paths[2]));
1003   EXPECT_TRUE(fs::exists(Paths[3]));
1004
1005   ASSERT_NO_ERROR(fs::remove_directories("D:/footest"));
1006
1007   ASSERT_NO_ERROR(fs::remove_directories(BaseDir));
1008   ASSERT_FALSE(fs::exists(BaseDir));
1009 }
1010
1011 #ifdef LLVM_ON_WIN32
1012 TEST_F(FileSystemTest, CarriageReturn) {
1013   SmallString<128> FilePathname(TestDirectory);
1014   std::error_code EC;
1015   path::append(FilePathname, "test");
1016
1017   {
1018     raw_fd_ostream File(FilePathname, EC, sys::fs::F_Text);
1019     ASSERT_NO_ERROR(EC);
1020     File << '\n';
1021   }
1022   {
1023     auto Buf = MemoryBuffer::getFile(FilePathname.str());
1024     EXPECT_TRUE((bool)Buf);
1025     EXPECT_EQ(Buf.get()->getBuffer(), "\r\n");
1026   }
1027
1028   {
1029     raw_fd_ostream File(FilePathname, EC, sys::fs::F_None);
1030     ASSERT_NO_ERROR(EC);
1031     File << '\n';
1032   }
1033   {
1034     auto Buf = MemoryBuffer::getFile(FilePathname.str());
1035     EXPECT_TRUE((bool)Buf);
1036     EXPECT_EQ(Buf.get()->getBuffer(), "\n");
1037   }
1038   ASSERT_NO_ERROR(fs::remove(Twine(FilePathname)));
1039 }
1040 #endif
1041
1042 TEST_F(FileSystemTest, Resize) {
1043   int FD;
1044   SmallString<64> TempPath;
1045   ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath));
1046   ASSERT_NO_ERROR(fs::resize_file(FD, 123));
1047   fs::file_status Status;
1048   ASSERT_NO_ERROR(fs::status(FD, Status));
1049   ASSERT_EQ(Status.getSize(), 123U);
1050   ::close(FD);
1051   ASSERT_NO_ERROR(fs::remove(TempPath));
1052 }
1053
1054 TEST_F(FileSystemTest, MD5) {
1055   int FD;
1056   SmallString<64> TempPath;
1057   ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath));
1058   StringRef Data("abcdefghijklmnopqrstuvwxyz");
1059   ASSERT_EQ(write(FD, Data.data(), Data.size()), static_cast<ssize_t>(Data.size()));
1060   lseek(FD, 0, SEEK_SET);
1061   auto Hash = fs::md5_contents(FD);
1062   ::close(FD);
1063   ASSERT_NO_ERROR(Hash.getError());
1064
1065   EXPECT_STREQ("c3fcd3d76192e4007dfb496cca67e13b", Hash->digest().c_str());
1066 }
1067
1068 TEST_F(FileSystemTest, FileMapping) {
1069   // Create a temp file.
1070   int FileDescriptor;
1071   SmallString<64> TempPath;
1072   ASSERT_NO_ERROR(
1073       fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));
1074   unsigned Size = 4096;
1075   ASSERT_NO_ERROR(fs::resize_file(FileDescriptor, Size));
1076
1077   // Map in temp file and add some content
1078   std::error_code EC;
1079   StringRef Val("hello there");
1080   {
1081     fs::mapped_file_region mfr(FileDescriptor,
1082                                fs::mapped_file_region::readwrite, Size, 0, EC);
1083     ASSERT_NO_ERROR(EC);
1084     std::copy(Val.begin(), Val.end(), mfr.data());
1085     // Explicitly add a 0.
1086     mfr.data()[Val.size()] = 0;
1087     // Unmap temp file
1088   }
1089   ASSERT_EQ(close(FileDescriptor), 0);
1090
1091   // Map it back in read-only
1092   {
1093     int FD;
1094     EC = fs::openFileForRead(Twine(TempPath), FD);
1095     ASSERT_NO_ERROR(EC);
1096     fs::mapped_file_region mfr(FD, fs::mapped_file_region::readonly, Size, 0, EC);
1097     ASSERT_NO_ERROR(EC);
1098
1099     // Verify content
1100     EXPECT_EQ(StringRef(mfr.const_data()), Val);
1101
1102     // Unmap temp file
1103     fs::mapped_file_region m(FD, fs::mapped_file_region::readonly, Size, 0, EC);
1104     ASSERT_NO_ERROR(EC);
1105     ASSERT_EQ(close(FD), 0);
1106   }
1107   ASSERT_NO_ERROR(fs::remove(TempPath));
1108 }
1109
1110 TEST(Support, NormalizePath) {
1111   using TestTuple = std::tuple<const char *, const char *, const char *>;
1112   std::vector<TestTuple> Tests;
1113   Tests.emplace_back("a", "a", "a");
1114   Tests.emplace_back("a/b", "a\\b", "a/b");
1115   Tests.emplace_back("a\\b", "a\\b", "a/b");
1116   Tests.emplace_back("a\\\\b", "a\\\\b", "a\\\\b");
1117   Tests.emplace_back("\\a", "\\a", "/a");
1118   Tests.emplace_back("a\\", "a\\", "a/");
1119
1120   for (auto &T : Tests) {
1121     SmallString<64> Win(std::get<0>(T));
1122     SmallString<64> Posix(Win);
1123     path::native(Win, path::Style::windows);
1124     path::native(Posix, path::Style::posix);
1125     EXPECT_EQ(std::get<1>(T), Win);
1126     EXPECT_EQ(std::get<2>(T), Posix);
1127   }
1128
1129 #if defined(LLVM_ON_WIN32)
1130   SmallString<64> PathHome;
1131   path::home_directory(PathHome);
1132
1133   const char *Path7a = "~/aaa";
1134   SmallString<64> Path7(Path7a);
1135   path::native(Path7);
1136   EXPECT_TRUE(Path7.endswith("\\aaa"));
1137   EXPECT_TRUE(Path7.startswith(PathHome));
1138   EXPECT_EQ(Path7.size(), PathHome.size() + strlen(Path7a + 1));
1139
1140   const char *Path8a = "~";
1141   SmallString<64> Path8(Path8a);
1142   path::native(Path8);
1143   EXPECT_EQ(Path8, PathHome);
1144
1145   const char *Path9a = "~aaa";
1146   SmallString<64> Path9(Path9a);
1147   path::native(Path9);
1148   EXPECT_EQ(Path9, "~aaa");
1149
1150   const char *Path10a = "aaa/~/b";
1151   SmallString<64> Path10(Path10a);
1152   path::native(Path10);
1153   EXPECT_EQ(Path10, "aaa\\~\\b");
1154 #endif
1155 }
1156
1157 TEST(Support, RemoveLeadingDotSlash) {
1158   StringRef Path1("././/foolz/wat");
1159   StringRef Path2("./////");
1160
1161   Path1 = path::remove_leading_dotslash(Path1);
1162   EXPECT_EQ(Path1, "foolz/wat");
1163   Path2 = path::remove_leading_dotslash(Path2);
1164   EXPECT_EQ(Path2, "");
1165 }
1166
1167 static std::string remove_dots(StringRef path, bool remove_dot_dot,
1168                                path::Style style) {
1169   SmallString<256> buffer(path);
1170   path::remove_dots(buffer, remove_dot_dot, style);
1171   return buffer.str();
1172 }
1173
1174 TEST(Support, RemoveDots) {
1175   EXPECT_EQ("foolz\\wat",
1176             remove_dots(".\\.\\\\foolz\\wat", false, path::Style::windows));
1177   EXPECT_EQ("", remove_dots(".\\\\\\\\\\", false, path::Style::windows));
1178
1179   EXPECT_EQ("a\\..\\b\\c",
1180             remove_dots(".\\a\\..\\b\\c", false, path::Style::windows));
1181   EXPECT_EQ("b\\c", remove_dots(".\\a\\..\\b\\c", true, path::Style::windows));
1182   EXPECT_EQ("c", remove_dots(".\\.\\c", true, path::Style::windows));
1183   EXPECT_EQ("..\\a\\c",
1184             remove_dots("..\\a\\b\\..\\c", true, path::Style::windows));
1185   EXPECT_EQ("..\\..\\a\\c",
1186             remove_dots("..\\..\\a\\b\\..\\c", true, path::Style::windows));
1187
1188   SmallString<64> Path1(".\\.\\c");
1189   EXPECT_TRUE(path::remove_dots(Path1, true, path::Style::windows));
1190   EXPECT_EQ("c", Path1);
1191
1192   EXPECT_EQ("foolz/wat",
1193             remove_dots("././/foolz/wat", false, path::Style::posix));
1194   EXPECT_EQ("", remove_dots("./////", false, path::Style::posix));
1195
1196   EXPECT_EQ("a/../b/c", remove_dots("./a/../b/c", false, path::Style::posix));
1197   EXPECT_EQ("b/c", remove_dots("./a/../b/c", true, path::Style::posix));
1198   EXPECT_EQ("c", remove_dots("././c", true, path::Style::posix));
1199   EXPECT_EQ("../a/c", remove_dots("../a/b/../c", true, path::Style::posix));
1200   EXPECT_EQ("../../a/c",
1201             remove_dots("../../a/b/../c", true, path::Style::posix));
1202   EXPECT_EQ("/a/c", remove_dots("/../../a/c", true, path::Style::posix));
1203   EXPECT_EQ("/a/c",
1204             remove_dots("/../a/b//../././/c", true, path::Style::posix));
1205
1206   SmallString<64> Path2("././c");
1207   EXPECT_TRUE(path::remove_dots(Path2, true, path::Style::posix));
1208   EXPECT_EQ("c", Path2);
1209 }
1210
1211 TEST(Support, ReplacePathPrefix) {
1212   SmallString<64> Path1("/foo");
1213   SmallString<64> Path2("/old/foo");
1214   SmallString<64> OldPrefix("/old");
1215   SmallString<64> NewPrefix("/new");
1216   SmallString<64> NewPrefix2("/longernew");
1217   SmallString<64> EmptyPrefix("");
1218
1219   SmallString<64> Path = Path1;
1220   path::replace_path_prefix(Path, OldPrefix, NewPrefix);
1221   EXPECT_EQ(Path, "/foo");
1222   Path = Path2;
1223   path::replace_path_prefix(Path, OldPrefix, NewPrefix);
1224   EXPECT_EQ(Path, "/new/foo");
1225   Path = Path2;
1226   path::replace_path_prefix(Path, OldPrefix, NewPrefix2);
1227   EXPECT_EQ(Path, "/longernew/foo");
1228   Path = Path1;
1229   path::replace_path_prefix(Path, EmptyPrefix, NewPrefix);
1230   EXPECT_EQ(Path, "/new/foo");
1231   Path = Path2;
1232   path::replace_path_prefix(Path, OldPrefix, EmptyPrefix);
1233   EXPECT_EQ(Path, "/foo");
1234 }
1235
1236 TEST_F(FileSystemTest, OpenFileForRead) {
1237   // Create a temp file.
1238   int FileDescriptor;
1239   SmallString<64> TempPath;
1240   ASSERT_NO_ERROR(
1241       fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath));
1242   FileRemover Cleanup(TempPath);
1243
1244   // Make sure it exists.
1245   ASSERT_TRUE(sys::fs::exists(Twine(TempPath)));
1246
1247   // Open the file for read
1248   int FileDescriptor2;
1249   SmallString<64> ResultPath;
1250   ASSERT_NO_ERROR(
1251       fs::openFileForRead(Twine(TempPath), FileDescriptor2, &ResultPath))
1252
1253   // If we succeeded, check that the paths are the same (modulo case):
1254   if (!ResultPath.empty()) {
1255     // The paths returned by createTemporaryFile and getPathFromOpenFD
1256     // should reference the same file on disk.
1257     fs::UniqueID D1, D2;
1258     ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), D1));
1259     ASSERT_NO_ERROR(fs::getUniqueID(Twine(ResultPath), D2));
1260     ASSERT_EQ(D1, D2);
1261   }
1262
1263   ::close(FileDescriptor);
1264 }
1265
1266 TEST_F(FileSystemTest, set_current_path) {
1267   SmallString<128> path;
1268
1269   ASSERT_NO_ERROR(fs::current_path(path));
1270   ASSERT_NE(TestDirectory, path);
1271
1272   struct RestorePath {
1273     SmallString<128> path;
1274     RestorePath(const SmallString<128> &path) : path(path) {}
1275     ~RestorePath() { fs::set_current_path(path); }
1276   } restore_path(path);
1277
1278   ASSERT_NO_ERROR(fs::set_current_path(TestDirectory));
1279
1280   ASSERT_NO_ERROR(fs::current_path(path));
1281
1282   fs::UniqueID D1, D2;
1283   ASSERT_NO_ERROR(fs::getUniqueID(TestDirectory, D1));
1284   ASSERT_NO_ERROR(fs::getUniqueID(path, D2));
1285   ASSERT_EQ(D1, D2) << "D1: " << TestDirectory << "\nD2: " << path;
1286 }
1287
1288 TEST_F(FileSystemTest, permissions) {
1289   int FD;
1290   SmallString<64> TempPath;
1291   ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath));
1292   FileRemover Cleanup(TempPath);
1293
1294   // Make sure it exists.
1295   ASSERT_TRUE(fs::exists(Twine(TempPath)));
1296
1297   auto CheckPermissions = [&](fs::perms Expected) {
1298     ErrorOr<fs::perms> Actual = fs::getPermissions(TempPath);
1299     return Actual && *Actual == Expected;
1300   };
1301
1302   std::error_code NoError;
1303   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_all), NoError);
1304   EXPECT_TRUE(CheckPermissions(fs::all_all));
1305
1306   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read | fs::all_exe), NoError);
1307   EXPECT_TRUE(CheckPermissions(fs::all_read | fs::all_exe));
1308
1309 #if defined(LLVM_ON_WIN32)
1310   fs::perms ReadOnly = fs::all_read | fs::all_exe;
1311   EXPECT_EQ(fs::setPermissions(TempPath, fs::no_perms), NoError);
1312   EXPECT_TRUE(CheckPermissions(ReadOnly));
1313
1314   EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_read), NoError);
1315   EXPECT_TRUE(CheckPermissions(ReadOnly));
1316
1317   EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_write), NoError);
1318   EXPECT_TRUE(CheckPermissions(fs::all_all));
1319
1320   EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_exe), NoError);
1321   EXPECT_TRUE(CheckPermissions(ReadOnly));
1322
1323   EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_all), NoError);
1324   EXPECT_TRUE(CheckPermissions(fs::all_all));
1325
1326   EXPECT_EQ(fs::setPermissions(TempPath, fs::group_read), NoError);
1327   EXPECT_TRUE(CheckPermissions(ReadOnly));
1328
1329   EXPECT_EQ(fs::setPermissions(TempPath, fs::group_write), NoError);
1330   EXPECT_TRUE(CheckPermissions(fs::all_all));
1331
1332   EXPECT_EQ(fs::setPermissions(TempPath, fs::group_exe), NoError);
1333   EXPECT_TRUE(CheckPermissions(ReadOnly));
1334
1335   EXPECT_EQ(fs::setPermissions(TempPath, fs::group_all), NoError);
1336   EXPECT_TRUE(CheckPermissions(fs::all_all));
1337
1338   EXPECT_EQ(fs::setPermissions(TempPath, fs::others_read), NoError);
1339   EXPECT_TRUE(CheckPermissions(ReadOnly));
1340
1341   EXPECT_EQ(fs::setPermissions(TempPath, fs::others_write), NoError);
1342   EXPECT_TRUE(CheckPermissions(fs::all_all));
1343
1344   EXPECT_EQ(fs::setPermissions(TempPath, fs::others_exe), NoError);
1345   EXPECT_TRUE(CheckPermissions(ReadOnly));
1346
1347   EXPECT_EQ(fs::setPermissions(TempPath, fs::others_all), NoError);
1348   EXPECT_TRUE(CheckPermissions(fs::all_all));
1349
1350   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read), NoError);
1351   EXPECT_TRUE(CheckPermissions(ReadOnly));
1352
1353   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_write), NoError);
1354   EXPECT_TRUE(CheckPermissions(fs::all_all));
1355
1356   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_exe), NoError);
1357   EXPECT_TRUE(CheckPermissions(ReadOnly));
1358
1359   EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe), NoError);
1360   EXPECT_TRUE(CheckPermissions(ReadOnly));
1361
1362   EXPECT_EQ(fs::setPermissions(TempPath, fs::set_gid_on_exe), NoError);
1363   EXPECT_TRUE(CheckPermissions(ReadOnly));
1364
1365   EXPECT_EQ(fs::setPermissions(TempPath, fs::sticky_bit), NoError);
1366   EXPECT_TRUE(CheckPermissions(ReadOnly));
1367
1368   EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe |
1369                                              fs::set_gid_on_exe |
1370                                              fs::sticky_bit),
1371             NoError);
1372   EXPECT_TRUE(CheckPermissions(ReadOnly));
1373
1374   EXPECT_EQ(fs::setPermissions(TempPath, ReadOnly | fs::set_uid_on_exe |
1375                                              fs::set_gid_on_exe |
1376                                              fs::sticky_bit),
1377             NoError);
1378   EXPECT_TRUE(CheckPermissions(ReadOnly));
1379
1380   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms), NoError);
1381   EXPECT_TRUE(CheckPermissions(fs::all_all));
1382 #else
1383   EXPECT_EQ(fs::setPermissions(TempPath, fs::no_perms), NoError);
1384   EXPECT_TRUE(CheckPermissions(fs::no_perms));
1385
1386   EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_read), NoError);
1387   EXPECT_TRUE(CheckPermissions(fs::owner_read));
1388
1389   EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_write), NoError);
1390   EXPECT_TRUE(CheckPermissions(fs::owner_write));
1391
1392   EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_exe), NoError);
1393   EXPECT_TRUE(CheckPermissions(fs::owner_exe));
1394
1395   EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_all), NoError);
1396   EXPECT_TRUE(CheckPermissions(fs::owner_all));
1397
1398   EXPECT_EQ(fs::setPermissions(TempPath, fs::group_read), NoError);
1399   EXPECT_TRUE(CheckPermissions(fs::group_read));
1400
1401   EXPECT_EQ(fs::setPermissions(TempPath, fs::group_write), NoError);
1402   EXPECT_TRUE(CheckPermissions(fs::group_write));
1403
1404   EXPECT_EQ(fs::setPermissions(TempPath, fs::group_exe), NoError);
1405   EXPECT_TRUE(CheckPermissions(fs::group_exe));
1406
1407   EXPECT_EQ(fs::setPermissions(TempPath, fs::group_all), NoError);
1408   EXPECT_TRUE(CheckPermissions(fs::group_all));
1409
1410   EXPECT_EQ(fs::setPermissions(TempPath, fs::others_read), NoError);
1411   EXPECT_TRUE(CheckPermissions(fs::others_read));
1412
1413   EXPECT_EQ(fs::setPermissions(TempPath, fs::others_write), NoError);
1414   EXPECT_TRUE(CheckPermissions(fs::others_write));
1415
1416   EXPECT_EQ(fs::setPermissions(TempPath, fs::others_exe), NoError);
1417   EXPECT_TRUE(CheckPermissions(fs::others_exe));
1418
1419   EXPECT_EQ(fs::setPermissions(TempPath, fs::others_all), NoError);
1420   EXPECT_TRUE(CheckPermissions(fs::others_all));
1421
1422   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read), NoError);
1423   EXPECT_TRUE(CheckPermissions(fs::all_read));
1424
1425   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_write), NoError);
1426   EXPECT_TRUE(CheckPermissions(fs::all_write));
1427
1428   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_exe), NoError);
1429   EXPECT_TRUE(CheckPermissions(fs::all_exe));
1430
1431   EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe), NoError);
1432   EXPECT_TRUE(CheckPermissions(fs::set_uid_on_exe));
1433
1434   EXPECT_EQ(fs::setPermissions(TempPath, fs::set_gid_on_exe), NoError);
1435   EXPECT_TRUE(CheckPermissions(fs::set_gid_on_exe));
1436
1437   // Modern BSDs require root to set the sticky bit on files.
1438 #if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__)
1439   EXPECT_EQ(fs::setPermissions(TempPath, fs::sticky_bit), NoError);
1440   EXPECT_TRUE(CheckPermissions(fs::sticky_bit));
1441
1442   EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe |
1443                                              fs::set_gid_on_exe |
1444                                              fs::sticky_bit),
1445             NoError);
1446   EXPECT_TRUE(CheckPermissions(fs::set_uid_on_exe | fs::set_gid_on_exe |
1447                                fs::sticky_bit));
1448
1449   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read | fs::set_uid_on_exe |
1450                                              fs::set_gid_on_exe |
1451                                              fs::sticky_bit),
1452             NoError);
1453   EXPECT_TRUE(CheckPermissions(fs::all_read | fs::set_uid_on_exe |
1454                                fs::set_gid_on_exe | fs::sticky_bit));
1455
1456   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms), NoError);
1457   EXPECT_TRUE(CheckPermissions(fs::all_perms));
1458 #endif // !FreeBSD && !NetBSD && !OpenBSD
1459
1460   EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms & ~fs::sticky_bit),
1461                                NoError);
1462   EXPECT_TRUE(CheckPermissions(fs::all_perms & ~fs::sticky_bit));
1463 #endif
1464 }
1465
1466 } // anonymous namespace