1 //===- unittests/Support/VirtualFileSystem.cpp -------------- VFS tests ---===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/Support/VirtualFileSystem.h" 10 #include "llvm/ADT/Triple.h" 11 #include "llvm/Config/llvm-config.h" 12 #include "llvm/Support/Errc.h" 13 #include "llvm/Support/Host.h" 14 #include "llvm/Support/MemoryBuffer.h" 15 #include "llvm/Support/Path.h" 16 #include "llvm/Support/SourceMgr.h" 17 #include "gmock/gmock.h" 18 #include "gtest/gtest.h" 19 #include <map> 20 #include <string> 21 22 using namespace llvm; 23 using llvm::sys::fs::UniqueID; 24 using testing::ElementsAre; 25 using testing::Pair; 26 using testing::UnorderedElementsAre; 27 28 namespace { 29 struct DummyFile : public vfs::File { 30 vfs::Status S; 31 explicit DummyFile(vfs::Status S) : S(S) {} 32 llvm::ErrorOr<vfs::Status> status() override { return S; } 33 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> 34 getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator, 35 bool IsVolatile) override { 36 llvm_unreachable("unimplemented"); 37 } 38 std::error_code close() override { return std::error_code(); } 39 }; 40 41 class DummyFileSystem : public vfs::FileSystem { 42 int FSID; // used to produce UniqueIDs 43 int FileID; // used to produce UniqueIDs 44 std::map<std::string, vfs::Status> FilesAndDirs; 45 46 static int getNextFSID() { 47 static int Count = 0; 48 return Count++; 49 } 50 51 public: 52 DummyFileSystem() : FSID(getNextFSID()), FileID(0) {} 53 54 ErrorOr<vfs::Status> status(const Twine &Path) override { 55 std::map<std::string, vfs::Status>::iterator I = 56 FilesAndDirs.find(Path.str()); 57 if (I == FilesAndDirs.end()) 58 return make_error_code(llvm::errc::no_such_file_or_directory); 59 return I->second; 60 } 61 ErrorOr<std::unique_ptr<vfs::File>> 62 openFileForRead(const Twine &Path) override { 63 auto S = status(Path); 64 if (S) 65 return std::unique_ptr<vfs::File>(new DummyFile{*S}); 66 return S.getError(); 67 } 68 llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override { 69 return std::string(); 70 } 71 std::error_code setCurrentWorkingDirectory(const Twine &Path) override { 72 return std::error_code(); 73 } 74 // Map any symlink to "/symlink". 75 std::error_code getRealPath(const Twine &Path, 76 SmallVectorImpl<char> &Output) const override { 77 auto I = FilesAndDirs.find(Path.str()); 78 if (I == FilesAndDirs.end()) 79 return make_error_code(llvm::errc::no_such_file_or_directory); 80 if (I->second.isSymlink()) { 81 Output.clear(); 82 Twine("/symlink").toVector(Output); 83 return std::error_code(); 84 } 85 Output.clear(); 86 Path.toVector(Output); 87 return std::error_code(); 88 } 89 90 struct DirIterImpl : public llvm::vfs::detail::DirIterImpl { 91 std::map<std::string, vfs::Status> &FilesAndDirs; 92 std::map<std::string, vfs::Status>::iterator I; 93 std::string Path; 94 bool isInPath(StringRef S) { 95 if (Path.size() < S.size() && S.find(Path) == 0) { 96 auto LastSep = S.find_last_of('/'); 97 if (LastSep == Path.size() || LastSep == Path.size() - 1) 98 return true; 99 } 100 return false; 101 } 102 DirIterImpl(std::map<std::string, vfs::Status> &FilesAndDirs, 103 const Twine &_Path) 104 : FilesAndDirs(FilesAndDirs), I(FilesAndDirs.begin()), 105 Path(_Path.str()) { 106 for (; I != FilesAndDirs.end(); ++I) { 107 if (isInPath(I->first)) { 108 CurrentEntry = 109 vfs::directory_entry(I->second.getName(), I->second.getType()); 110 break; 111 } 112 } 113 } 114 std::error_code increment() override { 115 ++I; 116 for (; I != FilesAndDirs.end(); ++I) { 117 if (isInPath(I->first)) { 118 CurrentEntry = 119 vfs::directory_entry(I->second.getName(), I->second.getType()); 120 break; 121 } 122 } 123 if (I == FilesAndDirs.end()) 124 CurrentEntry = vfs::directory_entry(); 125 return std::error_code(); 126 } 127 }; 128 129 vfs::directory_iterator dir_begin(const Twine &Dir, 130 std::error_code &EC) override { 131 return vfs::directory_iterator( 132 std::make_shared<DirIterImpl>(FilesAndDirs, Dir)); 133 } 134 135 void addEntry(StringRef Path, const vfs::Status &Status) { 136 FilesAndDirs[Path] = Status; 137 } 138 139 void addRegularFile(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) { 140 vfs::Status S(Path, UniqueID(FSID, FileID++), 141 std::chrono::system_clock::now(), 0, 0, 1024, 142 sys::fs::file_type::regular_file, Perms); 143 addEntry(Path, S); 144 } 145 146 void addDirectory(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) { 147 vfs::Status S(Path, UniqueID(FSID, FileID++), 148 std::chrono::system_clock::now(), 0, 0, 0, 149 sys::fs::file_type::directory_file, Perms); 150 addEntry(Path, S); 151 } 152 153 void addSymlink(StringRef Path) { 154 vfs::Status S(Path, UniqueID(FSID, FileID++), 155 std::chrono::system_clock::now(), 0, 0, 0, 156 sys::fs::file_type::symlink_file, sys::fs::all_all); 157 addEntry(Path, S); 158 } 159 }; 160 161 /// Replace back-slashes by front-slashes. 162 std::string getPosixPath(std::string S) { 163 SmallString<128> Result; 164 llvm::sys::path::native(S, Result, llvm::sys::path::Style::posix); 165 return Result.str(); 166 } 167 } // end anonymous namespace 168 169 TEST(VirtualFileSystemTest, StatusQueries) { 170 IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem()); 171 ErrorOr<vfs::Status> Status((std::error_code())); 172 173 D->addRegularFile("/foo"); 174 Status = D->status("/foo"); 175 ASSERT_FALSE(Status.getError()); 176 EXPECT_TRUE(Status->isStatusKnown()); 177 EXPECT_FALSE(Status->isDirectory()); 178 EXPECT_TRUE(Status->isRegularFile()); 179 EXPECT_FALSE(Status->isSymlink()); 180 EXPECT_FALSE(Status->isOther()); 181 EXPECT_TRUE(Status->exists()); 182 183 D->addDirectory("/bar"); 184 Status = D->status("/bar"); 185 ASSERT_FALSE(Status.getError()); 186 EXPECT_TRUE(Status->isStatusKnown()); 187 EXPECT_TRUE(Status->isDirectory()); 188 EXPECT_FALSE(Status->isRegularFile()); 189 EXPECT_FALSE(Status->isSymlink()); 190 EXPECT_FALSE(Status->isOther()); 191 EXPECT_TRUE(Status->exists()); 192 193 D->addSymlink("/baz"); 194 Status = D->status("/baz"); 195 ASSERT_FALSE(Status.getError()); 196 EXPECT_TRUE(Status->isStatusKnown()); 197 EXPECT_FALSE(Status->isDirectory()); 198 EXPECT_FALSE(Status->isRegularFile()); 199 EXPECT_TRUE(Status->isSymlink()); 200 EXPECT_FALSE(Status->isOther()); 201 EXPECT_TRUE(Status->exists()); 202 203 EXPECT_TRUE(Status->equivalent(*Status)); 204 ErrorOr<vfs::Status> Status2 = D->status("/foo"); 205 ASSERT_FALSE(Status2.getError()); 206 EXPECT_FALSE(Status->equivalent(*Status2)); 207 } 208 209 TEST(VirtualFileSystemTest, BaseOnlyOverlay) { 210 IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem()); 211 ErrorOr<vfs::Status> Status((std::error_code())); 212 EXPECT_FALSE(Status = D->status("/foo")); 213 214 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(new vfs::OverlayFileSystem(D)); 215 EXPECT_FALSE(Status = O->status("/foo")); 216 217 D->addRegularFile("/foo"); 218 Status = D->status("/foo"); 219 EXPECT_FALSE(Status.getError()); 220 221 ErrorOr<vfs::Status> Status2((std::error_code())); 222 Status2 = O->status("/foo"); 223 EXPECT_FALSE(Status2.getError()); 224 EXPECT_TRUE(Status->equivalent(*Status2)); 225 } 226 227 TEST(VirtualFileSystemTest, GetRealPathInOverlay) { 228 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 229 Lower->addRegularFile("/foo"); 230 Lower->addSymlink("/lower_link"); 231 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); 232 233 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 234 new vfs::OverlayFileSystem(Lower)); 235 O->pushOverlay(Upper); 236 237 // Regular file. 238 SmallString<16> RealPath; 239 EXPECT_FALSE(O->getRealPath("/foo", RealPath)); 240 EXPECT_EQ(RealPath.str(), "/foo"); 241 242 // Expect no error getting real path for symlink in lower overlay. 243 EXPECT_FALSE(O->getRealPath("/lower_link", RealPath)); 244 EXPECT_EQ(RealPath.str(), "/symlink"); 245 246 // Try a non-existing link. 247 EXPECT_EQ(O->getRealPath("/upper_link", RealPath), 248 errc::no_such_file_or_directory); 249 250 // Add a new symlink in upper. 251 Upper->addSymlink("/upper_link"); 252 EXPECT_FALSE(O->getRealPath("/upper_link", RealPath)); 253 EXPECT_EQ(RealPath.str(), "/symlink"); 254 } 255 256 TEST(VirtualFileSystemTest, OverlayFiles) { 257 IntrusiveRefCntPtr<DummyFileSystem> Base(new DummyFileSystem()); 258 IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem()); 259 IntrusiveRefCntPtr<DummyFileSystem> Top(new DummyFileSystem()); 260 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 261 new vfs::OverlayFileSystem(Base)); 262 O->pushOverlay(Middle); 263 O->pushOverlay(Top); 264 265 ErrorOr<vfs::Status> Status1((std::error_code())), 266 Status2((std::error_code())), Status3((std::error_code())), 267 StatusB((std::error_code())), StatusM((std::error_code())), 268 StatusT((std::error_code())); 269 270 Base->addRegularFile("/foo"); 271 StatusB = Base->status("/foo"); 272 ASSERT_FALSE(StatusB.getError()); 273 Status1 = O->status("/foo"); 274 ASSERT_FALSE(Status1.getError()); 275 Middle->addRegularFile("/foo"); 276 StatusM = Middle->status("/foo"); 277 ASSERT_FALSE(StatusM.getError()); 278 Status2 = O->status("/foo"); 279 ASSERT_FALSE(Status2.getError()); 280 Top->addRegularFile("/foo"); 281 StatusT = Top->status("/foo"); 282 ASSERT_FALSE(StatusT.getError()); 283 Status3 = O->status("/foo"); 284 ASSERT_FALSE(Status3.getError()); 285 286 EXPECT_TRUE(Status1->equivalent(*StatusB)); 287 EXPECT_TRUE(Status2->equivalent(*StatusM)); 288 EXPECT_TRUE(Status3->equivalent(*StatusT)); 289 290 EXPECT_FALSE(Status1->equivalent(*Status2)); 291 EXPECT_FALSE(Status2->equivalent(*Status3)); 292 EXPECT_FALSE(Status1->equivalent(*Status3)); 293 } 294 295 TEST(VirtualFileSystemTest, OverlayDirsNonMerged) { 296 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 297 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); 298 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 299 new vfs::OverlayFileSystem(Lower)); 300 O->pushOverlay(Upper); 301 302 Lower->addDirectory("/lower-only"); 303 Upper->addDirectory("/upper-only"); 304 305 // non-merged paths should be the same 306 ErrorOr<vfs::Status> Status1 = Lower->status("/lower-only"); 307 ASSERT_FALSE(Status1.getError()); 308 ErrorOr<vfs::Status> Status2 = O->status("/lower-only"); 309 ASSERT_FALSE(Status2.getError()); 310 EXPECT_TRUE(Status1->equivalent(*Status2)); 311 312 Status1 = Upper->status("/upper-only"); 313 ASSERT_FALSE(Status1.getError()); 314 Status2 = O->status("/upper-only"); 315 ASSERT_FALSE(Status2.getError()); 316 EXPECT_TRUE(Status1->equivalent(*Status2)); 317 } 318 319 TEST(VirtualFileSystemTest, MergedDirPermissions) { 320 // merged directories get the permissions of the upper dir 321 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 322 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); 323 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 324 new vfs::OverlayFileSystem(Lower)); 325 O->pushOverlay(Upper); 326 327 ErrorOr<vfs::Status> Status((std::error_code())); 328 Lower->addDirectory("/both", sys::fs::owner_read); 329 Upper->addDirectory("/both", sys::fs::owner_all | sys::fs::group_read); 330 Status = O->status("/both"); 331 ASSERT_FALSE(Status.getError()); 332 EXPECT_EQ(0740, Status->getPermissions()); 333 334 // permissions (as usual) are not recursively applied 335 Lower->addRegularFile("/both/foo", sys::fs::owner_read); 336 Upper->addRegularFile("/both/bar", sys::fs::owner_write); 337 Status = O->status("/both/foo"); 338 ASSERT_FALSE(Status.getError()); 339 EXPECT_EQ(0400, Status->getPermissions()); 340 Status = O->status("/both/bar"); 341 ASSERT_FALSE(Status.getError()); 342 EXPECT_EQ(0200, Status->getPermissions()); 343 } 344 345 TEST(VirtualFileSystemTest, OverlayIterator) { 346 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 347 Lower->addRegularFile("/foo"); 348 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); 349 350 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 351 new vfs::OverlayFileSystem(Lower)); 352 O->pushOverlay(Upper); 353 354 ErrorOr<vfs::Status> Status((std::error_code())); 355 { 356 auto it = O->overlays_begin(); 357 auto end = O->overlays_end(); 358 359 EXPECT_NE(it, end); 360 361 Status = (*it)->status("/foo"); 362 ASSERT_TRUE(Status.getError()); 363 364 it++; 365 EXPECT_NE(it, end); 366 367 Status = (*it)->status("/foo"); 368 ASSERT_FALSE(Status.getError()); 369 EXPECT_TRUE(Status->exists()); 370 371 it++; 372 EXPECT_EQ(it, end); 373 } 374 375 { 376 auto it = O->overlays_rbegin(); 377 auto end = O->overlays_rend(); 378 379 EXPECT_NE(it, end); 380 381 Status = (*it)->status("/foo"); 382 ASSERT_FALSE(Status.getError()); 383 EXPECT_TRUE(Status->exists()); 384 385 it++; 386 EXPECT_NE(it, end); 387 388 Status = (*it)->status("/foo"); 389 ASSERT_TRUE(Status.getError()); 390 391 it++; 392 EXPECT_EQ(it, end); 393 } 394 } 395 396 namespace { 397 struct ScopedDir { 398 SmallString<128> Path; 399 ScopedDir(const Twine &Name, bool Unique = false) { 400 std::error_code EC; 401 if (Unique) { 402 EC = llvm::sys::fs::createUniqueDirectory(Name, Path); 403 if (!EC) { 404 // Resolve any symlinks in the new directory. 405 std::string UnresolvedPath = Path.str(); 406 EC = llvm::sys::fs::real_path(UnresolvedPath, Path); 407 } 408 } else { 409 Path = Name.str(); 410 EC = llvm::sys::fs::create_directory(Twine(Path)); 411 } 412 if (EC) 413 Path = ""; 414 EXPECT_FALSE(EC) << EC.message(); 415 } 416 ~ScopedDir() { 417 if (Path != "") { 418 EXPECT_FALSE(llvm::sys::fs::remove(Path.str())); 419 } 420 } 421 operator StringRef() { return Path.str(); } 422 }; 423 424 struct ScopedLink { 425 SmallString<128> Path; 426 ScopedLink(const Twine &To, const Twine &From) { 427 Path = From.str(); 428 std::error_code EC = sys::fs::create_link(To, From); 429 if (EC) 430 Path = ""; 431 EXPECT_FALSE(EC); 432 } 433 ~ScopedLink() { 434 if (Path != "") { 435 EXPECT_FALSE(llvm::sys::fs::remove(Path.str())); 436 } 437 } 438 operator StringRef() { return Path.str(); } 439 }; 440 441 struct ScopedFile { 442 SmallString<128> Path; 443 ScopedFile(const Twine &Path, StringRef Contents) { 444 Path.toVector(this->Path); 445 std::error_code EC; 446 raw_fd_ostream OS(this->Path, EC); 447 EXPECT_FALSE(EC); 448 OS << Contents; 449 OS.flush(); 450 EXPECT_FALSE(OS.error()); 451 if (EC || OS.error()) 452 this->Path = ""; 453 } 454 ~ScopedFile() { 455 if (Path != "") { 456 EXPECT_FALSE(llvm::sys::fs::remove(Path.str())); 457 } 458 } 459 }; 460 } // end anonymous namespace 461 462 TEST(VirtualFileSystemTest, BasicRealFSIteration) { 463 ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true); 464 IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem(); 465 466 std::error_code EC; 467 vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory), EC); 468 ASSERT_FALSE(EC); 469 EXPECT_EQ(vfs::directory_iterator(), I); // empty directory is empty 470 471 ScopedDir _a(TestDirectory + "/a"); 472 ScopedDir _ab(TestDirectory + "/a/b"); 473 ScopedDir _c(TestDirectory + "/c"); 474 ScopedDir _cd(TestDirectory + "/c/d"); 475 476 I = FS->dir_begin(Twine(TestDirectory), EC); 477 ASSERT_FALSE(EC); 478 ASSERT_NE(vfs::directory_iterator(), I); 479 // Check either a or c, since we can't rely on the iteration order. 480 EXPECT_TRUE(I->path().endswith("a") || I->path().endswith("c")); 481 I.increment(EC); 482 ASSERT_FALSE(EC); 483 ASSERT_NE(vfs::directory_iterator(), I); 484 EXPECT_TRUE(I->path().endswith("a") || I->path().endswith("c")); 485 I.increment(EC); 486 EXPECT_EQ(vfs::directory_iterator(), I); 487 } 488 489 #ifdef LLVM_ON_UNIX 490 TEST(VirtualFileSystemTest, MultipleWorkingDirs) { 491 // Our root contains a/aa, b/bb, c, where c is a link to a/. 492 // Run tests both in root/b/ and root/c/ (to test "normal" and symlink dirs). 493 // Interleave operations to show the working directories are independent. 494 ScopedDir Root("r", true), ADir(Root.Path + "/a"), BDir(Root.Path + "/b"); 495 ScopedLink C(ADir.Path, Root.Path + "/c"); 496 ScopedFile AA(ADir.Path + "/aa", "aaaa"), BB(BDir.Path + "/bb", "bbbb"); 497 std::unique_ptr<vfs::FileSystem> BFS = vfs::createPhysicalFileSystem(), 498 CFS = vfs::createPhysicalFileSystem(); 499 500 ASSERT_FALSE(BFS->setCurrentWorkingDirectory(BDir.Path)); 501 ASSERT_FALSE(CFS->setCurrentWorkingDirectory(C.Path)); 502 EXPECT_EQ(BDir.Path, *BFS->getCurrentWorkingDirectory()); 503 EXPECT_EQ(C.Path, *CFS->getCurrentWorkingDirectory()); 504 505 // openFileForRead(), indirectly. 506 auto BBuf = BFS->getBufferForFile("bb"); 507 ASSERT_TRUE(BBuf); 508 EXPECT_EQ("bbbb", (*BBuf)->getBuffer()); 509 510 auto ABuf = CFS->getBufferForFile("aa"); 511 ASSERT_TRUE(ABuf); 512 EXPECT_EQ("aaaa", (*ABuf)->getBuffer()); 513 514 // status() 515 auto BStat = BFS->status("bb"); 516 ASSERT_TRUE(BStat); 517 EXPECT_EQ("bb", BStat->getName()); 518 519 auto AStat = CFS->status("aa"); 520 ASSERT_TRUE(AStat); 521 EXPECT_EQ("aa", AStat->getName()); // unresolved name 522 523 // getRealPath() 524 SmallString<128> BPath; 525 ASSERT_FALSE(BFS->getRealPath("bb", BPath)); 526 EXPECT_EQ(BB.Path, BPath); 527 528 SmallString<128> APath; 529 ASSERT_FALSE(CFS->getRealPath("aa", APath)); 530 EXPECT_EQ(AA.Path, APath); // Reports resolved name. 531 532 // dir_begin 533 std::error_code EC; 534 auto BIt = BFS->dir_begin(".", EC); 535 ASSERT_FALSE(EC); 536 ASSERT_NE(BIt, vfs::directory_iterator()); 537 EXPECT_EQ((BDir.Path + "/./bb").str(), BIt->path()); 538 BIt.increment(EC); 539 ASSERT_FALSE(EC); 540 ASSERT_EQ(BIt, vfs::directory_iterator()); 541 542 auto CIt = CFS->dir_begin(".", EC); 543 ASSERT_FALSE(EC); 544 ASSERT_NE(CIt, vfs::directory_iterator()); 545 EXPECT_EQ((ADir.Path + "/./aa").str(), CIt->path()); // Partly resolved name! 546 CIt.increment(EC); // Because likely to read through this path. 547 ASSERT_FALSE(EC); 548 ASSERT_EQ(CIt, vfs::directory_iterator()); 549 } 550 551 TEST(VirtualFileSystemTest, BrokenSymlinkRealFSIteration) { 552 ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true); 553 IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem(); 554 555 ScopedLink _a("no_such_file", TestDirectory + "/a"); 556 ScopedDir _b(TestDirectory + "/b"); 557 ScopedLink _c("no_such_file", TestDirectory + "/c"); 558 559 // Should get no iteration error, but a stat error for the broken symlinks. 560 std::map<std::string, std::error_code> StatResults; 561 std::error_code EC; 562 for (vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory), EC), E; 563 I != E; I.increment(EC)) { 564 EXPECT_FALSE(EC); 565 StatResults[sys::path::filename(I->path())] = 566 FS->status(I->path()).getError(); 567 } 568 EXPECT_THAT( 569 StatResults, 570 ElementsAre( 571 Pair("a", std::make_error_code(std::errc::no_such_file_or_directory)), 572 Pair("b", std::error_code()), 573 Pair("c", 574 std::make_error_code(std::errc::no_such_file_or_directory)))); 575 } 576 #endif 577 578 TEST(VirtualFileSystemTest, BasicRealFSRecursiveIteration) { 579 ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true); 580 IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem(); 581 582 std::error_code EC; 583 auto I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC); 584 ASSERT_FALSE(EC); 585 EXPECT_EQ(vfs::recursive_directory_iterator(), I); // empty directory is empty 586 587 ScopedDir _a(TestDirectory + "/a"); 588 ScopedDir _ab(TestDirectory + "/a/b"); 589 ScopedDir _c(TestDirectory + "/c"); 590 ScopedDir _cd(TestDirectory + "/c/d"); 591 592 I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC); 593 ASSERT_FALSE(EC); 594 ASSERT_NE(vfs::recursive_directory_iterator(), I); 595 596 std::vector<std::string> Contents; 597 for (auto E = vfs::recursive_directory_iterator(); !EC && I != E; 598 I.increment(EC)) { 599 Contents.push_back(I->path()); 600 } 601 602 // Check contents, which may be in any order 603 EXPECT_EQ(4U, Contents.size()); 604 int Counts[4] = {0, 0, 0, 0}; 605 for (const std::string &Name : Contents) { 606 ASSERT_FALSE(Name.empty()); 607 int Index = Name[Name.size() - 1] - 'a'; 608 ASSERT_TRUE(Index >= 0 && Index < 4); 609 Counts[Index]++; 610 } 611 EXPECT_EQ(1, Counts[0]); // a 612 EXPECT_EQ(1, Counts[1]); // b 613 EXPECT_EQ(1, Counts[2]); // c 614 EXPECT_EQ(1, Counts[3]); // d 615 } 616 617 TEST(VirtualFileSystemTest, BasicRealFSRecursiveIterationNoPush) { 618 ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true); 619 620 ScopedDir _a(TestDirectory + "/a"); 621 ScopedDir _ab(TestDirectory + "/a/b"); 622 ScopedDir _c(TestDirectory + "/c"); 623 ScopedDir _cd(TestDirectory + "/c/d"); 624 ScopedDir _e(TestDirectory + "/e"); 625 ScopedDir _ef(TestDirectory + "/e/f"); 626 ScopedDir _g(TestDirectory + "/g"); 627 628 IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem(); 629 630 // Test that calling no_push on entries without subdirectories has no effect. 631 { 632 std::error_code EC; 633 auto I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC); 634 ASSERT_FALSE(EC); 635 636 std::vector<std::string> Contents; 637 for (auto E = vfs::recursive_directory_iterator(); !EC && I != E; 638 I.increment(EC)) { 639 Contents.push_back(I->path()); 640 char last = I->path().back(); 641 switch (last) { 642 case 'b': 643 case 'd': 644 case 'f': 645 case 'g': 646 I.no_push(); 647 break; 648 default: 649 break; 650 } 651 } 652 EXPECT_EQ(7U, Contents.size()); 653 } 654 655 // Test that calling no_push skips subdirectories. 656 { 657 std::error_code EC; 658 auto I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC); 659 ASSERT_FALSE(EC); 660 661 std::vector<std::string> Contents; 662 for (auto E = vfs::recursive_directory_iterator(); !EC && I != E; 663 I.increment(EC)) { 664 Contents.push_back(I->path()); 665 char last = I->path().back(); 666 switch (last) { 667 case 'a': 668 case 'c': 669 case 'e': 670 I.no_push(); 671 break; 672 default: 673 break; 674 } 675 } 676 677 // Check contents, which may be in any order 678 EXPECT_EQ(4U, Contents.size()); 679 int Counts[7] = {0, 0, 0, 0, 0, 0, 0}; 680 for (const std::string &Name : Contents) { 681 ASSERT_FALSE(Name.empty()); 682 int Index = Name[Name.size() - 1] - 'a'; 683 ASSERT_TRUE(Index >= 0 && Index < 7); 684 Counts[Index]++; 685 } 686 EXPECT_EQ(1, Counts[0]); // a 687 EXPECT_EQ(0, Counts[1]); // b 688 EXPECT_EQ(1, Counts[2]); // c 689 EXPECT_EQ(0, Counts[3]); // d 690 EXPECT_EQ(1, Counts[4]); // e 691 EXPECT_EQ(0, Counts[5]); // f 692 EXPECT_EQ(1, Counts[6]); // g 693 } 694 } 695 696 #ifdef LLVM_ON_UNIX 697 TEST(VirtualFileSystemTest, BrokenSymlinkRealFSRecursiveIteration) { 698 ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/ true); 699 IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem(); 700 701 ScopedLink _a("no_such_file", TestDirectory + "/a"); 702 ScopedDir _b(TestDirectory + "/b"); 703 ScopedLink _ba("no_such_file", TestDirectory + "/b/a"); 704 ScopedDir _bb(TestDirectory + "/b/b"); 705 ScopedLink _bc("no_such_file", TestDirectory + "/b/c"); 706 ScopedLink _c("no_such_file", TestDirectory + "/c"); 707 ScopedDir _d(TestDirectory + "/d"); 708 ScopedDir _dd(TestDirectory + "/d/d"); 709 ScopedDir _ddd(TestDirectory + "/d/d/d"); 710 ScopedLink _e("no_such_file", TestDirectory + "/e"); 711 712 std::vector<std::string> VisitedBrokenSymlinks; 713 std::vector<std::string> VisitedNonBrokenSymlinks; 714 std::error_code EC; 715 for (vfs::recursive_directory_iterator I(*FS, Twine(TestDirectory), EC), E; 716 I != E; I.increment(EC)) { 717 EXPECT_FALSE(EC); 718 (FS->status(I->path()) ? VisitedNonBrokenSymlinks : VisitedBrokenSymlinks) 719 .push_back(I->path()); 720 } 721 722 // Check visited file names. 723 EXPECT_THAT(VisitedBrokenSymlinks, 724 UnorderedElementsAre(StringRef(_a), StringRef(_ba), 725 StringRef(_bc), StringRef(_c), 726 StringRef(_e))); 727 EXPECT_THAT(VisitedNonBrokenSymlinks, 728 UnorderedElementsAre(StringRef(_b), StringRef(_bb), StringRef(_d), 729 StringRef(_dd), StringRef(_ddd))); 730 } 731 #endif 732 733 template <typename DirIter> 734 static void checkContents(DirIter I, ArrayRef<StringRef> ExpectedOut) { 735 std::error_code EC; 736 SmallVector<StringRef, 4> Expected(ExpectedOut.begin(), ExpectedOut.end()); 737 SmallVector<std::string, 4> InputToCheck; 738 739 // Do not rely on iteration order to check for contents, sort both 740 // content vectors before comparison. 741 for (DirIter E; !EC && I != E; I.increment(EC)) 742 InputToCheck.push_back(I->path()); 743 744 llvm::sort(InputToCheck); 745 llvm::sort(Expected); 746 EXPECT_EQ(InputToCheck.size(), Expected.size()); 747 748 unsigned LastElt = std::min(InputToCheck.size(), Expected.size()); 749 for (unsigned Idx = 0; Idx != LastElt; ++Idx) 750 EXPECT_EQ(StringRef(InputToCheck[Idx]), Expected[Idx]); 751 } 752 753 TEST(VirtualFileSystemTest, OverlayIteration) { 754 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 755 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); 756 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 757 new vfs::OverlayFileSystem(Lower)); 758 O->pushOverlay(Upper); 759 760 std::error_code EC; 761 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>()); 762 763 Lower->addRegularFile("/file1"); 764 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file1")); 765 766 Upper->addRegularFile("/file2"); 767 checkContents(O->dir_begin("/", EC), {"/file2", "/file1"}); 768 769 Lower->addDirectory("/dir1"); 770 Lower->addRegularFile("/dir1/foo"); 771 Upper->addDirectory("/dir2"); 772 Upper->addRegularFile("/dir2/foo"); 773 checkContents(O->dir_begin("/dir2", EC), ArrayRef<StringRef>("/dir2/foo")); 774 checkContents(O->dir_begin("/", EC), {"/dir2", "/file2", "/dir1", "/file1"}); 775 } 776 777 TEST(VirtualFileSystemTest, OverlayRecursiveIteration) { 778 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 779 IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem()); 780 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); 781 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 782 new vfs::OverlayFileSystem(Lower)); 783 O->pushOverlay(Middle); 784 O->pushOverlay(Upper); 785 786 std::error_code EC; 787 checkContents(vfs::recursive_directory_iterator(*O, "/", EC), 788 ArrayRef<StringRef>()); 789 790 Lower->addRegularFile("/file1"); 791 checkContents(vfs::recursive_directory_iterator(*O, "/", EC), 792 ArrayRef<StringRef>("/file1")); 793 794 Upper->addDirectory("/dir"); 795 Upper->addRegularFile("/dir/file2"); 796 checkContents(vfs::recursive_directory_iterator(*O, "/", EC), 797 {"/dir", "/dir/file2", "/file1"}); 798 799 Lower->addDirectory("/dir1"); 800 Lower->addRegularFile("/dir1/foo"); 801 Lower->addDirectory("/dir1/a"); 802 Lower->addRegularFile("/dir1/a/b"); 803 Middle->addDirectory("/a"); 804 Middle->addDirectory("/a/b"); 805 Middle->addDirectory("/a/b/c"); 806 Middle->addRegularFile("/a/b/c/d"); 807 Middle->addRegularFile("/hiddenByUp"); 808 Upper->addDirectory("/dir2"); 809 Upper->addRegularFile("/dir2/foo"); 810 Upper->addRegularFile("/hiddenByUp"); 811 checkContents(vfs::recursive_directory_iterator(*O, "/dir2", EC), 812 ArrayRef<StringRef>("/dir2/foo")); 813 checkContents(vfs::recursive_directory_iterator(*O, "/", EC), 814 {"/dir", "/dir/file2", "/dir2", "/dir2/foo", "/hiddenByUp", 815 "/a", "/a/b", "/a/b/c", "/a/b/c/d", "/dir1", "/dir1/a", 816 "/dir1/a/b", "/dir1/foo", "/file1"}); 817 } 818 819 TEST(VirtualFileSystemTest, ThreeLevelIteration) { 820 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 821 IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem()); 822 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); 823 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 824 new vfs::OverlayFileSystem(Lower)); 825 O->pushOverlay(Middle); 826 O->pushOverlay(Upper); 827 828 std::error_code EC; 829 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>()); 830 831 Middle->addRegularFile("/file2"); 832 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file2")); 833 834 Lower->addRegularFile("/file1"); 835 Upper->addRegularFile("/file3"); 836 checkContents(O->dir_begin("/", EC), {"/file3", "/file2", "/file1"}); 837 } 838 839 TEST(VirtualFileSystemTest, HiddenInIteration) { 840 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 841 IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem()); 842 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); 843 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 844 new vfs::OverlayFileSystem(Lower)); 845 O->pushOverlay(Middle); 846 O->pushOverlay(Upper); 847 848 std::error_code EC; 849 Lower->addRegularFile("/onlyInLow"); 850 Lower->addDirectory("/hiddenByMid"); 851 Lower->addDirectory("/hiddenByUp"); 852 Middle->addRegularFile("/onlyInMid"); 853 Middle->addRegularFile("/hiddenByMid"); 854 Middle->addDirectory("/hiddenByUp"); 855 Upper->addRegularFile("/onlyInUp"); 856 Upper->addRegularFile("/hiddenByUp"); 857 checkContents( 858 O->dir_begin("/", EC), 859 {"/hiddenByUp", "/onlyInUp", "/hiddenByMid", "/onlyInMid", "/onlyInLow"}); 860 861 // Make sure we get the top-most entry 862 { 863 std::error_code EC; 864 vfs::directory_iterator I = O->dir_begin("/", EC), E; 865 for (; !EC && I != E; I.increment(EC)) 866 if (I->path() == "/hiddenByUp") 867 break; 868 ASSERT_NE(E, I); 869 EXPECT_EQ(sys::fs::file_type::regular_file, I->type()); 870 } 871 { 872 std::error_code EC; 873 vfs::directory_iterator I = O->dir_begin("/", EC), E; 874 for (; !EC && I != E; I.increment(EC)) 875 if (I->path() == "/hiddenByMid") 876 break; 877 ASSERT_NE(E, I); 878 EXPECT_EQ(sys::fs::file_type::regular_file, I->type()); 879 } 880 } 881 882 TEST(ProxyFileSystemTest, Basic) { 883 IntrusiveRefCntPtr<vfs::InMemoryFileSystem> Base( 884 new vfs::InMemoryFileSystem()); 885 vfs::ProxyFileSystem PFS(Base); 886 887 Base->addFile("/a", 0, MemoryBuffer::getMemBuffer("test")); 888 889 auto Stat = PFS.status("/a"); 890 ASSERT_FALSE(Stat.getError()); 891 892 auto File = PFS.openFileForRead("/a"); 893 ASSERT_FALSE(File.getError()); 894 EXPECT_EQ("test", (*(*File)->getBuffer("ignored"))->getBuffer()); 895 896 std::error_code EC; 897 vfs::directory_iterator I = PFS.dir_begin("/", EC); 898 ASSERT_FALSE(EC); 899 ASSERT_EQ("/a", I->path()); 900 I.increment(EC); 901 ASSERT_FALSE(EC); 902 ASSERT_EQ(vfs::directory_iterator(), I); 903 904 ASSERT_FALSE(PFS.setCurrentWorkingDirectory("/")); 905 906 auto PWD = PFS.getCurrentWorkingDirectory(); 907 ASSERT_FALSE(PWD.getError()); 908 ASSERT_EQ("/", *PWD); 909 910 SmallString<16> Path; 911 ASSERT_FALSE(PFS.getRealPath("a", Path)); 912 ASSERT_EQ("/a", Path); 913 914 bool Local = true; 915 ASSERT_FALSE(PFS.isLocal("/a", Local)); 916 EXPECT_FALSE(Local); 917 } 918 919 class InMemoryFileSystemTest : public ::testing::Test { 920 protected: 921 llvm::vfs::InMemoryFileSystem FS; 922 llvm::vfs::InMemoryFileSystem NormalizedFS; 923 924 InMemoryFileSystemTest() 925 : FS(/*UseNormalizedPaths=*/false), 926 NormalizedFS(/*UseNormalizedPaths=*/true) {} 927 }; 928 929 MATCHER_P2(IsHardLinkTo, FS, Target, "") { 930 StringRef From = arg; 931 StringRef To = Target; 932 auto OpenedFrom = FS->openFileForRead(From); 933 auto OpenedTo = FS->openFileForRead(To); 934 return !OpenedFrom.getError() && !OpenedTo.getError() && 935 (*OpenedFrom)->status()->getUniqueID() == 936 (*OpenedTo)->status()->getUniqueID(); 937 } 938 939 TEST_F(InMemoryFileSystemTest, IsEmpty) { 940 auto Stat = FS.status("/a"); 941 ASSERT_EQ(Stat.getError(), errc::no_such_file_or_directory) << FS.toString(); 942 Stat = FS.status("/"); 943 ASSERT_EQ(Stat.getError(), errc::no_such_file_or_directory) << FS.toString(); 944 } 945 946 TEST_F(InMemoryFileSystemTest, WindowsPath) { 947 FS.addFile("c:/windows/system128/foo.cpp", 0, MemoryBuffer::getMemBuffer("")); 948 auto Stat = FS.status("c:"); 949 #if !defined(_WIN32) 950 ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString(); 951 #endif 952 Stat = FS.status("c:/windows/system128/foo.cpp"); 953 ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString(); 954 FS.addFile("d:/windows/foo.cpp", 0, MemoryBuffer::getMemBuffer("")); 955 Stat = FS.status("d:/windows/foo.cpp"); 956 ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString(); 957 } 958 959 TEST_F(InMemoryFileSystemTest, OverlayFile) { 960 FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")); 961 NormalizedFS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")); 962 auto Stat = FS.status("/"); 963 ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString(); 964 Stat = FS.status("/."); 965 ASSERT_FALSE(Stat); 966 Stat = NormalizedFS.status("/."); 967 ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString(); 968 Stat = FS.status("/a"); 969 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 970 ASSERT_EQ("/a", Stat->getName()); 971 } 972 973 TEST_F(InMemoryFileSystemTest, OverlayFileNoOwn) { 974 auto Buf = MemoryBuffer::getMemBuffer("a"); 975 FS.addFileNoOwn("/a", 0, Buf.get()); 976 auto Stat = FS.status("/a"); 977 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 978 ASSERT_EQ("/a", Stat->getName()); 979 } 980 981 TEST_F(InMemoryFileSystemTest, OpenFileForRead) { 982 FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")); 983 FS.addFile("././c", 0, MemoryBuffer::getMemBuffer("c")); 984 FS.addFile("./d/../d", 0, MemoryBuffer::getMemBuffer("d")); 985 NormalizedFS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")); 986 NormalizedFS.addFile("././c", 0, MemoryBuffer::getMemBuffer("c")); 987 NormalizedFS.addFile("./d/../d", 0, MemoryBuffer::getMemBuffer("d")); 988 auto File = FS.openFileForRead("/a"); 989 ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer()); 990 File = FS.openFileForRead("/a"); // Open again. 991 ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer()); 992 File = NormalizedFS.openFileForRead("/././a"); // Open again. 993 ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer()); 994 File = FS.openFileForRead("/"); 995 ASSERT_EQ(File.getError(), errc::invalid_argument) << FS.toString(); 996 File = FS.openFileForRead("/b"); 997 ASSERT_EQ(File.getError(), errc::no_such_file_or_directory) << FS.toString(); 998 File = FS.openFileForRead("./c"); 999 ASSERT_FALSE(File); 1000 File = FS.openFileForRead("e/../d"); 1001 ASSERT_FALSE(File); 1002 File = NormalizedFS.openFileForRead("./c"); 1003 ASSERT_EQ("c", (*(*File)->getBuffer("ignored"))->getBuffer()); 1004 File = NormalizedFS.openFileForRead("e/../d"); 1005 ASSERT_EQ("d", (*(*File)->getBuffer("ignored"))->getBuffer()); 1006 } 1007 1008 TEST_F(InMemoryFileSystemTest, DuplicatedFile) { 1009 ASSERT_TRUE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a"))); 1010 ASSERT_FALSE(FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("a"))); 1011 ASSERT_TRUE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a"))); 1012 ASSERT_FALSE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("b"))); 1013 } 1014 1015 TEST_F(InMemoryFileSystemTest, DirectoryIteration) { 1016 FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("")); 1017 FS.addFile("/b/c", 0, MemoryBuffer::getMemBuffer("")); 1018 1019 std::error_code EC; 1020 vfs::directory_iterator I = FS.dir_begin("/", EC); 1021 ASSERT_FALSE(EC); 1022 ASSERT_EQ("/a", I->path()); 1023 I.increment(EC); 1024 ASSERT_FALSE(EC); 1025 ASSERT_EQ("/b", I->path()); 1026 I.increment(EC); 1027 ASSERT_FALSE(EC); 1028 ASSERT_EQ(vfs::directory_iterator(), I); 1029 1030 I = FS.dir_begin("/b", EC); 1031 ASSERT_FALSE(EC); 1032 // When on Windows, we end up with "/b\\c" as the name. Convert to Posix 1033 // path for the sake of the comparison. 1034 ASSERT_EQ("/b/c", getPosixPath(I->path())); 1035 I.increment(EC); 1036 ASSERT_FALSE(EC); 1037 ASSERT_EQ(vfs::directory_iterator(), I); 1038 } 1039 1040 TEST_F(InMemoryFileSystemTest, WorkingDirectory) { 1041 FS.setCurrentWorkingDirectory("/b"); 1042 FS.addFile("c", 0, MemoryBuffer::getMemBuffer("")); 1043 1044 auto Stat = FS.status("/b/c"); 1045 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1046 ASSERT_EQ("/b/c", Stat->getName()); 1047 ASSERT_EQ("/b", *FS.getCurrentWorkingDirectory()); 1048 1049 Stat = FS.status("c"); 1050 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1051 1052 NormalizedFS.setCurrentWorkingDirectory("/b/c"); 1053 NormalizedFS.setCurrentWorkingDirectory("."); 1054 ASSERT_EQ("/b/c", 1055 getPosixPath(NormalizedFS.getCurrentWorkingDirectory().get())); 1056 NormalizedFS.setCurrentWorkingDirectory(".."); 1057 ASSERT_EQ("/b", 1058 getPosixPath(NormalizedFS.getCurrentWorkingDirectory().get())); 1059 } 1060 1061 TEST_F(InMemoryFileSystemTest, IsLocal) { 1062 FS.setCurrentWorkingDirectory("/b"); 1063 FS.addFile("c", 0, MemoryBuffer::getMemBuffer("")); 1064 1065 std::error_code EC; 1066 bool IsLocal = true; 1067 EC = FS.isLocal("c", IsLocal); 1068 ASSERT_FALSE(EC); 1069 ASSERT_FALSE(IsLocal); 1070 } 1071 1072 #if !defined(_WIN32) 1073 TEST_F(InMemoryFileSystemTest, GetRealPath) { 1074 SmallString<16> Path; 1075 EXPECT_EQ(FS.getRealPath("b", Path), errc::operation_not_permitted); 1076 1077 auto GetRealPath = [this](StringRef P) { 1078 SmallString<16> Output; 1079 auto EC = FS.getRealPath(P, Output); 1080 EXPECT_FALSE(EC); 1081 return Output.str().str(); 1082 }; 1083 1084 FS.setCurrentWorkingDirectory("a"); 1085 EXPECT_EQ(GetRealPath("b"), "a/b"); 1086 EXPECT_EQ(GetRealPath("../b"), "b"); 1087 EXPECT_EQ(GetRealPath("b/./c"), "a/b/c"); 1088 1089 FS.setCurrentWorkingDirectory("/a"); 1090 EXPECT_EQ(GetRealPath("b"), "/a/b"); 1091 EXPECT_EQ(GetRealPath("../b"), "/b"); 1092 EXPECT_EQ(GetRealPath("b/./c"), "/a/b/c"); 1093 } 1094 #endif // _WIN32 1095 1096 TEST_F(InMemoryFileSystemTest, AddFileWithUser) { 1097 FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), 0xFEEDFACE); 1098 auto Stat = FS.status("/a"); 1099 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1100 ASSERT_TRUE(Stat->isDirectory()); 1101 ASSERT_EQ(0xFEEDFACE, Stat->getUser()); 1102 Stat = FS.status("/a/b"); 1103 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1104 ASSERT_TRUE(Stat->isDirectory()); 1105 ASSERT_EQ(0xFEEDFACE, Stat->getUser()); 1106 Stat = FS.status("/a/b/c"); 1107 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1108 ASSERT_TRUE(Stat->isRegularFile()); 1109 ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions()); 1110 ASSERT_EQ(0xFEEDFACE, Stat->getUser()); 1111 } 1112 1113 TEST_F(InMemoryFileSystemTest, AddFileWithGroup) { 1114 FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), None, 0xDABBAD00); 1115 auto Stat = FS.status("/a"); 1116 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1117 ASSERT_TRUE(Stat->isDirectory()); 1118 ASSERT_EQ(0xDABBAD00, Stat->getGroup()); 1119 Stat = FS.status("/a/b"); 1120 ASSERT_TRUE(Stat->isDirectory()); 1121 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1122 ASSERT_EQ(0xDABBAD00, Stat->getGroup()); 1123 Stat = FS.status("/a/b/c"); 1124 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1125 ASSERT_TRUE(Stat->isRegularFile()); 1126 ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions()); 1127 ASSERT_EQ(0xDABBAD00, Stat->getGroup()); 1128 } 1129 1130 TEST_F(InMemoryFileSystemTest, AddFileWithFileType) { 1131 FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), None, None, 1132 sys::fs::file_type::socket_file); 1133 auto Stat = FS.status("/a"); 1134 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1135 ASSERT_TRUE(Stat->isDirectory()); 1136 Stat = FS.status("/a/b"); 1137 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1138 ASSERT_TRUE(Stat->isDirectory()); 1139 Stat = FS.status("/a/b/c"); 1140 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1141 ASSERT_EQ(sys::fs::file_type::socket_file, Stat->getType()); 1142 ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions()); 1143 } 1144 1145 TEST_F(InMemoryFileSystemTest, AddFileWithPerms) { 1146 FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), None, None, None, 1147 sys::fs::perms::owner_read | sys::fs::perms::owner_write); 1148 auto Stat = FS.status("/a"); 1149 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1150 ASSERT_TRUE(Stat->isDirectory()); 1151 ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write | 1152 sys::fs::perms::owner_exe, 1153 Stat->getPermissions()); 1154 Stat = FS.status("/a/b"); 1155 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1156 ASSERT_TRUE(Stat->isDirectory()); 1157 ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write | 1158 sys::fs::perms::owner_exe, 1159 Stat->getPermissions()); 1160 Stat = FS.status("/a/b/c"); 1161 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1162 ASSERT_TRUE(Stat->isRegularFile()); 1163 ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write, 1164 Stat->getPermissions()); 1165 } 1166 1167 TEST_F(InMemoryFileSystemTest, AddDirectoryThenAddChild) { 1168 FS.addFile("/a", 0, MemoryBuffer::getMemBuffer(""), /*User=*/None, 1169 /*Group=*/None, sys::fs::file_type::directory_file); 1170 FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("abc"), /*User=*/None, 1171 /*Group=*/None, sys::fs::file_type::regular_file); 1172 auto Stat = FS.status("/a"); 1173 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1174 ASSERT_TRUE(Stat->isDirectory()); 1175 Stat = FS.status("/a/b"); 1176 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); 1177 ASSERT_TRUE(Stat->isRegularFile()); 1178 } 1179 1180 // Test that the name returned by status() is in the same form as the path that 1181 // was requested (to match the behavior of RealFileSystem). 1182 TEST_F(InMemoryFileSystemTest, StatusName) { 1183 NormalizedFS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), 1184 /*User=*/None, 1185 /*Group=*/None, sys::fs::file_type::regular_file); 1186 NormalizedFS.setCurrentWorkingDirectory("/a/b"); 1187 1188 // Access using InMemoryFileSystem::status. 1189 auto Stat = NormalizedFS.status("../b/c"); 1190 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" 1191 << NormalizedFS.toString(); 1192 ASSERT_TRUE(Stat->isRegularFile()); 1193 ASSERT_EQ("../b/c", Stat->getName()); 1194 1195 // Access using InMemoryFileAdaptor::status. 1196 auto File = NormalizedFS.openFileForRead("../b/c"); 1197 ASSERT_FALSE(File.getError()) << File.getError() << "\n" 1198 << NormalizedFS.toString(); 1199 Stat = (*File)->status(); 1200 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" 1201 << NormalizedFS.toString(); 1202 ASSERT_TRUE(Stat->isRegularFile()); 1203 ASSERT_EQ("../b/c", Stat->getName()); 1204 1205 // Access using a directory iterator. 1206 std::error_code EC; 1207 llvm::vfs::directory_iterator It = NormalizedFS.dir_begin("../b", EC); 1208 // When on Windows, we end up with "../b\\c" as the name. Convert to Posix 1209 // path for the sake of the comparison. 1210 ASSERT_EQ("../b/c", getPosixPath(It->path())); 1211 } 1212 1213 TEST_F(InMemoryFileSystemTest, AddHardLinkToFile) { 1214 StringRef FromLink = "/path/to/FROM/link"; 1215 StringRef Target = "/path/to/TO/file"; 1216 FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target")); 1217 EXPECT_TRUE(FS.addHardLink(FromLink, Target)); 1218 EXPECT_THAT(FromLink, IsHardLinkTo(&FS, Target)); 1219 EXPECT_TRUE(FS.status(FromLink)->getSize() == FS.status(Target)->getSize()); 1220 EXPECT_TRUE(FS.getBufferForFile(FromLink)->get()->getBuffer() == 1221 FS.getBufferForFile(Target)->get()->getBuffer()); 1222 } 1223 1224 TEST_F(InMemoryFileSystemTest, AddHardLinkInChainPattern) { 1225 StringRef Link0 = "/path/to/0/link"; 1226 StringRef Link1 = "/path/to/1/link"; 1227 StringRef Link2 = "/path/to/2/link"; 1228 StringRef Target = "/path/to/target"; 1229 FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target file")); 1230 EXPECT_TRUE(FS.addHardLink(Link2, Target)); 1231 EXPECT_TRUE(FS.addHardLink(Link1, Link2)); 1232 EXPECT_TRUE(FS.addHardLink(Link0, Link1)); 1233 EXPECT_THAT(Link0, IsHardLinkTo(&FS, Target)); 1234 EXPECT_THAT(Link1, IsHardLinkTo(&FS, Target)); 1235 EXPECT_THAT(Link2, IsHardLinkTo(&FS, Target)); 1236 } 1237 1238 TEST_F(InMemoryFileSystemTest, AddHardLinkToAFileThatWasNotAddedBefore) { 1239 EXPECT_FALSE(FS.addHardLink("/path/to/link", "/path/to/target")); 1240 } 1241 1242 TEST_F(InMemoryFileSystemTest, AddHardLinkFromAFileThatWasAddedBefore) { 1243 StringRef Link = "/path/to/link"; 1244 StringRef Target = "/path/to/target"; 1245 FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target")); 1246 FS.addFile(Link, 0, MemoryBuffer::getMemBuffer("content of link")); 1247 EXPECT_FALSE(FS.addHardLink(Link, Target)); 1248 } 1249 1250 TEST_F(InMemoryFileSystemTest, AddSameHardLinkMoreThanOnce) { 1251 StringRef Link = "/path/to/link"; 1252 StringRef Target = "/path/to/target"; 1253 FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target")); 1254 EXPECT_TRUE(FS.addHardLink(Link, Target)); 1255 EXPECT_FALSE(FS.addHardLink(Link, Target)); 1256 } 1257 1258 TEST_F(InMemoryFileSystemTest, AddFileInPlaceOfAHardLinkWithSameContent) { 1259 StringRef Link = "/path/to/link"; 1260 StringRef Target = "/path/to/target"; 1261 StringRef Content = "content of target"; 1262 EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content))); 1263 EXPECT_TRUE(FS.addHardLink(Link, Target)); 1264 EXPECT_TRUE(FS.addFile(Link, 0, MemoryBuffer::getMemBuffer(Content))); 1265 } 1266 1267 TEST_F(InMemoryFileSystemTest, AddFileInPlaceOfAHardLinkWithDifferentContent) { 1268 StringRef Link = "/path/to/link"; 1269 StringRef Target = "/path/to/target"; 1270 StringRef Content = "content of target"; 1271 StringRef LinkContent = "different content of link"; 1272 EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content))); 1273 EXPECT_TRUE(FS.addHardLink(Link, Target)); 1274 EXPECT_FALSE(FS.addFile(Link, 0, MemoryBuffer::getMemBuffer(LinkContent))); 1275 } 1276 1277 TEST_F(InMemoryFileSystemTest, AddHardLinkToADirectory) { 1278 StringRef Dir = "path/to/dummy/dir"; 1279 StringRef Link = "/path/to/link"; 1280 StringRef File = "path/to/dummy/dir/target"; 1281 StringRef Content = "content of target"; 1282 EXPECT_TRUE(FS.addFile(File, 0, MemoryBuffer::getMemBuffer(Content))); 1283 EXPECT_FALSE(FS.addHardLink(Link, Dir)); 1284 } 1285 1286 TEST_F(InMemoryFileSystemTest, AddHardLinkFromADirectory) { 1287 StringRef Dir = "path/to/dummy/dir"; 1288 StringRef Target = "path/to/dummy/dir/target"; 1289 StringRef Content = "content of target"; 1290 EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content))); 1291 EXPECT_FALSE(FS.addHardLink(Dir, Target)); 1292 } 1293 1294 TEST_F(InMemoryFileSystemTest, AddHardLinkUnderAFile) { 1295 StringRef CommonContent = "content string"; 1296 FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer(CommonContent)); 1297 FS.addFile("/c/d", 0, MemoryBuffer::getMemBuffer(CommonContent)); 1298 EXPECT_FALSE(FS.addHardLink("/c/d/e", "/a/b")); 1299 } 1300 1301 TEST_F(InMemoryFileSystemTest, RecursiveIterationWithHardLink) { 1302 std::error_code EC; 1303 FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("content string")); 1304 EXPECT_TRUE(FS.addHardLink("/c/d", "/a/b")); 1305 auto I = vfs::recursive_directory_iterator(FS, "/", EC); 1306 ASSERT_FALSE(EC); 1307 std::vector<std::string> Nodes; 1308 for (auto E = vfs::recursive_directory_iterator(); !EC && I != E; 1309 I.increment(EC)) { 1310 Nodes.push_back(getPosixPath(I->path())); 1311 } 1312 EXPECT_THAT(Nodes, testing::UnorderedElementsAre("/a", "/a/b", "/c", "/c/d")); 1313 } 1314 1315 // NOTE: in the tests below, we use '//root/' as our root directory, since it is 1316 // a legal *absolute* path on Windows as well as *nix. 1317 class VFSFromYAMLTest : public ::testing::Test { 1318 public: 1319 int NumDiagnostics; 1320 1321 void SetUp() override { NumDiagnostics = 0; } 1322 1323 static void CountingDiagHandler(const SMDiagnostic &, void *Context) { 1324 VFSFromYAMLTest *Test = static_cast<VFSFromYAMLTest *>(Context); 1325 ++Test->NumDiagnostics; 1326 } 1327 1328 IntrusiveRefCntPtr<vfs::FileSystem> 1329 getFromYAMLRawString(StringRef Content, 1330 IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS) { 1331 std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Content); 1332 return getVFSFromYAML(std::move(Buffer), CountingDiagHandler, "", this, 1333 ExternalFS); 1334 } 1335 1336 IntrusiveRefCntPtr<vfs::FileSystem> getFromYAMLString( 1337 StringRef Content, 1338 IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS = new DummyFileSystem()) { 1339 std::string VersionPlusContent("{\n 'version':0,\n"); 1340 VersionPlusContent += Content.slice(Content.find('{') + 1, StringRef::npos); 1341 return getFromYAMLRawString(VersionPlusContent, ExternalFS); 1342 } 1343 1344 // This is intended as a "XFAIL" for windows hosts. 1345 bool supportsSameDirMultipleYAMLEntries() { 1346 Triple Host(Triple::normalize(sys::getProcessTriple())); 1347 return !Host.isOSWindows(); 1348 } 1349 }; 1350 1351 TEST_F(VFSFromYAMLTest, BasicVFSFromYAML) { 1352 IntrusiveRefCntPtr<vfs::FileSystem> FS; 1353 FS = getFromYAMLString(""); 1354 EXPECT_EQ(nullptr, FS.get()); 1355 FS = getFromYAMLString("[]"); 1356 EXPECT_EQ(nullptr, FS.get()); 1357 FS = getFromYAMLString("'string'"); 1358 EXPECT_EQ(nullptr, FS.get()); 1359 EXPECT_EQ(3, NumDiagnostics); 1360 } 1361 1362 TEST_F(VFSFromYAMLTest, MappedFiles) { 1363 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1364 Lower->addRegularFile("//root/foo/bar/a"); 1365 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1366 "{ 'roots': [\n" 1367 "{\n" 1368 " 'type': 'directory',\n" 1369 " 'name': '//root/',\n" 1370 " 'contents': [ {\n" 1371 " 'type': 'file',\n" 1372 " 'name': 'file1',\n" 1373 " 'external-contents': '//root/foo/bar/a'\n" 1374 " },\n" 1375 " {\n" 1376 " 'type': 'file',\n" 1377 " 'name': 'file2',\n" 1378 " 'external-contents': '//root/foo/b'\n" 1379 " }\n" 1380 " ]\n" 1381 "}\n" 1382 "]\n" 1383 "}", 1384 Lower); 1385 ASSERT_TRUE(FS.get() != nullptr); 1386 1387 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 1388 new vfs::OverlayFileSystem(Lower)); 1389 O->pushOverlay(FS); 1390 1391 // file 1392 ErrorOr<vfs::Status> S = O->status("//root/file1"); 1393 ASSERT_FALSE(S.getError()); 1394 EXPECT_EQ("//root/foo/bar/a", S->getName()); 1395 EXPECT_TRUE(S->IsVFSMapped); 1396 1397 ErrorOr<vfs::Status> SLower = O->status("//root/foo/bar/a"); 1398 EXPECT_EQ("//root/foo/bar/a", SLower->getName()); 1399 EXPECT_TRUE(S->equivalent(*SLower)); 1400 EXPECT_FALSE(SLower->IsVFSMapped); 1401 1402 // file after opening 1403 auto OpenedF = O->openFileForRead("//root/file1"); 1404 ASSERT_FALSE(OpenedF.getError()); 1405 auto OpenedS = (*OpenedF)->status(); 1406 ASSERT_FALSE(OpenedS.getError()); 1407 EXPECT_EQ("//root/foo/bar/a", OpenedS->getName()); 1408 EXPECT_TRUE(OpenedS->IsVFSMapped); 1409 1410 // directory 1411 S = O->status("//root/"); 1412 ASSERT_FALSE(S.getError()); 1413 EXPECT_TRUE(S->isDirectory()); 1414 EXPECT_TRUE(S->equivalent(*O->status("//root/"))); // non-volatile UniqueID 1415 1416 // broken mapping 1417 EXPECT_EQ(O->status("//root/file2").getError(), 1418 llvm::errc::no_such_file_or_directory); 1419 EXPECT_EQ(0, NumDiagnostics); 1420 } 1421 1422 TEST_F(VFSFromYAMLTest, CaseInsensitive) { 1423 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1424 Lower->addRegularFile("//root/foo/bar/a"); 1425 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1426 "{ 'case-sensitive': 'false',\n" 1427 " 'roots': [\n" 1428 "{\n" 1429 " 'type': 'directory',\n" 1430 " 'name': '//root/',\n" 1431 " 'contents': [ {\n" 1432 " 'type': 'file',\n" 1433 " 'name': 'XX',\n" 1434 " 'external-contents': '//root/foo/bar/a'\n" 1435 " }\n" 1436 " ]\n" 1437 "}]}", 1438 Lower); 1439 ASSERT_TRUE(FS.get() != nullptr); 1440 1441 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 1442 new vfs::OverlayFileSystem(Lower)); 1443 O->pushOverlay(FS); 1444 1445 ErrorOr<vfs::Status> S = O->status("//root/XX"); 1446 ASSERT_FALSE(S.getError()); 1447 1448 ErrorOr<vfs::Status> SS = O->status("//root/xx"); 1449 ASSERT_FALSE(SS.getError()); 1450 EXPECT_TRUE(S->equivalent(*SS)); 1451 SS = O->status("//root/xX"); 1452 EXPECT_TRUE(S->equivalent(*SS)); 1453 SS = O->status("//root/Xx"); 1454 EXPECT_TRUE(S->equivalent(*SS)); 1455 EXPECT_EQ(0, NumDiagnostics); 1456 } 1457 1458 TEST_F(VFSFromYAMLTest, CaseSensitive) { 1459 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1460 Lower->addRegularFile("//root/foo/bar/a"); 1461 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1462 "{ 'case-sensitive': 'true',\n" 1463 " 'roots': [\n" 1464 "{\n" 1465 " 'type': 'directory',\n" 1466 " 'name': '//root/',\n" 1467 " 'contents': [ {\n" 1468 " 'type': 'file',\n" 1469 " 'name': 'XX',\n" 1470 " 'external-contents': '//root/foo/bar/a'\n" 1471 " }\n" 1472 " ]\n" 1473 "}]}", 1474 Lower); 1475 ASSERT_TRUE(FS.get() != nullptr); 1476 1477 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 1478 new vfs::OverlayFileSystem(Lower)); 1479 O->pushOverlay(FS); 1480 1481 ErrorOr<vfs::Status> SS = O->status("//root/xx"); 1482 EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory); 1483 SS = O->status("//root/xX"); 1484 EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory); 1485 SS = O->status("//root/Xx"); 1486 EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory); 1487 EXPECT_EQ(0, NumDiagnostics); 1488 } 1489 1490 TEST_F(VFSFromYAMLTest, IllegalVFSFile) { 1491 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1492 1493 // invalid YAML at top-level 1494 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString("{]", Lower); 1495 EXPECT_EQ(nullptr, FS.get()); 1496 // invalid YAML in roots 1497 FS = getFromYAMLString("{ 'roots':[}", Lower); 1498 // invalid YAML in directory 1499 FS = getFromYAMLString( 1500 "{ 'roots':[ { 'name': 'foo', 'type': 'directory', 'contents': [}", 1501 Lower); 1502 EXPECT_EQ(nullptr, FS.get()); 1503 1504 // invalid configuration 1505 FS = getFromYAMLString("{ 'knobular': 'true', 'roots':[] }", Lower); 1506 EXPECT_EQ(nullptr, FS.get()); 1507 FS = getFromYAMLString("{ 'case-sensitive': 'maybe', 'roots':[] }", Lower); 1508 EXPECT_EQ(nullptr, FS.get()); 1509 1510 // invalid roots 1511 FS = getFromYAMLString("{ 'roots':'' }", Lower); 1512 EXPECT_EQ(nullptr, FS.get()); 1513 FS = getFromYAMLString("{ 'roots':{} }", Lower); 1514 EXPECT_EQ(nullptr, FS.get()); 1515 1516 // invalid entries 1517 FS = getFromYAMLString( 1518 "{ 'roots':[ { 'type': 'other', 'name': 'me', 'contents': '' }", Lower); 1519 EXPECT_EQ(nullptr, FS.get()); 1520 FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': [], " 1521 "'external-contents': 'other' }", 1522 Lower); 1523 EXPECT_EQ(nullptr, FS.get()); 1524 FS = getFromYAMLString( 1525 "{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': [] }", 1526 Lower); 1527 EXPECT_EQ(nullptr, FS.get()); 1528 FS = getFromYAMLString( 1529 "{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': {} }", 1530 Lower); 1531 EXPECT_EQ(nullptr, FS.get()); 1532 FS = getFromYAMLString( 1533 "{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': {} }", 1534 Lower); 1535 EXPECT_EQ(nullptr, FS.get()); 1536 FS = getFromYAMLString( 1537 "{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': '' }", 1538 Lower); 1539 EXPECT_EQ(nullptr, FS.get()); 1540 FS = getFromYAMLString( 1541 "{ 'roots':[ { 'thingy': 'directory', 'name': 'me', 'contents': [] }", 1542 Lower); 1543 EXPECT_EQ(nullptr, FS.get()); 1544 1545 // missing mandatory fields 1546 FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': 'me' }", Lower); 1547 EXPECT_EQ(nullptr, FS.get()); 1548 FS = getFromYAMLString( 1549 "{ 'roots':[ { 'type': 'file', 'external-contents': 'other' }", Lower); 1550 EXPECT_EQ(nullptr, FS.get()); 1551 FS = getFromYAMLString("{ 'roots':[ { 'name': 'me', 'contents': [] }", Lower); 1552 EXPECT_EQ(nullptr, FS.get()); 1553 1554 // duplicate keys 1555 FS = getFromYAMLString("{ 'roots':[], 'roots':[] }", Lower); 1556 EXPECT_EQ(nullptr, FS.get()); 1557 FS = getFromYAMLString( 1558 "{ 'case-sensitive':'true', 'case-sensitive':'true', 'roots':[] }", 1559 Lower); 1560 EXPECT_EQ(nullptr, FS.get()); 1561 FS = 1562 getFromYAMLString("{ 'roots':[{'name':'me', 'name':'you', 'type':'file', " 1563 "'external-contents':'blah' } ] }", 1564 Lower); 1565 EXPECT_EQ(nullptr, FS.get()); 1566 1567 // missing version 1568 FS = getFromYAMLRawString("{ 'roots':[] }", Lower); 1569 EXPECT_EQ(nullptr, FS.get()); 1570 1571 // bad version number 1572 FS = getFromYAMLRawString("{ 'version':'foo', 'roots':[] }", Lower); 1573 EXPECT_EQ(nullptr, FS.get()); 1574 FS = getFromYAMLRawString("{ 'version':-1, 'roots':[] }", Lower); 1575 EXPECT_EQ(nullptr, FS.get()); 1576 FS = getFromYAMLRawString("{ 'version':100000, 'roots':[] }", Lower); 1577 EXPECT_EQ(nullptr, FS.get()); 1578 EXPECT_EQ(24, NumDiagnostics); 1579 } 1580 1581 TEST_F(VFSFromYAMLTest, UseExternalName) { 1582 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1583 Lower->addRegularFile("//root/external/file"); 1584 1585 IntrusiveRefCntPtr<vfs::FileSystem> FS = 1586 getFromYAMLString("{ 'roots': [\n" 1587 " { 'type': 'file', 'name': '//root/A',\n" 1588 " 'external-contents': '//root/external/file'\n" 1589 " },\n" 1590 " { 'type': 'file', 'name': '//root/B',\n" 1591 " 'use-external-name': true,\n" 1592 " 'external-contents': '//root/external/file'\n" 1593 " },\n" 1594 " { 'type': 'file', 'name': '//root/C',\n" 1595 " 'use-external-name': false,\n" 1596 " 'external-contents': '//root/external/file'\n" 1597 " }\n" 1598 "] }", 1599 Lower); 1600 ASSERT_TRUE(nullptr != FS.get()); 1601 1602 // default true 1603 EXPECT_EQ("//root/external/file", FS->status("//root/A")->getName()); 1604 // explicit 1605 EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName()); 1606 EXPECT_EQ("//root/C", FS->status("//root/C")->getName()); 1607 1608 // global configuration 1609 FS = getFromYAMLString("{ 'use-external-names': false,\n" 1610 " 'roots': [\n" 1611 " { 'type': 'file', 'name': '//root/A',\n" 1612 " 'external-contents': '//root/external/file'\n" 1613 " },\n" 1614 " { 'type': 'file', 'name': '//root/B',\n" 1615 " 'use-external-name': true,\n" 1616 " 'external-contents': '//root/external/file'\n" 1617 " },\n" 1618 " { 'type': 'file', 'name': '//root/C',\n" 1619 " 'use-external-name': false,\n" 1620 " 'external-contents': '//root/external/file'\n" 1621 " }\n" 1622 "] }", 1623 Lower); 1624 ASSERT_TRUE(nullptr != FS.get()); 1625 1626 // default 1627 EXPECT_EQ("//root/A", FS->status("//root/A")->getName()); 1628 // explicit 1629 EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName()); 1630 EXPECT_EQ("//root/C", FS->status("//root/C")->getName()); 1631 } 1632 1633 TEST_F(VFSFromYAMLTest, MultiComponentPath) { 1634 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1635 Lower->addRegularFile("//root/other"); 1636 1637 // file in roots 1638 IntrusiveRefCntPtr<vfs::FileSystem> FS = 1639 getFromYAMLString("{ 'roots': [\n" 1640 " { 'type': 'file', 'name': '//root/path/to/file',\n" 1641 " 'external-contents': '//root/other' }]\n" 1642 "}", 1643 Lower); 1644 ASSERT_TRUE(nullptr != FS.get()); 1645 EXPECT_FALSE(FS->status("//root/path/to/file").getError()); 1646 EXPECT_FALSE(FS->status("//root/path/to").getError()); 1647 EXPECT_FALSE(FS->status("//root/path").getError()); 1648 EXPECT_FALSE(FS->status("//root/").getError()); 1649 1650 // at the start 1651 FS = getFromYAMLString( 1652 "{ 'roots': [\n" 1653 " { 'type': 'directory', 'name': '//root/path/to',\n" 1654 " 'contents': [ { 'type': 'file', 'name': 'file',\n" 1655 " 'external-contents': '//root/other' }]}]\n" 1656 "}", 1657 Lower); 1658 ASSERT_TRUE(nullptr != FS.get()); 1659 EXPECT_FALSE(FS->status("//root/path/to/file").getError()); 1660 EXPECT_FALSE(FS->status("//root/path/to").getError()); 1661 EXPECT_FALSE(FS->status("//root/path").getError()); 1662 EXPECT_FALSE(FS->status("//root/").getError()); 1663 1664 // at the end 1665 FS = getFromYAMLString( 1666 "{ 'roots': [\n" 1667 " { 'type': 'directory', 'name': '//root/',\n" 1668 " 'contents': [ { 'type': 'file', 'name': 'path/to/file',\n" 1669 " 'external-contents': '//root/other' }]}]\n" 1670 "}", 1671 Lower); 1672 ASSERT_TRUE(nullptr != FS.get()); 1673 EXPECT_FALSE(FS->status("//root/path/to/file").getError()); 1674 EXPECT_FALSE(FS->status("//root/path/to").getError()); 1675 EXPECT_FALSE(FS->status("//root/path").getError()); 1676 EXPECT_FALSE(FS->status("//root/").getError()); 1677 } 1678 1679 TEST_F(VFSFromYAMLTest, TrailingSlashes) { 1680 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1681 Lower->addRegularFile("//root/other"); 1682 1683 // file in roots 1684 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1685 "{ 'roots': [\n" 1686 " { 'type': 'directory', 'name': '//root/path/to////',\n" 1687 " 'contents': [ { 'type': 'file', 'name': 'file',\n" 1688 " 'external-contents': '//root/other' }]}]\n" 1689 "}", 1690 Lower); 1691 ASSERT_TRUE(nullptr != FS.get()); 1692 EXPECT_FALSE(FS->status("//root/path/to/file").getError()); 1693 EXPECT_FALSE(FS->status("//root/path/to").getError()); 1694 EXPECT_FALSE(FS->status("//root/path").getError()); 1695 EXPECT_FALSE(FS->status("//root/").getError()); 1696 } 1697 1698 TEST_F(VFSFromYAMLTest, DirectoryIteration) { 1699 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1700 Lower->addDirectory("//root/"); 1701 Lower->addDirectory("//root/foo"); 1702 Lower->addDirectory("//root/foo/bar"); 1703 Lower->addRegularFile("//root/foo/bar/a"); 1704 Lower->addRegularFile("//root/foo/bar/b"); 1705 Lower->addRegularFile("//root/file3"); 1706 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1707 "{ 'use-external-names': false,\n" 1708 " 'roots': [\n" 1709 "{\n" 1710 " 'type': 'directory',\n" 1711 " 'name': '//root/',\n" 1712 " 'contents': [ {\n" 1713 " 'type': 'file',\n" 1714 " 'name': 'file1',\n" 1715 " 'external-contents': '//root/foo/bar/a'\n" 1716 " },\n" 1717 " {\n" 1718 " 'type': 'file',\n" 1719 " 'name': 'file2',\n" 1720 " 'external-contents': '//root/foo/bar/b'\n" 1721 " }\n" 1722 " ]\n" 1723 "}\n" 1724 "]\n" 1725 "}", 1726 Lower); 1727 ASSERT_TRUE(FS.get() != nullptr); 1728 1729 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 1730 new vfs::OverlayFileSystem(Lower)); 1731 O->pushOverlay(FS); 1732 1733 std::error_code EC; 1734 checkContents(O->dir_begin("//root/", EC), 1735 {"//root/file1", "//root/file2", "//root/file3", "//root/foo"}); 1736 1737 checkContents(O->dir_begin("//root/foo/bar", EC), 1738 {"//root/foo/bar/a", "//root/foo/bar/b"}); 1739 } 1740 1741 TEST_F(VFSFromYAMLTest, DirectoryIterationSameDirMultipleEntries) { 1742 // https://llvm.org/bugs/show_bug.cgi?id=27725 1743 if (!supportsSameDirMultipleYAMLEntries()) 1744 return; 1745 1746 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1747 Lower->addDirectory("//root/zab"); 1748 Lower->addDirectory("//root/baz"); 1749 Lower->addRegularFile("//root/zab/a"); 1750 Lower->addRegularFile("//root/zab/b"); 1751 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1752 "{ 'use-external-names': false,\n" 1753 " 'roots': [\n" 1754 "{\n" 1755 " 'type': 'directory',\n" 1756 " 'name': '//root/baz/',\n" 1757 " 'contents': [ {\n" 1758 " 'type': 'file',\n" 1759 " 'name': 'x',\n" 1760 " 'external-contents': '//root/zab/a'\n" 1761 " }\n" 1762 " ]\n" 1763 "},\n" 1764 "{\n" 1765 " 'type': 'directory',\n" 1766 " 'name': '//root/baz/',\n" 1767 " 'contents': [ {\n" 1768 " 'type': 'file',\n" 1769 " 'name': 'y',\n" 1770 " 'external-contents': '//root/zab/b'\n" 1771 " }\n" 1772 " ]\n" 1773 "}\n" 1774 "]\n" 1775 "}", 1776 Lower); 1777 ASSERT_TRUE(FS.get() != nullptr); 1778 1779 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 1780 new vfs::OverlayFileSystem(Lower)); 1781 O->pushOverlay(FS); 1782 1783 std::error_code EC; 1784 1785 checkContents(O->dir_begin("//root/baz/", EC), 1786 {"//root/baz/x", "//root/baz/y"}); 1787 } 1788 1789 TEST_F(VFSFromYAMLTest, RecursiveDirectoryIterationLevel) { 1790 1791 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1792 Lower->addDirectory("//root/a"); 1793 Lower->addDirectory("//root/a/b"); 1794 Lower->addDirectory("//root/a/b/c"); 1795 Lower->addRegularFile("//root/a/b/c/file"); 1796 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1797 "{ 'use-external-names': false,\n" 1798 " 'roots': [\n" 1799 "{\n" 1800 " 'type': 'directory',\n" 1801 " 'name': '//root/a/b/c/',\n" 1802 " 'contents': [ {\n" 1803 " 'type': 'file',\n" 1804 " 'name': 'file',\n" 1805 " 'external-contents': '//root/a/b/c/file'\n" 1806 " }\n" 1807 " ]\n" 1808 "},\n" 1809 "]\n" 1810 "}", 1811 Lower); 1812 ASSERT_TRUE(FS.get() != nullptr); 1813 1814 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( 1815 new vfs::OverlayFileSystem(Lower)); 1816 O->pushOverlay(FS); 1817 1818 std::error_code EC; 1819 1820 // Test recursive_directory_iterator level() 1821 vfs::recursive_directory_iterator I = vfs::recursive_directory_iterator( 1822 *O, "//root", EC), 1823 E; 1824 ASSERT_FALSE(EC); 1825 for (int l = 0; I != E; I.increment(EC), ++l) { 1826 ASSERT_FALSE(EC); 1827 EXPECT_EQ(I.level(), l); 1828 } 1829 EXPECT_EQ(I, E); 1830 } 1831 1832 TEST_F(VFSFromYAMLTest, RelativePaths) { 1833 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1834 // Filename at root level without a parent directory. 1835 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1836 "{ 'roots': [\n" 1837 " { 'type': 'file', 'name': 'file-not-in-directory.h',\n" 1838 " 'external-contents': '//root/external/file'\n" 1839 " }\n" 1840 "] }", 1841 Lower); 1842 EXPECT_EQ(nullptr, FS.get()); 1843 1844 // Relative file path. 1845 FS = getFromYAMLString("{ 'roots': [\n" 1846 " { 'type': 'file', 'name': 'relative/file/path.h',\n" 1847 " 'external-contents': '//root/external/file'\n" 1848 " }\n" 1849 "] }", 1850 Lower); 1851 EXPECT_EQ(nullptr, FS.get()); 1852 1853 // Relative directory path. 1854 FS = getFromYAMLString( 1855 "{ 'roots': [\n" 1856 " { 'type': 'directory', 'name': 'relative/directory/path.h',\n" 1857 " 'contents': []\n" 1858 " }\n" 1859 "] }", 1860 Lower); 1861 EXPECT_EQ(nullptr, FS.get()); 1862 1863 EXPECT_EQ(3, NumDiagnostics); 1864 } 1865 1866 TEST_F(VFSFromYAMLTest, NonFallthroughDirectoryIteration) { 1867 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1868 Lower->addDirectory("//root/"); 1869 Lower->addRegularFile("//root/a"); 1870 Lower->addRegularFile("//root/b"); 1871 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1872 "{ 'use-external-names': false,\n" 1873 " 'fallthrough': false,\n" 1874 " 'roots': [\n" 1875 "{\n" 1876 " 'type': 'directory',\n" 1877 " 'name': '//root/',\n" 1878 " 'contents': [ {\n" 1879 " 'type': 'file',\n" 1880 " 'name': 'c',\n" 1881 " 'external-contents': '//root/a'\n" 1882 " }\n" 1883 " ]\n" 1884 "}\n" 1885 "]\n" 1886 "}", 1887 Lower); 1888 ASSERT_TRUE(FS.get() != nullptr); 1889 1890 std::error_code EC; 1891 checkContents(FS->dir_begin("//root/", EC), 1892 {"//root/c"}); 1893 } 1894 1895 TEST_F(VFSFromYAMLTest, DirectoryIterationWithDuplicates) { 1896 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1897 Lower->addDirectory("//root/"); 1898 Lower->addRegularFile("//root/a"); 1899 Lower->addRegularFile("//root/b"); 1900 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1901 "{ 'use-external-names': false,\n" 1902 " 'roots': [\n" 1903 "{\n" 1904 " 'type': 'directory',\n" 1905 " 'name': '//root/',\n" 1906 " 'contents': [ {\n" 1907 " 'type': 'file',\n" 1908 " 'name': 'a',\n" 1909 " 'external-contents': '//root/a'\n" 1910 " }\n" 1911 " ]\n" 1912 "}\n" 1913 "]\n" 1914 "}", 1915 Lower); 1916 ASSERT_TRUE(FS.get() != nullptr); 1917 1918 std::error_code EC; 1919 checkContents(FS->dir_begin("//root/", EC), 1920 {"//root/a", "//root/b"}); 1921 } 1922 1923 TEST_F(VFSFromYAMLTest, DirectoryIterationErrorInVFSLayer) { 1924 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1925 Lower->addDirectory("//root/"); 1926 Lower->addDirectory("//root/foo"); 1927 Lower->addRegularFile("//root/foo/a"); 1928 Lower->addRegularFile("//root/foo/b"); 1929 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1930 "{ 'use-external-names': false,\n" 1931 " 'roots': [\n" 1932 "{\n" 1933 " 'type': 'directory',\n" 1934 " 'name': '//root/',\n" 1935 " 'contents': [ {\n" 1936 " 'type': 'file',\n" 1937 " 'name': 'bar/a',\n" 1938 " 'external-contents': '//root/foo/a'\n" 1939 " }\n" 1940 " ]\n" 1941 "}\n" 1942 "]\n" 1943 "}", 1944 Lower); 1945 ASSERT_TRUE(FS.get() != nullptr); 1946 1947 std::error_code EC; 1948 checkContents(FS->dir_begin("//root/foo", EC), 1949 {"//root/foo/a", "//root/foo/b"}); 1950 } 1951 1952 TEST_F(VFSFromYAMLTest, GetRealPath) { 1953 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); 1954 Lower->addDirectory("//dir/"); 1955 Lower->addRegularFile("/foo"); 1956 Lower->addSymlink("/link"); 1957 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( 1958 "{ 'use-external-names': false,\n" 1959 " 'roots': [\n" 1960 "{\n" 1961 " 'type': 'directory',\n" 1962 " 'name': '//root/',\n" 1963 " 'contents': [ {\n" 1964 " 'type': 'file',\n" 1965 " 'name': 'bar',\n" 1966 " 'external-contents': '/link'\n" 1967 " }\n" 1968 " ]\n" 1969 "},\n" 1970 "{\n" 1971 " 'type': 'directory',\n" 1972 " 'name': '//dir/',\n" 1973 " 'contents': []\n" 1974 "}\n" 1975 "]\n" 1976 "}", 1977 Lower); 1978 ASSERT_TRUE(FS.get() != nullptr); 1979 1980 // Regular file present in underlying file system. 1981 SmallString<16> RealPath; 1982 EXPECT_FALSE(FS->getRealPath("/foo", RealPath)); 1983 EXPECT_EQ(RealPath.str(), "/foo"); 1984 1985 // File present in YAML pointing to symlink in underlying file system. 1986 EXPECT_FALSE(FS->getRealPath("//root/bar", RealPath)); 1987 EXPECT_EQ(RealPath.str(), "/symlink"); 1988 1989 // Directories should fall back to the underlying file system is possible. 1990 EXPECT_FALSE(FS->getRealPath("//dir/", RealPath)); 1991 EXPECT_EQ(RealPath.str(), "//dir/"); 1992 1993 // Try a non-existing file. 1994 EXPECT_EQ(FS->getRealPath("/non_existing", RealPath), 1995 errc::no_such_file_or_directory); 1996 } 1997