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