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