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 TEST_F(FileSystemTest, TempFiles) { 568 // Create a temp file. 569 int FileDescriptor; 570 SmallString<64> TempPath; 571 ASSERT_NO_ERROR( 572 fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath)); 573 574 // Make sure it exists. 575 ASSERT_TRUE(sys::fs::exists(Twine(TempPath))); 576 577 // Create another temp tile. 578 int FD2; 579 SmallString<64> TempPath2; 580 ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD2, TempPath2)); 581 ASSERT_TRUE(TempPath2.endswith(".temp")); 582 ASSERT_NE(TempPath.str(), TempPath2.str()); 583 584 fs::file_status A, B; 585 ASSERT_NO_ERROR(fs::status(Twine(TempPath), A)); 586 ASSERT_NO_ERROR(fs::status(Twine(TempPath2), B)); 587 EXPECT_FALSE(fs::equivalent(A, B)); 588 589 ::close(FD2); 590 591 // Remove Temp2. 592 ASSERT_NO_ERROR(fs::remove(Twine(TempPath2))); 593 ASSERT_NO_ERROR(fs::remove(Twine(TempPath2))); 594 ASSERT_EQ(fs::remove(Twine(TempPath2), false), 595 errc::no_such_file_or_directory); 596 597 std::error_code EC = fs::status(TempPath2.c_str(), B); 598 EXPECT_EQ(EC, errc::no_such_file_or_directory); 599 EXPECT_EQ(B.type(), fs::file_type::file_not_found); 600 601 // Make sure Temp2 doesn't exist. 602 ASSERT_EQ(fs::access(Twine(TempPath2), sys::fs::AccessMode::Exist), 603 errc::no_such_file_or_directory); 604 605 SmallString<64> TempPath3; 606 ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "", TempPath3)); 607 ASSERT_FALSE(TempPath3.endswith(".")); 608 FileRemover Cleanup3(TempPath3); 609 610 // Create a hard link to Temp1. 611 ASSERT_NO_ERROR(fs::create_link(Twine(TempPath), Twine(TempPath2))); 612 bool equal; 613 ASSERT_NO_ERROR(fs::equivalent(Twine(TempPath), Twine(TempPath2), equal)); 614 EXPECT_TRUE(equal); 615 ASSERT_NO_ERROR(fs::status(Twine(TempPath), A)); 616 ASSERT_NO_ERROR(fs::status(Twine(TempPath2), B)); 617 EXPECT_TRUE(fs::equivalent(A, B)); 618 619 // Remove Temp1. 620 ::close(FileDescriptor); 621 ASSERT_NO_ERROR(fs::remove(Twine(TempPath))); 622 623 // Remove the hard link. 624 ASSERT_NO_ERROR(fs::remove(Twine(TempPath2))); 625 626 // Make sure Temp1 doesn't exist. 627 ASSERT_EQ(fs::access(Twine(TempPath), sys::fs::AccessMode::Exist), 628 errc::no_such_file_or_directory); 629 630 #ifdef LLVM_ON_WIN32 631 // Path name > 260 chars should get an error. 632 const char *Path270 = 633 "abcdefghijklmnopqrstuvwxyz9abcdefghijklmnopqrstuvwxyz8" 634 "abcdefghijklmnopqrstuvwxyz7abcdefghijklmnopqrstuvwxyz6" 635 "abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz4" 636 "abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz2" 637 "abcdefghijklmnopqrstuvwxyz1abcdefghijklmnopqrstuvwxyz0"; 638 EXPECT_EQ(fs::createUniqueFile(Path270, FileDescriptor, TempPath), 639 errc::invalid_argument); 640 // Relative path < 247 chars, no problem. 641 const char *Path216 = 642 "abcdefghijklmnopqrstuvwxyz7abcdefghijklmnopqrstuvwxyz6" 643 "abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz4" 644 "abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz2" 645 "abcdefghijklmnopqrstuvwxyz1abcdefghijklmnopqrstuvwxyz0"; 646 ASSERT_NO_ERROR(fs::createTemporaryFile(Path216, "", TempPath)); 647 ASSERT_NO_ERROR(fs::remove(Twine(TempPath))); 648 #endif 649 } 650 651 TEST_F(FileSystemTest, CreateDir) { 652 ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "foo")); 653 ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "foo")); 654 ASSERT_EQ(fs::create_directory(Twine(TestDirectory) + "foo", false), 655 errc::file_exists); 656 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "foo")); 657 658 #ifdef LLVM_ON_UNIX 659 // Set a 0000 umask so that we can test our directory permissions. 660 mode_t OldUmask = ::umask(0000); 661 662 fs::file_status Status; 663 ASSERT_NO_ERROR( 664 fs::create_directory(Twine(TestDirectory) + "baz500", false, 665 fs::perms::owner_read | fs::perms::owner_exe)); 666 ASSERT_NO_ERROR(fs::status(Twine(TestDirectory) + "baz500", Status)); 667 ASSERT_EQ(Status.permissions() & fs::perms::all_all, 668 fs::perms::owner_read | fs::perms::owner_exe); 669 ASSERT_NO_ERROR(fs::create_directory(Twine(TestDirectory) + "baz777", false, 670 fs::perms::all_all)); 671 ASSERT_NO_ERROR(fs::status(Twine(TestDirectory) + "baz777", Status)); 672 ASSERT_EQ(Status.permissions() & fs::perms::all_all, fs::perms::all_all); 673 674 // Restore umask to be safe. 675 ::umask(OldUmask); 676 #endif 677 678 #ifdef LLVM_ON_WIN32 679 // Prove that create_directories() can handle a pathname > 248 characters, 680 // which is the documented limit for CreateDirectory(). 681 // (248 is MAX_PATH subtracting room for an 8.3 filename.) 682 // Generate a directory path guaranteed to fall into that range. 683 size_t TmpLen = TestDirectory.size(); 684 const char *OneDir = "\\123456789"; 685 size_t OneDirLen = strlen(OneDir); 686 ASSERT_LT(OneDirLen, 12U); 687 size_t NLevels = ((248 - TmpLen) / OneDirLen) + 1; 688 SmallString<260> LongDir(TestDirectory); 689 for (size_t I = 0; I < NLevels; ++I) 690 LongDir.append(OneDir); 691 ASSERT_NO_ERROR(fs::create_directories(Twine(LongDir))); 692 ASSERT_NO_ERROR(fs::create_directories(Twine(LongDir))); 693 ASSERT_EQ(fs::create_directories(Twine(LongDir), false), 694 errc::file_exists); 695 // Tidy up, "recursively" removing the directories. 696 StringRef ThisDir(LongDir); 697 for (size_t J = 0; J < NLevels; ++J) { 698 ASSERT_NO_ERROR(fs::remove(ThisDir)); 699 ThisDir = path::parent_path(ThisDir); 700 } 701 702 // Also verify that paths with Unix separators are handled correctly. 703 std::string LongPathWithUnixSeparators(TestDirectory.str()); 704 // Add at least one subdirectory to TestDirectory, and replace slashes with 705 // backslashes 706 do { 707 LongPathWithUnixSeparators.append("/DirNameWith19Charss"); 708 } while (LongPathWithUnixSeparators.size() < 260); 709 std::replace(LongPathWithUnixSeparators.begin(), 710 LongPathWithUnixSeparators.end(), 711 '\\', '/'); 712 ASSERT_NO_ERROR(fs::create_directories(Twine(LongPathWithUnixSeparators))); 713 // cleanup 714 ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) + 715 "/DirNameWith19Charss")); 716 717 // Similarly for a relative pathname. Need to set the current directory to 718 // TestDirectory so that the one we create ends up in the right place. 719 char PreviousDir[260]; 720 size_t PreviousDirLen = ::GetCurrentDirectoryA(260, PreviousDir); 721 ASSERT_GT(PreviousDirLen, 0U); 722 ASSERT_LT(PreviousDirLen, 260U); 723 ASSERT_NE(::SetCurrentDirectoryA(TestDirectory.c_str()), 0); 724 LongDir.clear(); 725 // Generate a relative directory name with absolute length > 248. 726 size_t LongDirLen = 249 - TestDirectory.size(); 727 LongDir.assign(LongDirLen, 'a'); 728 ASSERT_NO_ERROR(fs::create_directory(Twine(LongDir))); 729 // While we're here, prove that .. and . handling works in these long paths. 730 const char *DotDotDirs = "\\..\\.\\b"; 731 LongDir.append(DotDotDirs); 732 ASSERT_NO_ERROR(fs::create_directory("b")); 733 ASSERT_EQ(fs::create_directory(Twine(LongDir), false), errc::file_exists); 734 // And clean up. 735 ASSERT_NO_ERROR(fs::remove("b")); 736 ASSERT_NO_ERROR(fs::remove( 737 Twine(LongDir.substr(0, LongDir.size() - strlen(DotDotDirs))))); 738 ASSERT_NE(::SetCurrentDirectoryA(PreviousDir), 0); 739 #endif 740 } 741 742 TEST_F(FileSystemTest, DirectoryIteration) { 743 std::error_code ec; 744 for (fs::directory_iterator i(".", ec), e; i != e; i.increment(ec)) 745 ASSERT_NO_ERROR(ec); 746 747 // Create a known hierarchy to recurse over. 748 ASSERT_NO_ERROR( 749 fs::create_directories(Twine(TestDirectory) + "/recursive/a0/aa1")); 750 ASSERT_NO_ERROR( 751 fs::create_directories(Twine(TestDirectory) + "/recursive/a0/ab1")); 752 ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) + 753 "/recursive/dontlookhere/da1")); 754 ASSERT_NO_ERROR( 755 fs::create_directories(Twine(TestDirectory) + "/recursive/z0/za1")); 756 ASSERT_NO_ERROR( 757 fs::create_directories(Twine(TestDirectory) + "/recursive/pop/p1")); 758 typedef std::vector<std::string> v_t; 759 v_t visited; 760 for (fs::recursive_directory_iterator i(Twine(TestDirectory) 761 + "/recursive", ec), e; i != e; i.increment(ec)){ 762 ASSERT_NO_ERROR(ec); 763 if (path::filename(i->path()) == "p1") { 764 i.pop(); 765 // FIXME: recursive_directory_iterator should be more robust. 766 if (i == e) break; 767 } 768 if (path::filename(i->path()) == "dontlookhere") 769 i.no_push(); 770 visited.push_back(path::filename(i->path())); 771 } 772 v_t::const_iterator a0 = find(visited, "a0"); 773 v_t::const_iterator aa1 = find(visited, "aa1"); 774 v_t::const_iterator ab1 = find(visited, "ab1"); 775 v_t::const_iterator dontlookhere = find(visited, "dontlookhere"); 776 v_t::const_iterator da1 = find(visited, "da1"); 777 v_t::const_iterator z0 = find(visited, "z0"); 778 v_t::const_iterator za1 = find(visited, "za1"); 779 v_t::const_iterator pop = find(visited, "pop"); 780 v_t::const_iterator p1 = find(visited, "p1"); 781 782 // Make sure that each path was visited correctly. 783 ASSERT_NE(a0, visited.end()); 784 ASSERT_NE(aa1, visited.end()); 785 ASSERT_NE(ab1, visited.end()); 786 ASSERT_NE(dontlookhere, visited.end()); 787 ASSERT_EQ(da1, visited.end()); // Not visited. 788 ASSERT_NE(z0, visited.end()); 789 ASSERT_NE(za1, visited.end()); 790 ASSERT_NE(pop, visited.end()); 791 ASSERT_EQ(p1, visited.end()); // Not visited. 792 793 // Make sure that parents were visited before children. No other ordering 794 // guarantees can be made across siblings. 795 ASSERT_LT(a0, aa1); 796 ASSERT_LT(a0, ab1); 797 ASSERT_LT(z0, za1); 798 799 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0/aa1")); 800 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0/ab1")); 801 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/a0")); 802 ASSERT_NO_ERROR( 803 fs::remove(Twine(TestDirectory) + "/recursive/dontlookhere/da1")); 804 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/dontlookhere")); 805 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/pop/p1")); 806 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/pop")); 807 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/z0/za1")); 808 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive/z0")); 809 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/recursive")); 810 811 // Test recursive_directory_iterator level() 812 ASSERT_NO_ERROR( 813 fs::create_directories(Twine(TestDirectory) + "/reclevel/a/b/c")); 814 fs::recursive_directory_iterator I(Twine(TestDirectory) + "/reclevel", ec), E; 815 for (int l = 0; I != E; I.increment(ec), ++l) { 816 ASSERT_NO_ERROR(ec); 817 EXPECT_EQ(I.level(), l); 818 } 819 EXPECT_EQ(I, E); 820 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel/a/b/c")); 821 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel/a/b")); 822 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel/a")); 823 ASSERT_NO_ERROR(fs::remove(Twine(TestDirectory) + "/reclevel")); 824 } 825 826 #ifdef LLVM_ON_UNIX 827 TEST_F(FileSystemTest, BrokenSymlinkDirectoryIteration) { 828 // Create a known hierarchy to recurse over. 829 ASSERT_NO_ERROR(fs::create_directories(Twine(TestDirectory) + "/symlink")); 830 ASSERT_NO_ERROR( 831 fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/a")); 832 ASSERT_NO_ERROR( 833 fs::create_directories(Twine(TestDirectory) + "/symlink/b/bb")); 834 ASSERT_NO_ERROR( 835 fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/b/ba")); 836 ASSERT_NO_ERROR( 837 fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/b/bc")); 838 ASSERT_NO_ERROR( 839 fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/c")); 840 ASSERT_NO_ERROR( 841 fs::create_directories(Twine(TestDirectory) + "/symlink/d/dd/ddd")); 842 ASSERT_NO_ERROR(fs::create_link(Twine(TestDirectory) + "/symlink/d/dd", 843 Twine(TestDirectory) + "/symlink/d/da")); 844 ASSERT_NO_ERROR( 845 fs::create_link("no_such_file", Twine(TestDirectory) + "/symlink/e")); 846 847 typedef std::vector<std::string> v_t; 848 v_t visited; 849 850 // The directory iterator doesn't stat the file, so we should be able to 851 // iterate over the whole directory. 852 std::error_code ec; 853 for (fs::directory_iterator i(Twine(TestDirectory) + "/symlink", ec), e; 854 i != e; i.increment(ec)) { 855 ASSERT_NO_ERROR(ec); 856 visited.push_back(path::filename(i->path())); 857 } 858 std::sort(visited.begin(), visited.end()); 859 v_t expected = {"a", "b", "c", "d", "e"}; 860 ASSERT_TRUE(visited.size() == expected.size()); 861 ASSERT_TRUE(std::equal(visited.begin(), visited.end(), expected.begin())); 862 visited.clear(); 863 864 // The recursive directory iterator has to stat the file, so we need to skip 865 // the broken symlinks. 866 for (fs::recursive_directory_iterator 867 i(Twine(TestDirectory) + "/symlink", ec), 868 e; 869 i != e; i.increment(ec)) { 870 ASSERT_NO_ERROR(ec); 871 872 fs::file_status status; 873 if (i->status(status) == 874 std::make_error_code(std::errc::no_such_file_or_directory)) { 875 i.no_push(); 876 continue; 877 } 878 879 visited.push_back(path::filename(i->path())); 880 } 881 std::sort(visited.begin(), visited.end()); 882 expected = {"b", "bb", "d", "da", "dd", "ddd", "ddd"}; 883 ASSERT_TRUE(visited.size() == expected.size()); 884 ASSERT_TRUE(std::equal(visited.begin(), visited.end(), expected.begin())); 885 visited.clear(); 886 887 // This recursive directory iterator doesn't follow symlinks, so we don't need 888 // to skip them. 889 for (fs::recursive_directory_iterator 890 i(Twine(TestDirectory) + "/symlink", ec, /*follow_symlinks=*/false), 891 e; 892 i != e; i.increment(ec)) { 893 ASSERT_NO_ERROR(ec); 894 visited.push_back(path::filename(i->path())); 895 } 896 std::sort(visited.begin(), visited.end()); 897 expected = {"a", "b", "ba", "bb", "bc", "c", "d", "da", "dd", "ddd", "e"}; 898 ASSERT_TRUE(visited.size() == expected.size()); 899 ASSERT_TRUE(std::equal(visited.begin(), visited.end(), expected.begin())); 900 901 ASSERT_NO_ERROR(fs::remove_directories(Twine(TestDirectory) + "/symlink")); 902 } 903 #endif 904 905 TEST_F(FileSystemTest, Remove) { 906 SmallString<64> BaseDir; 907 SmallString<64> Paths[4]; 908 int fds[4]; 909 ASSERT_NO_ERROR(fs::createUniqueDirectory("fs_remove", BaseDir)); 910 911 ASSERT_NO_ERROR(fs::create_directories(Twine(BaseDir) + "/foo/bar/baz")); 912 ASSERT_NO_ERROR(fs::create_directories(Twine(BaseDir) + "/foo/bar/buzz")); 913 ASSERT_NO_ERROR(fs::createUniqueFile( 914 Twine(BaseDir) + "/foo/bar/baz/%%%%%%.tmp", fds[0], Paths[0])); 915 ASSERT_NO_ERROR(fs::createUniqueFile( 916 Twine(BaseDir) + "/foo/bar/baz/%%%%%%.tmp", fds[1], Paths[1])); 917 ASSERT_NO_ERROR(fs::createUniqueFile( 918 Twine(BaseDir) + "/foo/bar/buzz/%%%%%%.tmp", fds[2], Paths[2])); 919 ASSERT_NO_ERROR(fs::createUniqueFile( 920 Twine(BaseDir) + "/foo/bar/buzz/%%%%%%.tmp", fds[3], Paths[3])); 921 922 for (int fd : fds) 923 ::close(fd); 924 925 EXPECT_TRUE(fs::exists(Twine(BaseDir) + "/foo/bar/baz")); 926 EXPECT_TRUE(fs::exists(Twine(BaseDir) + "/foo/bar/buzz")); 927 EXPECT_TRUE(fs::exists(Paths[0])); 928 EXPECT_TRUE(fs::exists(Paths[1])); 929 EXPECT_TRUE(fs::exists(Paths[2])); 930 EXPECT_TRUE(fs::exists(Paths[3])); 931 932 ASSERT_NO_ERROR(fs::remove_directories("D:/footest")); 933 934 ASSERT_NO_ERROR(fs::remove_directories(BaseDir)); 935 ASSERT_FALSE(fs::exists(BaseDir)); 936 } 937 938 #ifdef LLVM_ON_WIN32 939 TEST_F(FileSystemTest, CarriageReturn) { 940 SmallString<128> FilePathname(TestDirectory); 941 std::error_code EC; 942 path::append(FilePathname, "test"); 943 944 { 945 raw_fd_ostream File(FilePathname, EC, sys::fs::F_Text); 946 ASSERT_NO_ERROR(EC); 947 File << '\n'; 948 } 949 { 950 auto Buf = MemoryBuffer::getFile(FilePathname.str()); 951 EXPECT_TRUE((bool)Buf); 952 EXPECT_EQ(Buf.get()->getBuffer(), "\r\n"); 953 } 954 955 { 956 raw_fd_ostream File(FilePathname, EC, sys::fs::F_None); 957 ASSERT_NO_ERROR(EC); 958 File << '\n'; 959 } 960 { 961 auto Buf = MemoryBuffer::getFile(FilePathname.str()); 962 EXPECT_TRUE((bool)Buf); 963 EXPECT_EQ(Buf.get()->getBuffer(), "\n"); 964 } 965 ASSERT_NO_ERROR(fs::remove(Twine(FilePathname))); 966 } 967 #endif 968 969 TEST_F(FileSystemTest, Resize) { 970 int FD; 971 SmallString<64> TempPath; 972 ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath)); 973 ASSERT_NO_ERROR(fs::resize_file(FD, 123)); 974 fs::file_status Status; 975 ASSERT_NO_ERROR(fs::status(FD, Status)); 976 ASSERT_EQ(Status.getSize(), 123U); 977 ::close(FD); 978 ASSERT_NO_ERROR(fs::remove(TempPath)); 979 } 980 981 TEST_F(FileSystemTest, MD5) { 982 int FD; 983 SmallString<64> TempPath; 984 ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath)); 985 StringRef Data("abcdefghijklmnopqrstuvwxyz"); 986 ASSERT_EQ(write(FD, Data.data(), Data.size()), static_cast<ssize_t>(Data.size())); 987 lseek(FD, 0, SEEK_SET); 988 auto Hash = fs::md5_contents(FD); 989 ::close(FD); 990 ASSERT_NO_ERROR(Hash.getError()); 991 992 EXPECT_STREQ("c3fcd3d76192e4007dfb496cca67e13b", Hash->digest().c_str()); 993 } 994 995 TEST_F(FileSystemTest, FileMapping) { 996 // Create a temp file. 997 int FileDescriptor; 998 SmallString<64> TempPath; 999 ASSERT_NO_ERROR( 1000 fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath)); 1001 unsigned Size = 4096; 1002 ASSERT_NO_ERROR(fs::resize_file(FileDescriptor, Size)); 1003 1004 // Map in temp file and add some content 1005 std::error_code EC; 1006 StringRef Val("hello there"); 1007 { 1008 fs::mapped_file_region mfr(FileDescriptor, 1009 fs::mapped_file_region::readwrite, Size, 0, EC); 1010 ASSERT_NO_ERROR(EC); 1011 std::copy(Val.begin(), Val.end(), mfr.data()); 1012 // Explicitly add a 0. 1013 mfr.data()[Val.size()] = 0; 1014 // Unmap temp file 1015 } 1016 ASSERT_EQ(close(FileDescriptor), 0); 1017 1018 // Map it back in read-only 1019 { 1020 int FD; 1021 EC = fs::openFileForRead(Twine(TempPath), FD); 1022 ASSERT_NO_ERROR(EC); 1023 fs::mapped_file_region mfr(FD, fs::mapped_file_region::readonly, Size, 0, EC); 1024 ASSERT_NO_ERROR(EC); 1025 1026 // Verify content 1027 EXPECT_EQ(StringRef(mfr.const_data()), Val); 1028 1029 // Unmap temp file 1030 fs::mapped_file_region m(FD, fs::mapped_file_region::readonly, Size, 0, EC); 1031 ASSERT_NO_ERROR(EC); 1032 ASSERT_EQ(close(FD), 0); 1033 } 1034 ASSERT_NO_ERROR(fs::remove(TempPath)); 1035 } 1036 1037 TEST(Support, NormalizePath) { 1038 using TestTuple = std::tuple<const char *, const char *, const char *>; 1039 std::vector<TestTuple> Tests; 1040 Tests.emplace_back("a", "a", "a"); 1041 Tests.emplace_back("a/b", "a\\b", "a/b"); 1042 Tests.emplace_back("a\\b", "a\\b", "a/b"); 1043 Tests.emplace_back("a\\\\b", "a\\\\b", "a\\\\b"); 1044 Tests.emplace_back("\\a", "\\a", "/a"); 1045 Tests.emplace_back("a\\", "a\\", "a/"); 1046 1047 for (auto &T : Tests) { 1048 SmallString<64> Win(std::get<0>(T)); 1049 SmallString<64> Posix(Win); 1050 path::native(Win, path::Style::windows); 1051 path::native(Posix, path::Style::posix); 1052 EXPECT_EQ(std::get<1>(T), Win); 1053 EXPECT_EQ(std::get<2>(T), Posix); 1054 } 1055 1056 #if defined(LLVM_ON_WIN32) 1057 SmallString<64> PathHome; 1058 path::home_directory(PathHome); 1059 1060 const char *Path7a = "~/aaa"; 1061 SmallString<64> Path7(Path7a); 1062 path::native(Path7); 1063 EXPECT_TRUE(Path7.endswith("\\aaa")); 1064 EXPECT_TRUE(Path7.startswith(PathHome)); 1065 EXPECT_EQ(Path7.size(), PathHome.size() + strlen(Path7a + 1)); 1066 1067 const char *Path8a = "~"; 1068 SmallString<64> Path8(Path8a); 1069 path::native(Path8); 1070 EXPECT_EQ(Path8, PathHome); 1071 1072 const char *Path9a = "~aaa"; 1073 SmallString<64> Path9(Path9a); 1074 path::native(Path9); 1075 EXPECT_EQ(Path9, "~aaa"); 1076 1077 const char *Path10a = "aaa/~/b"; 1078 SmallString<64> Path10(Path10a); 1079 path::native(Path10); 1080 EXPECT_EQ(Path10, "aaa\\~\\b"); 1081 #endif 1082 } 1083 1084 TEST(Support, RemoveLeadingDotSlash) { 1085 StringRef Path1("././/foolz/wat"); 1086 StringRef Path2("./////"); 1087 1088 Path1 = path::remove_leading_dotslash(Path1); 1089 EXPECT_EQ(Path1, "foolz/wat"); 1090 Path2 = path::remove_leading_dotslash(Path2); 1091 EXPECT_EQ(Path2, ""); 1092 } 1093 1094 static std::string remove_dots(StringRef path, bool remove_dot_dot, 1095 path::Style style) { 1096 SmallString<256> buffer(path); 1097 path::remove_dots(buffer, remove_dot_dot, style); 1098 return buffer.str(); 1099 } 1100 1101 TEST(Support, RemoveDots) { 1102 EXPECT_EQ("foolz\\wat", 1103 remove_dots(".\\.\\\\foolz\\wat", false, path::Style::windows)); 1104 EXPECT_EQ("", remove_dots(".\\\\\\\\\\", false, path::Style::windows)); 1105 1106 EXPECT_EQ("a\\..\\b\\c", 1107 remove_dots(".\\a\\..\\b\\c", false, path::Style::windows)); 1108 EXPECT_EQ("b\\c", remove_dots(".\\a\\..\\b\\c", true, path::Style::windows)); 1109 EXPECT_EQ("c", remove_dots(".\\.\\c", true, path::Style::windows)); 1110 EXPECT_EQ("..\\a\\c", 1111 remove_dots("..\\a\\b\\..\\c", true, path::Style::windows)); 1112 EXPECT_EQ("..\\..\\a\\c", 1113 remove_dots("..\\..\\a\\b\\..\\c", true, path::Style::windows)); 1114 1115 SmallString<64> Path1(".\\.\\c"); 1116 EXPECT_TRUE(path::remove_dots(Path1, true, path::Style::windows)); 1117 EXPECT_EQ("c", Path1); 1118 1119 EXPECT_EQ("foolz/wat", 1120 remove_dots("././/foolz/wat", false, path::Style::posix)); 1121 EXPECT_EQ("", remove_dots("./////", false, path::Style::posix)); 1122 1123 EXPECT_EQ("a/../b/c", remove_dots("./a/../b/c", false, path::Style::posix)); 1124 EXPECT_EQ("b/c", remove_dots("./a/../b/c", true, path::Style::posix)); 1125 EXPECT_EQ("c", remove_dots("././c", true, path::Style::posix)); 1126 EXPECT_EQ("../a/c", remove_dots("../a/b/../c", true, path::Style::posix)); 1127 EXPECT_EQ("../../a/c", 1128 remove_dots("../../a/b/../c", true, path::Style::posix)); 1129 EXPECT_EQ("/a/c", remove_dots("/../../a/c", true, path::Style::posix)); 1130 EXPECT_EQ("/a/c", 1131 remove_dots("/../a/b//../././/c", true, path::Style::posix)); 1132 1133 SmallString<64> Path2("././c"); 1134 EXPECT_TRUE(path::remove_dots(Path2, true, path::Style::posix)); 1135 EXPECT_EQ("c", Path2); 1136 } 1137 1138 TEST(Support, ReplacePathPrefix) { 1139 SmallString<64> Path1("/foo"); 1140 SmallString<64> Path2("/old/foo"); 1141 SmallString<64> OldPrefix("/old"); 1142 SmallString<64> NewPrefix("/new"); 1143 SmallString<64> NewPrefix2("/longernew"); 1144 SmallString<64> EmptyPrefix(""); 1145 1146 SmallString<64> Path = Path1; 1147 path::replace_path_prefix(Path, OldPrefix, NewPrefix); 1148 EXPECT_EQ(Path, "/foo"); 1149 Path = Path2; 1150 path::replace_path_prefix(Path, OldPrefix, NewPrefix); 1151 EXPECT_EQ(Path, "/new/foo"); 1152 Path = Path2; 1153 path::replace_path_prefix(Path, OldPrefix, NewPrefix2); 1154 EXPECT_EQ(Path, "/longernew/foo"); 1155 Path = Path1; 1156 path::replace_path_prefix(Path, EmptyPrefix, NewPrefix); 1157 EXPECT_EQ(Path, "/new/foo"); 1158 Path = Path2; 1159 path::replace_path_prefix(Path, OldPrefix, EmptyPrefix); 1160 EXPECT_EQ(Path, "/foo"); 1161 } 1162 1163 TEST_F(FileSystemTest, OpenFileForRead) { 1164 // Create a temp file. 1165 int FileDescriptor; 1166 SmallString<64> TempPath; 1167 ASSERT_NO_ERROR( 1168 fs::createTemporaryFile("prefix", "temp", FileDescriptor, TempPath)); 1169 FileRemover Cleanup(TempPath); 1170 1171 // Make sure it exists. 1172 ASSERT_TRUE(sys::fs::exists(Twine(TempPath))); 1173 1174 // Open the file for read 1175 int FileDescriptor2; 1176 SmallString<64> ResultPath; 1177 ASSERT_NO_ERROR( 1178 fs::openFileForRead(Twine(TempPath), FileDescriptor2, &ResultPath)) 1179 1180 // If we succeeded, check that the paths are the same (modulo case): 1181 if (!ResultPath.empty()) { 1182 // The paths returned by createTemporaryFile and getPathFromOpenFD 1183 // should reference the same file on disk. 1184 fs::UniqueID D1, D2; 1185 ASSERT_NO_ERROR(fs::getUniqueID(Twine(TempPath), D1)); 1186 ASSERT_NO_ERROR(fs::getUniqueID(Twine(ResultPath), D2)); 1187 ASSERT_EQ(D1, D2); 1188 } 1189 1190 ::close(FileDescriptor); 1191 } 1192 1193 TEST_F(FileSystemTest, set_current_path) { 1194 SmallString<128> path; 1195 1196 ASSERT_NO_ERROR(fs::current_path(path)); 1197 ASSERT_NE(TestDirectory, path); 1198 1199 struct RestorePath { 1200 SmallString<128> path; 1201 RestorePath(const SmallString<128> &path) : path(path) {} 1202 ~RestorePath() { fs::set_current_path(path); } 1203 } restore_path(path); 1204 1205 ASSERT_NO_ERROR(fs::set_current_path(TestDirectory)); 1206 1207 ASSERT_NO_ERROR(fs::current_path(path)); 1208 1209 fs::UniqueID D1, D2; 1210 ASSERT_NO_ERROR(fs::getUniqueID(TestDirectory, D1)); 1211 ASSERT_NO_ERROR(fs::getUniqueID(path, D2)); 1212 ASSERT_EQ(D1, D2) << "D1: " << TestDirectory << "\nD2: " << path; 1213 } 1214 1215 TEST_F(FileSystemTest, permissions) { 1216 int FD; 1217 SmallString<64> TempPath; 1218 ASSERT_NO_ERROR(fs::createTemporaryFile("prefix", "temp", FD, TempPath)); 1219 FileRemover Cleanup(TempPath); 1220 1221 // Make sure it exists. 1222 ASSERT_TRUE(fs::exists(Twine(TempPath))); 1223 1224 auto CheckPermissions = [&](fs::perms Expected) { 1225 ErrorOr<fs::perms> Actual = fs::getPermissions(TempPath); 1226 return Actual && *Actual == Expected; 1227 }; 1228 1229 std::error_code NoError; 1230 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_all), NoError); 1231 EXPECT_TRUE(CheckPermissions(fs::all_all)); 1232 1233 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read | fs::all_exe), NoError); 1234 EXPECT_TRUE(CheckPermissions(fs::all_read | fs::all_exe)); 1235 1236 #if defined(LLVM_ON_WIN32) 1237 fs::perms ReadOnly = fs::all_read | fs::all_exe; 1238 EXPECT_EQ(fs::setPermissions(TempPath, fs::no_perms), NoError); 1239 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1240 1241 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_read), NoError); 1242 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1243 1244 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_write), NoError); 1245 EXPECT_TRUE(CheckPermissions(fs::all_all)); 1246 1247 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_exe), NoError); 1248 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1249 1250 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_all), NoError); 1251 EXPECT_TRUE(CheckPermissions(fs::all_all)); 1252 1253 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_read), NoError); 1254 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1255 1256 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_write), NoError); 1257 EXPECT_TRUE(CheckPermissions(fs::all_all)); 1258 1259 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_exe), NoError); 1260 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1261 1262 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_all), NoError); 1263 EXPECT_TRUE(CheckPermissions(fs::all_all)); 1264 1265 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_read), NoError); 1266 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1267 1268 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_write), NoError); 1269 EXPECT_TRUE(CheckPermissions(fs::all_all)); 1270 1271 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_exe), NoError); 1272 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1273 1274 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_all), NoError); 1275 EXPECT_TRUE(CheckPermissions(fs::all_all)); 1276 1277 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read), NoError); 1278 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1279 1280 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_write), NoError); 1281 EXPECT_TRUE(CheckPermissions(fs::all_all)); 1282 1283 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_exe), NoError); 1284 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1285 1286 EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe), NoError); 1287 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1288 1289 EXPECT_EQ(fs::setPermissions(TempPath, fs::set_gid_on_exe), NoError); 1290 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1291 1292 EXPECT_EQ(fs::setPermissions(TempPath, fs::sticky_bit), NoError); 1293 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1294 1295 EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe | 1296 fs::set_gid_on_exe | 1297 fs::sticky_bit), 1298 NoError); 1299 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1300 1301 EXPECT_EQ(fs::setPermissions(TempPath, ReadOnly | fs::set_uid_on_exe | 1302 fs::set_gid_on_exe | 1303 fs::sticky_bit), 1304 NoError); 1305 EXPECT_TRUE(CheckPermissions(ReadOnly)); 1306 1307 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms), NoError); 1308 EXPECT_TRUE(CheckPermissions(fs::all_all)); 1309 #else 1310 EXPECT_EQ(fs::setPermissions(TempPath, fs::no_perms), NoError); 1311 EXPECT_TRUE(CheckPermissions(fs::no_perms)); 1312 1313 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_read), NoError); 1314 EXPECT_TRUE(CheckPermissions(fs::owner_read)); 1315 1316 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_write), NoError); 1317 EXPECT_TRUE(CheckPermissions(fs::owner_write)); 1318 1319 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_exe), NoError); 1320 EXPECT_TRUE(CheckPermissions(fs::owner_exe)); 1321 1322 EXPECT_EQ(fs::setPermissions(TempPath, fs::owner_all), NoError); 1323 EXPECT_TRUE(CheckPermissions(fs::owner_all)); 1324 1325 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_read), NoError); 1326 EXPECT_TRUE(CheckPermissions(fs::group_read)); 1327 1328 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_write), NoError); 1329 EXPECT_TRUE(CheckPermissions(fs::group_write)); 1330 1331 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_exe), NoError); 1332 EXPECT_TRUE(CheckPermissions(fs::group_exe)); 1333 1334 EXPECT_EQ(fs::setPermissions(TempPath, fs::group_all), NoError); 1335 EXPECT_TRUE(CheckPermissions(fs::group_all)); 1336 1337 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_read), NoError); 1338 EXPECT_TRUE(CheckPermissions(fs::others_read)); 1339 1340 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_write), NoError); 1341 EXPECT_TRUE(CheckPermissions(fs::others_write)); 1342 1343 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_exe), NoError); 1344 EXPECT_TRUE(CheckPermissions(fs::others_exe)); 1345 1346 EXPECT_EQ(fs::setPermissions(TempPath, fs::others_all), NoError); 1347 EXPECT_TRUE(CheckPermissions(fs::others_all)); 1348 1349 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read), NoError); 1350 EXPECT_TRUE(CheckPermissions(fs::all_read)); 1351 1352 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_write), NoError); 1353 EXPECT_TRUE(CheckPermissions(fs::all_write)); 1354 1355 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_exe), NoError); 1356 EXPECT_TRUE(CheckPermissions(fs::all_exe)); 1357 1358 EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe), NoError); 1359 EXPECT_TRUE(CheckPermissions(fs::set_uid_on_exe)); 1360 1361 EXPECT_EQ(fs::setPermissions(TempPath, fs::set_gid_on_exe), NoError); 1362 EXPECT_TRUE(CheckPermissions(fs::set_gid_on_exe)); 1363 1364 // Modern BSDs require root to set the sticky bit on files. 1365 #if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) 1366 EXPECT_EQ(fs::setPermissions(TempPath, fs::sticky_bit), NoError); 1367 EXPECT_TRUE(CheckPermissions(fs::sticky_bit)); 1368 1369 EXPECT_EQ(fs::setPermissions(TempPath, fs::set_uid_on_exe | 1370 fs::set_gid_on_exe | 1371 fs::sticky_bit), 1372 NoError); 1373 EXPECT_TRUE(CheckPermissions(fs::set_uid_on_exe | fs::set_gid_on_exe | 1374 fs::sticky_bit)); 1375 1376 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_read | fs::set_uid_on_exe | 1377 fs::set_gid_on_exe | 1378 fs::sticky_bit), 1379 NoError); 1380 EXPECT_TRUE(CheckPermissions(fs::all_read | fs::set_uid_on_exe | 1381 fs::set_gid_on_exe | fs::sticky_bit)); 1382 1383 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms), NoError); 1384 EXPECT_TRUE(CheckPermissions(fs::all_perms)); 1385 #endif // !FreeBSD && !NetBSD && !OpenBSD 1386 1387 EXPECT_EQ(fs::setPermissions(TempPath, fs::all_perms & ~fs::sticky_bit), 1388 NoError); 1389 EXPECT_TRUE(CheckPermissions(fs::all_perms & ~fs::sticky_bit)); 1390 #endif 1391 } 1392 1393 } // anonymous namespace 1394