| //===- unittests/Support/VirtualFileSystem.cpp -------------- VFS tests ---===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm/Support/VirtualFileSystem.h" |
| #include "llvm/ADT/Triple.h" |
| #include "llvm/Config/llvm-config.h" |
| #include "llvm/Support/Errc.h" |
| #include "llvm/Support/Host.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include "llvm/Support/Path.h" |
| #include "llvm/Support/SourceMgr.h" |
| #include "llvm/Testing/Support/SupportHelpers.h" |
| #include "gmock/gmock.h" |
| #include "gtest/gtest.h" |
| #include <map> |
| #include <string> |
| |
| using namespace llvm; |
| using llvm::sys::fs::UniqueID; |
| using llvm::unittest::TempDir; |
| using llvm::unittest::TempFile; |
| using llvm::unittest::TempLink; |
| using testing::ElementsAre; |
| using testing::Pair; |
| using testing::UnorderedElementsAre; |
| |
| namespace { |
| struct DummyFile : public vfs::File { |
| vfs::Status S; |
| explicit DummyFile(vfs::Status S) : S(S) {} |
| llvm::ErrorOr<vfs::Status> status() override { return S; } |
| llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> |
| getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator, |
| bool IsVolatile) override { |
| llvm_unreachable("unimplemented"); |
| } |
| std::error_code close() override { return std::error_code(); } |
| }; |
| |
| class DummyFileSystem : public vfs::FileSystem { |
| int FSID; // used to produce UniqueIDs |
| int FileID; // used to produce UniqueIDs |
| std::string WorkingDirectory; |
| std::map<std::string, vfs::Status> FilesAndDirs; |
| typedef std::map<std::string, vfs::Status>::const_iterator const_iterator; |
| |
| static int getNextFSID() { |
| static int Count = 0; |
| return Count++; |
| } |
| |
| public: |
| DummyFileSystem() : FSID(getNextFSID()), FileID(0) {} |
| |
| ErrorOr<vfs::Status> status(const Twine &Path) override { |
| auto I = findEntry(Path); |
| if (I == FilesAndDirs.end()) |
| return make_error_code(llvm::errc::no_such_file_or_directory); |
| return I->second; |
| } |
| ErrorOr<std::unique_ptr<vfs::File>> |
| openFileForRead(const Twine &Path) override { |
| auto S = status(Path); |
| if (S) |
| return std::unique_ptr<vfs::File>(new DummyFile{*S}); |
| return S.getError(); |
| } |
| llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override { |
| return WorkingDirectory; |
| } |
| std::error_code setCurrentWorkingDirectory(const Twine &Path) override { |
| WorkingDirectory = Path.str(); |
| return std::error_code(); |
| } |
| // Map any symlink to "/symlink". |
| std::error_code getRealPath(const Twine &Path, |
| SmallVectorImpl<char> &Output) const override { |
| auto I = findEntry(Path); |
| if (I == FilesAndDirs.end()) |
| return make_error_code(llvm::errc::no_such_file_or_directory); |
| if (I->second.isSymlink()) { |
| Output.clear(); |
| Twine("/symlink").toVector(Output); |
| return std::error_code(); |
| } |
| Output.clear(); |
| Path.toVector(Output); |
| return std::error_code(); |
| } |
| |
| struct DirIterImpl : public llvm::vfs::detail::DirIterImpl { |
| std::map<std::string, vfs::Status> &FilesAndDirs; |
| std::map<std::string, vfs::Status>::iterator I; |
| std::string Path; |
| bool isInPath(StringRef S) { |
| if (Path.size() < S.size() && S.find(Path) == 0) { |
| auto LastSep = S.find_last_of('/'); |
| if (LastSep == Path.size() || LastSep == Path.size() - 1) |
| return true; |
| } |
| return false; |
| } |
| DirIterImpl(std::map<std::string, vfs::Status> &FilesAndDirs, |
| const Twine &_Path) |
| : FilesAndDirs(FilesAndDirs), I(FilesAndDirs.begin()), |
| Path(_Path.str()) { |
| for (; I != FilesAndDirs.end(); ++I) { |
| if (isInPath(I->first)) { |
| CurrentEntry = vfs::directory_entry(std::string(I->second.getName()), |
| I->second.getType()); |
| break; |
| } |
| } |
| } |
| std::error_code increment() override { |
| ++I; |
| for (; I != FilesAndDirs.end(); ++I) { |
| if (isInPath(I->first)) { |
| CurrentEntry = vfs::directory_entry(std::string(I->second.getName()), |
| I->second.getType()); |
| break; |
| } |
| } |
| if (I == FilesAndDirs.end()) |
| CurrentEntry = vfs::directory_entry(); |
| return std::error_code(); |
| } |
| }; |
| |
| vfs::directory_iterator dir_begin(const Twine &Dir, |
| std::error_code &EC) override { |
| return vfs::directory_iterator( |
| std::make_shared<DirIterImpl>(FilesAndDirs, Dir)); |
| } |
| |
| void addEntry(StringRef Path, const vfs::Status &Status) { |
| FilesAndDirs[std::string(Path)] = Status; |
| } |
| |
| const_iterator findEntry(const Twine &Path) const { |
| SmallString<128> P; |
| Path.toVector(P); |
| std::error_code EC = makeAbsolute(P); |
| assert(!EC); |
| (void)EC; |
| return FilesAndDirs.find(std::string(P.str())); |
| } |
| |
| void addRegularFile(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) { |
| vfs::Status S(Path, UniqueID(FSID, FileID++), |
| std::chrono::system_clock::now(), 0, 0, 1024, |
| sys::fs::file_type::regular_file, Perms); |
| addEntry(Path, S); |
| } |
| |
| void addDirectory(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) { |
| vfs::Status S(Path, UniqueID(FSID, FileID++), |
| std::chrono::system_clock::now(), 0, 0, 0, |
| sys::fs::file_type::directory_file, Perms); |
| addEntry(Path, S); |
| } |
| |
| void addSymlink(StringRef Path) { |
| vfs::Status S(Path, UniqueID(FSID, FileID++), |
| std::chrono::system_clock::now(), 0, 0, 0, |
| sys::fs::file_type::symlink_file, sys::fs::all_all); |
| addEntry(Path, S); |
| } |
| }; |
| |
| class ErrorDummyFileSystem : public DummyFileSystem { |
| std::error_code setCurrentWorkingDirectory(const Twine &Path) override { |
| return llvm::errc::no_such_file_or_directory; |
| } |
| }; |
| |
| /// Replace back-slashes by front-slashes. |
| std::string getPosixPath(std::string S) { |
| SmallString<128> Result; |
| llvm::sys::path::native(S, Result, llvm::sys::path::Style::posix); |
| return std::string(Result.str()); |
| } |
| } // end anonymous namespace |
| |
| TEST(VirtualFileSystemTest, StatusQueries) { |
| IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem()); |
| ErrorOr<vfs::Status> Status((std::error_code())); |
| |
| D->addRegularFile("/foo"); |
| Status = D->status("/foo"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->isStatusKnown()); |
| EXPECT_FALSE(Status->isDirectory()); |
| EXPECT_TRUE(Status->isRegularFile()); |
| EXPECT_FALSE(Status->isSymlink()); |
| EXPECT_FALSE(Status->isOther()); |
| EXPECT_TRUE(Status->exists()); |
| |
| D->addDirectory("/bar"); |
| Status = D->status("/bar"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->isStatusKnown()); |
| EXPECT_TRUE(Status->isDirectory()); |
| EXPECT_FALSE(Status->isRegularFile()); |
| EXPECT_FALSE(Status->isSymlink()); |
| EXPECT_FALSE(Status->isOther()); |
| EXPECT_TRUE(Status->exists()); |
| |
| D->addSymlink("/baz"); |
| Status = D->status("/baz"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->isStatusKnown()); |
| EXPECT_FALSE(Status->isDirectory()); |
| EXPECT_FALSE(Status->isRegularFile()); |
| EXPECT_TRUE(Status->isSymlink()); |
| EXPECT_FALSE(Status->isOther()); |
| EXPECT_TRUE(Status->exists()); |
| |
| EXPECT_TRUE(Status->equivalent(*Status)); |
| ErrorOr<vfs::Status> Status2 = D->status("/foo"); |
| ASSERT_FALSE(Status2.getError()); |
| EXPECT_FALSE(Status->equivalent(*Status2)); |
| } |
| |
| TEST(VirtualFileSystemTest, BaseOnlyOverlay) { |
| IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem()); |
| ErrorOr<vfs::Status> Status((std::error_code())); |
| EXPECT_FALSE(Status = D->status("/foo")); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(new vfs::OverlayFileSystem(D)); |
| EXPECT_FALSE(Status = O->status("/foo")); |
| |
| D->addRegularFile("/foo"); |
| Status = D->status("/foo"); |
| EXPECT_FALSE(Status.getError()); |
| |
| ErrorOr<vfs::Status> Status2((std::error_code())); |
| Status2 = O->status("/foo"); |
| EXPECT_FALSE(Status2.getError()); |
| EXPECT_TRUE(Status->equivalent(*Status2)); |
| } |
| |
| TEST(VirtualFileSystemTest, GetRealPathInOverlay) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addRegularFile("/foo"); |
| Lower->addSymlink("/lower_link"); |
| IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(Upper); |
| |
| // Regular file. |
| SmallString<16> RealPath; |
| EXPECT_FALSE(O->getRealPath("/foo", RealPath)); |
| EXPECT_EQ(RealPath.str(), "/foo"); |
| |
| // Expect no error getting real path for symlink in lower overlay. |
| EXPECT_FALSE(O->getRealPath("/lower_link", RealPath)); |
| EXPECT_EQ(RealPath.str(), "/symlink"); |
| |
| // Try a non-existing link. |
| EXPECT_EQ(O->getRealPath("/upper_link", RealPath), |
| errc::no_such_file_or_directory); |
| |
| // Add a new symlink in upper. |
| Upper->addSymlink("/upper_link"); |
| EXPECT_FALSE(O->getRealPath("/upper_link", RealPath)); |
| EXPECT_EQ(RealPath.str(), "/symlink"); |
| } |
| |
| TEST(VirtualFileSystemTest, OverlayFiles) { |
| IntrusiveRefCntPtr<DummyFileSystem> Base(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Top(new DummyFileSystem()); |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Base)); |
| O->pushOverlay(Middle); |
| O->pushOverlay(Top); |
| |
| ErrorOr<vfs::Status> Status1((std::error_code())), |
| Status2((std::error_code())), Status3((std::error_code())), |
| StatusB((std::error_code())), StatusM((std::error_code())), |
| StatusT((std::error_code())); |
| |
| Base->addRegularFile("/foo"); |
| StatusB = Base->status("/foo"); |
| ASSERT_FALSE(StatusB.getError()); |
| Status1 = O->status("/foo"); |
| ASSERT_FALSE(Status1.getError()); |
| Middle->addRegularFile("/foo"); |
| StatusM = Middle->status("/foo"); |
| ASSERT_FALSE(StatusM.getError()); |
| Status2 = O->status("/foo"); |
| ASSERT_FALSE(Status2.getError()); |
| Top->addRegularFile("/foo"); |
| StatusT = Top->status("/foo"); |
| ASSERT_FALSE(StatusT.getError()); |
| Status3 = O->status("/foo"); |
| ASSERT_FALSE(Status3.getError()); |
| |
| EXPECT_TRUE(Status1->equivalent(*StatusB)); |
| EXPECT_TRUE(Status2->equivalent(*StatusM)); |
| EXPECT_TRUE(Status3->equivalent(*StatusT)); |
| |
| EXPECT_FALSE(Status1->equivalent(*Status2)); |
| EXPECT_FALSE(Status2->equivalent(*Status3)); |
| EXPECT_FALSE(Status1->equivalent(*Status3)); |
| } |
| |
| TEST(VirtualFileSystemTest, OverlayDirsNonMerged) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(Upper); |
| |
| Lower->addDirectory("/lower-only"); |
| Upper->addDirectory("/upper-only"); |
| |
| // non-merged paths should be the same |
| ErrorOr<vfs::Status> Status1 = Lower->status("/lower-only"); |
| ASSERT_FALSE(Status1.getError()); |
| ErrorOr<vfs::Status> Status2 = O->status("/lower-only"); |
| ASSERT_FALSE(Status2.getError()); |
| EXPECT_TRUE(Status1->equivalent(*Status2)); |
| |
| Status1 = Upper->status("/upper-only"); |
| ASSERT_FALSE(Status1.getError()); |
| Status2 = O->status("/upper-only"); |
| ASSERT_FALSE(Status2.getError()); |
| EXPECT_TRUE(Status1->equivalent(*Status2)); |
| } |
| |
| TEST(VirtualFileSystemTest, MergedDirPermissions) { |
| // merged directories get the permissions of the upper dir |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(Upper); |
| |
| ErrorOr<vfs::Status> Status((std::error_code())); |
| Lower->addDirectory("/both", sys::fs::owner_read); |
| Upper->addDirectory("/both", sys::fs::owner_all | sys::fs::group_read); |
| Status = O->status("/both"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_EQ(0740, Status->getPermissions()); |
| |
| // permissions (as usual) are not recursively applied |
| Lower->addRegularFile("/both/foo", sys::fs::owner_read); |
| Upper->addRegularFile("/both/bar", sys::fs::owner_write); |
| Status = O->status("/both/foo"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_EQ(0400, Status->getPermissions()); |
| Status = O->status("/both/bar"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_EQ(0200, Status->getPermissions()); |
| } |
| |
| TEST(VirtualFileSystemTest, OverlayIterator) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addRegularFile("/foo"); |
| IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(Upper); |
| |
| ErrorOr<vfs::Status> Status((std::error_code())); |
| { |
| auto it = O->overlays_begin(); |
| auto end = O->overlays_end(); |
| |
| EXPECT_NE(it, end); |
| |
| Status = (*it)->status("/foo"); |
| ASSERT_TRUE(Status.getError()); |
| |
| it++; |
| EXPECT_NE(it, end); |
| |
| Status = (*it)->status("/foo"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| |
| it++; |
| EXPECT_EQ(it, end); |
| } |
| |
| { |
| auto it = O->overlays_rbegin(); |
| auto end = O->overlays_rend(); |
| |
| EXPECT_NE(it, end); |
| |
| Status = (*it)->status("/foo"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| |
| it++; |
| EXPECT_NE(it, end); |
| |
| Status = (*it)->status("/foo"); |
| ASSERT_TRUE(Status.getError()); |
| |
| it++; |
| EXPECT_EQ(it, end); |
| } |
| } |
| |
| TEST(VirtualFileSystemTest, BasicRealFSIteration) { |
| TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem(); |
| |
| std::error_code EC; |
| vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory.path()), EC); |
| ASSERT_FALSE(EC); |
| EXPECT_EQ(vfs::directory_iterator(), I); // empty directory is empty |
| |
| TempDir _a(TestDirectory.path("a")); |
| TempDir _ab(TestDirectory.path("a/b")); |
| TempDir _c(TestDirectory.path("c")); |
| TempDir _cd(TestDirectory.path("c/d")); |
| |
| I = FS->dir_begin(Twine(TestDirectory.path()), EC); |
| ASSERT_FALSE(EC); |
| ASSERT_NE(vfs::directory_iterator(), I); |
| // Check either a or c, since we can't rely on the iteration order. |
| EXPECT_TRUE(I->path().endswith("a") || I->path().endswith("c")); |
| I.increment(EC); |
| ASSERT_FALSE(EC); |
| ASSERT_NE(vfs::directory_iterator(), I); |
| EXPECT_TRUE(I->path().endswith("a") || I->path().endswith("c")); |
| I.increment(EC); |
| EXPECT_EQ(vfs::directory_iterator(), I); |
| } |
| |
| #ifdef LLVM_ON_UNIX |
| TEST(VirtualFileSystemTest, MultipleWorkingDirs) { |
| // Our root contains a/aa, b/bb, c, where c is a link to a/. |
| // Run tests both in root/b/ and root/c/ (to test "normal" and symlink dirs). |
| // Interleave operations to show the working directories are independent. |
| TempDir Root("r", /*Unique*/ true); |
| TempDir ADir(Root.path("a")); |
| TempDir BDir(Root.path("b")); |
| TempLink C(ADir.path(), Root.path("c")); |
| TempFile AA(ADir.path("aa"), "", "aaaa"); |
| TempFile BB(BDir.path("bb"), "", "bbbb"); |
| std::unique_ptr<vfs::FileSystem> BFS = vfs::createPhysicalFileSystem(), |
| CFS = vfs::createPhysicalFileSystem(); |
| |
| ASSERT_FALSE(BFS->setCurrentWorkingDirectory(BDir.path())); |
| ASSERT_FALSE(CFS->setCurrentWorkingDirectory(C.path())); |
| EXPECT_EQ(BDir.path(), *BFS->getCurrentWorkingDirectory()); |
| EXPECT_EQ(C.path(), *CFS->getCurrentWorkingDirectory()); |
| |
| // openFileForRead(), indirectly. |
| auto BBuf = BFS->getBufferForFile("bb"); |
| ASSERT_TRUE(BBuf); |
| EXPECT_EQ("bbbb", (*BBuf)->getBuffer()); |
| |
| auto ABuf = CFS->getBufferForFile("aa"); |
| ASSERT_TRUE(ABuf); |
| EXPECT_EQ("aaaa", (*ABuf)->getBuffer()); |
| |
| // status() |
| auto BStat = BFS->status("bb"); |
| ASSERT_TRUE(BStat); |
| EXPECT_EQ("bb", BStat->getName()); |
| |
| auto AStat = CFS->status("aa"); |
| ASSERT_TRUE(AStat); |
| EXPECT_EQ("aa", AStat->getName()); // unresolved name |
| |
| // getRealPath() |
| SmallString<128> BPath; |
| ASSERT_FALSE(BFS->getRealPath("bb", BPath)); |
| EXPECT_EQ(BB.path(), BPath); |
| |
| SmallString<128> APath; |
| ASSERT_FALSE(CFS->getRealPath("aa", APath)); |
| EXPECT_EQ(AA.path(), APath); // Reports resolved name. |
| |
| // dir_begin |
| std::error_code EC; |
| auto BIt = BFS->dir_begin(".", EC); |
| ASSERT_FALSE(EC); |
| ASSERT_NE(BIt, vfs::directory_iterator()); |
| EXPECT_EQ((BDir.path() + "/./bb").str(), BIt->path()); |
| BIt.increment(EC); |
| ASSERT_FALSE(EC); |
| ASSERT_EQ(BIt, vfs::directory_iterator()); |
| |
| auto CIt = CFS->dir_begin(".", EC); |
| ASSERT_FALSE(EC); |
| ASSERT_NE(CIt, vfs::directory_iterator()); |
| EXPECT_EQ((ADir.path() + "/./aa").str(), |
| CIt->path()); // Partly resolved name! |
| CIt.increment(EC); // Because likely to read through this path. |
| ASSERT_FALSE(EC); |
| ASSERT_EQ(CIt, vfs::directory_iterator()); |
| } |
| |
| TEST(VirtualFileSystemTest, BrokenSymlinkRealFSIteration) { |
| TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem(); |
| |
| TempLink _a("no_such_file", TestDirectory.path("a")); |
| TempDir _b(TestDirectory.path("b")); |
| TempLink _c("no_such_file", TestDirectory.path("c")); |
| |
| // Should get no iteration error, but a stat error for the broken symlinks. |
| std::map<std::string, std::error_code> StatResults; |
| std::error_code EC; |
| for (vfs::directory_iterator |
| I = FS->dir_begin(Twine(TestDirectory.path()), EC), |
| E; |
| I != E; I.increment(EC)) { |
| EXPECT_FALSE(EC); |
| StatResults[std::string(sys::path::filename(I->path()))] = |
| FS->status(I->path()).getError(); |
| } |
| EXPECT_THAT( |
| StatResults, |
| ElementsAre( |
| Pair("a", std::make_error_code(std::errc::no_such_file_or_directory)), |
| Pair("b", std::error_code()), |
| Pair("c", |
| std::make_error_code(std::errc::no_such_file_or_directory)))); |
| } |
| #endif |
| |
| TEST(VirtualFileSystemTest, BasicRealFSRecursiveIteration) { |
| TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem(); |
| |
| std::error_code EC; |
| auto I = |
| vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC); |
| ASSERT_FALSE(EC); |
| EXPECT_EQ(vfs::recursive_directory_iterator(), I); // empty directory is empty |
| |
| TempDir _a(TestDirectory.path("a")); |
| TempDir _ab(TestDirectory.path("a/b")); |
| TempDir _c(TestDirectory.path("c")); |
| TempDir _cd(TestDirectory.path("c/d")); |
| |
| I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC); |
| ASSERT_FALSE(EC); |
| ASSERT_NE(vfs::recursive_directory_iterator(), I); |
| |
| std::vector<std::string> Contents; |
| for (auto E = vfs::recursive_directory_iterator(); !EC && I != E; |
| I.increment(EC)) { |
| Contents.push_back(std::string(I->path())); |
| } |
| |
| // Check contents, which may be in any order |
| EXPECT_EQ(4U, Contents.size()); |
| int Counts[4] = {0, 0, 0, 0}; |
| for (const std::string &Name : Contents) { |
| ASSERT_FALSE(Name.empty()); |
| int Index = Name[Name.size() - 1] - 'a'; |
| ASSERT_TRUE(Index >= 0 && Index < 4); |
| Counts[Index]++; |
| } |
| EXPECT_EQ(1, Counts[0]); // a |
| EXPECT_EQ(1, Counts[1]); // b |
| EXPECT_EQ(1, Counts[2]); // c |
| EXPECT_EQ(1, Counts[3]); // d |
| } |
| |
| TEST(VirtualFileSystemTest, BasicRealFSRecursiveIterationNoPush) { |
| TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true); |
| |
| TempDir _a(TestDirectory.path("a")); |
| TempDir _ab(TestDirectory.path("a/b")); |
| TempDir _c(TestDirectory.path("c")); |
| TempDir _cd(TestDirectory.path("c/d")); |
| TempDir _e(TestDirectory.path("e")); |
| TempDir _ef(TestDirectory.path("e/f")); |
| TempDir _g(TestDirectory.path("g")); |
| |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem(); |
| |
| // Test that calling no_push on entries without subdirectories has no effect. |
| { |
| std::error_code EC; |
| auto I = |
| vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC); |
| ASSERT_FALSE(EC); |
| |
| std::vector<std::string> Contents; |
| for (auto E = vfs::recursive_directory_iterator(); !EC && I != E; |
| I.increment(EC)) { |
| Contents.push_back(std::string(I->path())); |
| char last = I->path().back(); |
| switch (last) { |
| case 'b': |
| case 'd': |
| case 'f': |
| case 'g': |
| I.no_push(); |
| break; |
| default: |
| break; |
| } |
| } |
| EXPECT_EQ(7U, Contents.size()); |
| } |
| |
| // Test that calling no_push skips subdirectories. |
| { |
| std::error_code EC; |
| auto I = |
| vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC); |
| ASSERT_FALSE(EC); |
| |
| std::vector<std::string> Contents; |
| for (auto E = vfs::recursive_directory_iterator(); !EC && I != E; |
| I.increment(EC)) { |
| Contents.push_back(std::string(I->path())); |
| char last = I->path().back(); |
| switch (last) { |
| case 'a': |
| case 'c': |
| case 'e': |
| I.no_push(); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| // Check contents, which may be in any order |
| EXPECT_EQ(4U, Contents.size()); |
| int Counts[7] = {0, 0, 0, 0, 0, 0, 0}; |
| for (const std::string &Name : Contents) { |
| ASSERT_FALSE(Name.empty()); |
| int Index = Name[Name.size() - 1] - 'a'; |
| ASSERT_TRUE(Index >= 0 && Index < 7); |
| Counts[Index]++; |
| } |
| EXPECT_EQ(1, Counts[0]); // a |
| EXPECT_EQ(0, Counts[1]); // b |
| EXPECT_EQ(1, Counts[2]); // c |
| EXPECT_EQ(0, Counts[3]); // d |
| EXPECT_EQ(1, Counts[4]); // e |
| EXPECT_EQ(0, Counts[5]); // f |
| EXPECT_EQ(1, Counts[6]); // g |
| } |
| } |
| |
| #ifdef LLVM_ON_UNIX |
| TEST(VirtualFileSystemTest, BrokenSymlinkRealFSRecursiveIteration) { |
| TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem(); |
| |
| TempLink _a("no_such_file", TestDirectory.path("a")); |
| TempDir _b(TestDirectory.path("b")); |
| TempLink _ba("no_such_file", TestDirectory.path("b/a")); |
| TempDir _bb(TestDirectory.path("b/b")); |
| TempLink _bc("no_such_file", TestDirectory.path("b/c")); |
| TempLink _c("no_such_file", TestDirectory.path("c")); |
| TempDir _d(TestDirectory.path("d")); |
| TempDir _dd(TestDirectory.path("d/d")); |
| TempDir _ddd(TestDirectory.path("d/d/d")); |
| TempLink _e("no_such_file", TestDirectory.path("e")); |
| |
| std::vector<std::string> VisitedBrokenSymlinks; |
| std::vector<std::string> VisitedNonBrokenSymlinks; |
| std::error_code EC; |
| for (vfs::recursive_directory_iterator |
| I(*FS, Twine(TestDirectory.path()), EC), |
| E; |
| I != E; I.increment(EC)) { |
| EXPECT_FALSE(EC); |
| (FS->status(I->path()) ? VisitedNonBrokenSymlinks : VisitedBrokenSymlinks) |
| .push_back(std::string(I->path())); |
| } |
| |
| // Check visited file names. |
| EXPECT_THAT(VisitedBrokenSymlinks, |
| UnorderedElementsAre(_a.path().str(), _ba.path().str(), |
| _bc.path().str(), _c.path().str(), |
| _e.path().str())); |
| EXPECT_THAT(VisitedNonBrokenSymlinks, |
| UnorderedElementsAre(_b.path().str(), _bb.path().str(), |
| _d.path().str(), _dd.path().str(), |
| _ddd.path().str())); |
| } |
| #endif |
| |
| template <typename DirIter> |
| static void checkContents(DirIter I, ArrayRef<StringRef> ExpectedOut) { |
| std::error_code EC; |
| SmallVector<StringRef, 4> Expected(ExpectedOut.begin(), ExpectedOut.end()); |
| SmallVector<std::string, 4> InputToCheck; |
| |
| // Do not rely on iteration order to check for contents, sort both |
| // content vectors before comparison. |
| for (DirIter E; !EC && I != E; I.increment(EC)) |
| InputToCheck.push_back(std::string(I->path())); |
| |
| llvm::sort(InputToCheck); |
| llvm::sort(Expected); |
| EXPECT_EQ(InputToCheck.size(), Expected.size()); |
| |
| unsigned LastElt = std::min(InputToCheck.size(), Expected.size()); |
| for (unsigned Idx = 0; Idx != LastElt; ++Idx) |
| EXPECT_EQ(StringRef(InputToCheck[Idx]), Expected[Idx]); |
| } |
| |
| TEST(VirtualFileSystemTest, OverlayIteration) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(Upper); |
| |
| std::error_code EC; |
| checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>()); |
| |
| Lower->addRegularFile("/file1"); |
| checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file1")); |
| |
| Upper->addRegularFile("/file2"); |
| checkContents(O->dir_begin("/", EC), {"/file2", "/file1"}); |
| |
| Lower->addDirectory("/dir1"); |
| Lower->addRegularFile("/dir1/foo"); |
| Upper->addDirectory("/dir2"); |
| Upper->addRegularFile("/dir2/foo"); |
| checkContents(O->dir_begin("/dir2", EC), ArrayRef<StringRef>("/dir2/foo")); |
| checkContents(O->dir_begin("/", EC), {"/dir2", "/file2", "/dir1", "/file1"}); |
| } |
| |
| TEST(VirtualFileSystemTest, OverlayRecursiveIteration) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(Middle); |
| O->pushOverlay(Upper); |
| |
| std::error_code EC; |
| checkContents(vfs::recursive_directory_iterator(*O, "/", EC), |
| ArrayRef<StringRef>()); |
| |
| Lower->addRegularFile("/file1"); |
| checkContents(vfs::recursive_directory_iterator(*O, "/", EC), |
| ArrayRef<StringRef>("/file1")); |
| |
| Upper->addDirectory("/dir"); |
| Upper->addRegularFile("/dir/file2"); |
| checkContents(vfs::recursive_directory_iterator(*O, "/", EC), |
| {"/dir", "/dir/file2", "/file1"}); |
| |
| Lower->addDirectory("/dir1"); |
| Lower->addRegularFile("/dir1/foo"); |
| Lower->addDirectory("/dir1/a"); |
| Lower->addRegularFile("/dir1/a/b"); |
| Middle->addDirectory("/a"); |
| Middle->addDirectory("/a/b"); |
| Middle->addDirectory("/a/b/c"); |
| Middle->addRegularFile("/a/b/c/d"); |
| Middle->addRegularFile("/hiddenByUp"); |
| Upper->addDirectory("/dir2"); |
| Upper->addRegularFile("/dir2/foo"); |
| Upper->addRegularFile("/hiddenByUp"); |
| checkContents(vfs::recursive_directory_iterator(*O, "/dir2", EC), |
| ArrayRef<StringRef>("/dir2/foo")); |
| checkContents(vfs::recursive_directory_iterator(*O, "/", EC), |
| {"/dir", "/dir/file2", "/dir2", "/dir2/foo", "/hiddenByUp", |
| "/a", "/a/b", "/a/b/c", "/a/b/c/d", "/dir1", "/dir1/a", |
| "/dir1/a/b", "/dir1/foo", "/file1"}); |
| } |
| |
| TEST(VirtualFileSystemTest, ThreeLevelIteration) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(Middle); |
| O->pushOverlay(Upper); |
| |
| std::error_code EC; |
| checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>()); |
| |
| Middle->addRegularFile("/file2"); |
| checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file2")); |
| |
| Lower->addRegularFile("/file1"); |
| Upper->addRegularFile("/file3"); |
| checkContents(O->dir_begin("/", EC), {"/file3", "/file2", "/file1"}); |
| } |
| |
| TEST(VirtualFileSystemTest, HiddenInIteration) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem()); |
| IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem()); |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(Middle); |
| O->pushOverlay(Upper); |
| |
| std::error_code EC; |
| Lower->addRegularFile("/onlyInLow"); |
| Lower->addDirectory("/hiddenByMid"); |
| Lower->addDirectory("/hiddenByUp"); |
| Middle->addRegularFile("/onlyInMid"); |
| Middle->addRegularFile("/hiddenByMid"); |
| Middle->addDirectory("/hiddenByUp"); |
| Upper->addRegularFile("/onlyInUp"); |
| Upper->addRegularFile("/hiddenByUp"); |
| checkContents( |
| O->dir_begin("/", EC), |
| {"/hiddenByUp", "/onlyInUp", "/hiddenByMid", "/onlyInMid", "/onlyInLow"}); |
| |
| // Make sure we get the top-most entry |
| { |
| std::error_code EC; |
| vfs::directory_iterator I = O->dir_begin("/", EC), E; |
| for (; !EC && I != E; I.increment(EC)) |
| if (I->path() == "/hiddenByUp") |
| break; |
| ASSERT_NE(E, I); |
| EXPECT_EQ(sys::fs::file_type::regular_file, I->type()); |
| } |
| { |
| std::error_code EC; |
| vfs::directory_iterator I = O->dir_begin("/", EC), E; |
| for (; !EC && I != E; I.increment(EC)) |
| if (I->path() == "/hiddenByMid") |
| break; |
| ASSERT_NE(E, I); |
| EXPECT_EQ(sys::fs::file_type::regular_file, I->type()); |
| } |
| } |
| |
| TEST(ProxyFileSystemTest, Basic) { |
| IntrusiveRefCntPtr<vfs::InMemoryFileSystem> Base( |
| new vfs::InMemoryFileSystem()); |
| vfs::ProxyFileSystem PFS(Base); |
| |
| Base->addFile("/a", 0, MemoryBuffer::getMemBuffer("test")); |
| |
| auto Stat = PFS.status("/a"); |
| ASSERT_FALSE(Stat.getError()); |
| |
| auto File = PFS.openFileForRead("/a"); |
| ASSERT_FALSE(File.getError()); |
| EXPECT_EQ("test", (*(*File)->getBuffer("ignored"))->getBuffer()); |
| |
| std::error_code EC; |
| vfs::directory_iterator I = PFS.dir_begin("/", EC); |
| ASSERT_FALSE(EC); |
| ASSERT_EQ("/a", I->path()); |
| I.increment(EC); |
| ASSERT_FALSE(EC); |
| ASSERT_EQ(vfs::directory_iterator(), I); |
| |
| ASSERT_FALSE(PFS.setCurrentWorkingDirectory("/")); |
| |
| auto PWD = PFS.getCurrentWorkingDirectory(); |
| ASSERT_FALSE(PWD.getError()); |
| ASSERT_EQ("/", *PWD); |
| |
| SmallString<16> Path; |
| ASSERT_FALSE(PFS.getRealPath("a", Path)); |
| ASSERT_EQ("/a", Path); |
| |
| bool Local = true; |
| ASSERT_FALSE(PFS.isLocal("/a", Local)); |
| EXPECT_FALSE(Local); |
| } |
| |
| class InMemoryFileSystemTest : public ::testing::Test { |
| protected: |
| llvm::vfs::InMemoryFileSystem FS; |
| llvm::vfs::InMemoryFileSystem NormalizedFS; |
| |
| InMemoryFileSystemTest() |
| : FS(/*UseNormalizedPaths=*/false), |
| NormalizedFS(/*UseNormalizedPaths=*/true) {} |
| }; |
| |
| MATCHER_P2(IsHardLinkTo, FS, Target, "") { |
| StringRef From = arg; |
| StringRef To = Target; |
| auto OpenedFrom = FS->openFileForRead(From); |
| auto OpenedTo = FS->openFileForRead(To); |
| return !OpenedFrom.getError() && !OpenedTo.getError() && |
| (*OpenedFrom)->status()->getUniqueID() == |
| (*OpenedTo)->status()->getUniqueID(); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, IsEmpty) { |
| auto Stat = FS.status("/a"); |
| ASSERT_EQ(Stat.getError(), errc::no_such_file_or_directory) << FS.toString(); |
| Stat = FS.status("/"); |
| ASSERT_EQ(Stat.getError(), errc::no_such_file_or_directory) << FS.toString(); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, WindowsPath) { |
| FS.addFile("c:/windows/system128/foo.cpp", 0, MemoryBuffer::getMemBuffer("")); |
| auto Stat = FS.status("c:"); |
| #if !defined(_WIN32) |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString(); |
| #endif |
| Stat = FS.status("c:/windows/system128/foo.cpp"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString(); |
| FS.addFile("d:/windows/foo.cpp", 0, MemoryBuffer::getMemBuffer("")); |
| Stat = FS.status("d:/windows/foo.cpp"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString(); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, OverlayFile) { |
| FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")); |
| NormalizedFS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")); |
| auto Stat = FS.status("/"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString(); |
| Stat = FS.status("/."); |
| ASSERT_FALSE(Stat); |
| Stat = NormalizedFS.status("/."); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString(); |
| Stat = FS.status("/a"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_EQ("/a", Stat->getName()); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, OverlayFileNoOwn) { |
| auto Buf = MemoryBuffer::getMemBuffer("a"); |
| FS.addFileNoOwn("/a", 0, *Buf); |
| auto Stat = FS.status("/a"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_EQ("/a", Stat->getName()); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, OpenFileForRead) { |
| FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")); |
| FS.addFile("././c", 0, MemoryBuffer::getMemBuffer("c")); |
| FS.addFile("./d/../d", 0, MemoryBuffer::getMemBuffer("d")); |
| NormalizedFS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")); |
| NormalizedFS.addFile("././c", 0, MemoryBuffer::getMemBuffer("c")); |
| NormalizedFS.addFile("./d/../d", 0, MemoryBuffer::getMemBuffer("d")); |
| auto File = FS.openFileForRead("/a"); |
| ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer()); |
| File = FS.openFileForRead("/a"); // Open again. |
| ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer()); |
| File = NormalizedFS.openFileForRead("/././a"); // Open again. |
| ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer()); |
| File = FS.openFileForRead("/"); |
| ASSERT_EQ(File.getError(), errc::invalid_argument) << FS.toString(); |
| File = FS.openFileForRead("/b"); |
| ASSERT_EQ(File.getError(), errc::no_such_file_or_directory) << FS.toString(); |
| File = FS.openFileForRead("./c"); |
| ASSERT_FALSE(File); |
| File = FS.openFileForRead("e/../d"); |
| ASSERT_FALSE(File); |
| File = NormalizedFS.openFileForRead("./c"); |
| ASSERT_EQ("c", (*(*File)->getBuffer("ignored"))->getBuffer()); |
| File = NormalizedFS.openFileForRead("e/../d"); |
| ASSERT_EQ("d", (*(*File)->getBuffer("ignored"))->getBuffer()); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, DuplicatedFile) { |
| ASSERT_TRUE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a"))); |
| ASSERT_FALSE(FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("a"))); |
| ASSERT_TRUE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a"))); |
| ASSERT_FALSE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("b"))); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, DirectoryIteration) { |
| FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("")); |
| FS.addFile("/b/c", 0, MemoryBuffer::getMemBuffer("")); |
| |
| std::error_code EC; |
| vfs::directory_iterator I = FS.dir_begin("/", EC); |
| ASSERT_FALSE(EC); |
| ASSERT_EQ("/a", I->path()); |
| I.increment(EC); |
| ASSERT_FALSE(EC); |
| ASSERT_EQ("/b", I->path()); |
| I.increment(EC); |
| ASSERT_FALSE(EC); |
| ASSERT_EQ(vfs::directory_iterator(), I); |
| |
| I = FS.dir_begin("/b", EC); |
| ASSERT_FALSE(EC); |
| // When on Windows, we end up with "/b\\c" as the name. Convert to Posix |
| // path for the sake of the comparison. |
| ASSERT_EQ("/b/c", getPosixPath(std::string(I->path()))); |
| I.increment(EC); |
| ASSERT_FALSE(EC); |
| ASSERT_EQ(vfs::directory_iterator(), I); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, WorkingDirectory) { |
| FS.setCurrentWorkingDirectory("/b"); |
| FS.addFile("c", 0, MemoryBuffer::getMemBuffer("")); |
| |
| auto Stat = FS.status("/b/c"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_EQ("/b/c", Stat->getName()); |
| ASSERT_EQ("/b", *FS.getCurrentWorkingDirectory()); |
| |
| Stat = FS.status("c"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| |
| NormalizedFS.setCurrentWorkingDirectory("/b/c"); |
| NormalizedFS.setCurrentWorkingDirectory("."); |
| ASSERT_EQ("/b/c", |
| getPosixPath(NormalizedFS.getCurrentWorkingDirectory().get())); |
| NormalizedFS.setCurrentWorkingDirectory(".."); |
| ASSERT_EQ("/b", |
| getPosixPath(NormalizedFS.getCurrentWorkingDirectory().get())); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, IsLocal) { |
| FS.setCurrentWorkingDirectory("/b"); |
| FS.addFile("c", 0, MemoryBuffer::getMemBuffer("")); |
| |
| std::error_code EC; |
| bool IsLocal = true; |
| EC = FS.isLocal("c", IsLocal); |
| ASSERT_FALSE(EC); |
| ASSERT_FALSE(IsLocal); |
| } |
| |
| #if !defined(_WIN32) |
| TEST_F(InMemoryFileSystemTest, GetRealPath) { |
| SmallString<16> Path; |
| EXPECT_EQ(FS.getRealPath("b", Path), errc::operation_not_permitted); |
| |
| auto GetRealPath = [this](StringRef P) { |
| SmallString<16> Output; |
| auto EC = FS.getRealPath(P, Output); |
| EXPECT_FALSE(EC); |
| return std::string(Output); |
| }; |
| |
| FS.setCurrentWorkingDirectory("a"); |
| EXPECT_EQ(GetRealPath("b"), "a/b"); |
| EXPECT_EQ(GetRealPath("../b"), "b"); |
| EXPECT_EQ(GetRealPath("b/./c"), "a/b/c"); |
| |
| FS.setCurrentWorkingDirectory("/a"); |
| EXPECT_EQ(GetRealPath("b"), "/a/b"); |
| EXPECT_EQ(GetRealPath("../b"), "/b"); |
| EXPECT_EQ(GetRealPath("b/./c"), "/a/b/c"); |
| } |
| #endif // _WIN32 |
| |
| TEST_F(InMemoryFileSystemTest, AddFileWithUser) { |
| FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), 0xFEEDFACE); |
| auto Stat = FS.status("/a"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isDirectory()); |
| ASSERT_EQ(0xFEEDFACE, Stat->getUser()); |
| Stat = FS.status("/a/b"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isDirectory()); |
| ASSERT_EQ(0xFEEDFACE, Stat->getUser()); |
| Stat = FS.status("/a/b/c"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isRegularFile()); |
| ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions()); |
| ASSERT_EQ(0xFEEDFACE, Stat->getUser()); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddFileWithGroup) { |
| FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), None, 0xDABBAD00); |
| auto Stat = FS.status("/a"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isDirectory()); |
| ASSERT_EQ(0xDABBAD00, Stat->getGroup()); |
| Stat = FS.status("/a/b"); |
| ASSERT_TRUE(Stat->isDirectory()); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_EQ(0xDABBAD00, Stat->getGroup()); |
| Stat = FS.status("/a/b/c"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isRegularFile()); |
| ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions()); |
| ASSERT_EQ(0xDABBAD00, Stat->getGroup()); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddFileWithFileType) { |
| FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), None, None, |
| sys::fs::file_type::socket_file); |
| auto Stat = FS.status("/a"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isDirectory()); |
| Stat = FS.status("/a/b"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isDirectory()); |
| Stat = FS.status("/a/b/c"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_EQ(sys::fs::file_type::socket_file, Stat->getType()); |
| ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions()); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddFileWithPerms) { |
| FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), None, None, None, |
| sys::fs::perms::owner_read | sys::fs::perms::owner_write); |
| auto Stat = FS.status("/a"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isDirectory()); |
| ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write | |
| sys::fs::perms::owner_exe, |
| Stat->getPermissions()); |
| Stat = FS.status("/a/b"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isDirectory()); |
| ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write | |
| sys::fs::perms::owner_exe, |
| Stat->getPermissions()); |
| Stat = FS.status("/a/b/c"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isRegularFile()); |
| ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write, |
| Stat->getPermissions()); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddDirectoryThenAddChild) { |
| FS.addFile("/a", 0, MemoryBuffer::getMemBuffer(""), /*User=*/None, |
| /*Group=*/None, sys::fs::file_type::directory_file); |
| FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("abc"), /*User=*/None, |
| /*Group=*/None, sys::fs::file_type::regular_file); |
| auto Stat = FS.status("/a"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isDirectory()); |
| Stat = FS.status("/a/b"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString(); |
| ASSERT_TRUE(Stat->isRegularFile()); |
| } |
| |
| // Test that the name returned by status() is in the same form as the path that |
| // was requested (to match the behavior of RealFileSystem). |
| TEST_F(InMemoryFileSystemTest, StatusName) { |
| NormalizedFS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), |
| /*User=*/None, |
| /*Group=*/None, sys::fs::file_type::regular_file); |
| NormalizedFS.setCurrentWorkingDirectory("/a/b"); |
| |
| // Access using InMemoryFileSystem::status. |
| auto Stat = NormalizedFS.status("../b/c"); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" |
| << NormalizedFS.toString(); |
| ASSERT_TRUE(Stat->isRegularFile()); |
| ASSERT_EQ("../b/c", Stat->getName()); |
| |
| // Access using InMemoryFileAdaptor::status. |
| auto File = NormalizedFS.openFileForRead("../b/c"); |
| ASSERT_FALSE(File.getError()) << File.getError() << "\n" |
| << NormalizedFS.toString(); |
| Stat = (*File)->status(); |
| ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" |
| << NormalizedFS.toString(); |
| ASSERT_TRUE(Stat->isRegularFile()); |
| ASSERT_EQ("../b/c", Stat->getName()); |
| |
| // Access using a directory iterator. |
| std::error_code EC; |
| llvm::vfs::directory_iterator It = NormalizedFS.dir_begin("../b", EC); |
| // When on Windows, we end up with "../b\\c" as the name. Convert to Posix |
| // path for the sake of the comparison. |
| ASSERT_EQ("../b/c", getPosixPath(std::string(It->path()))); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddHardLinkToFile) { |
| StringRef FromLink = "/path/to/FROM/link"; |
| StringRef Target = "/path/to/TO/file"; |
| FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target")); |
| EXPECT_TRUE(FS.addHardLink(FromLink, Target)); |
| EXPECT_THAT(FromLink, IsHardLinkTo(&FS, Target)); |
| EXPECT_TRUE(FS.status(FromLink)->getSize() == FS.status(Target)->getSize()); |
| EXPECT_TRUE(FS.getBufferForFile(FromLink)->get()->getBuffer() == |
| FS.getBufferForFile(Target)->get()->getBuffer()); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddHardLinkInChainPattern) { |
| StringRef Link0 = "/path/to/0/link"; |
| StringRef Link1 = "/path/to/1/link"; |
| StringRef Link2 = "/path/to/2/link"; |
| StringRef Target = "/path/to/target"; |
| FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target file")); |
| EXPECT_TRUE(FS.addHardLink(Link2, Target)); |
| EXPECT_TRUE(FS.addHardLink(Link1, Link2)); |
| EXPECT_TRUE(FS.addHardLink(Link0, Link1)); |
| EXPECT_THAT(Link0, IsHardLinkTo(&FS, Target)); |
| EXPECT_THAT(Link1, IsHardLinkTo(&FS, Target)); |
| EXPECT_THAT(Link2, IsHardLinkTo(&FS, Target)); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddHardLinkToAFileThatWasNotAddedBefore) { |
| EXPECT_FALSE(FS.addHardLink("/path/to/link", "/path/to/target")); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddHardLinkFromAFileThatWasAddedBefore) { |
| StringRef Link = "/path/to/link"; |
| StringRef Target = "/path/to/target"; |
| FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target")); |
| FS.addFile(Link, 0, MemoryBuffer::getMemBuffer("content of link")); |
| EXPECT_FALSE(FS.addHardLink(Link, Target)); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddSameHardLinkMoreThanOnce) { |
| StringRef Link = "/path/to/link"; |
| StringRef Target = "/path/to/target"; |
| FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target")); |
| EXPECT_TRUE(FS.addHardLink(Link, Target)); |
| EXPECT_FALSE(FS.addHardLink(Link, Target)); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddFileInPlaceOfAHardLinkWithSameContent) { |
| StringRef Link = "/path/to/link"; |
| StringRef Target = "/path/to/target"; |
| StringRef Content = "content of target"; |
| EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content))); |
| EXPECT_TRUE(FS.addHardLink(Link, Target)); |
| EXPECT_TRUE(FS.addFile(Link, 0, MemoryBuffer::getMemBuffer(Content))); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddFileInPlaceOfAHardLinkWithDifferentContent) { |
| StringRef Link = "/path/to/link"; |
| StringRef Target = "/path/to/target"; |
| StringRef Content = "content of target"; |
| StringRef LinkContent = "different content of link"; |
| EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content))); |
| EXPECT_TRUE(FS.addHardLink(Link, Target)); |
| EXPECT_FALSE(FS.addFile(Link, 0, MemoryBuffer::getMemBuffer(LinkContent))); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddHardLinkToADirectory) { |
| StringRef Dir = "path/to/dummy/dir"; |
| StringRef Link = "/path/to/link"; |
| StringRef File = "path/to/dummy/dir/target"; |
| StringRef Content = "content of target"; |
| EXPECT_TRUE(FS.addFile(File, 0, MemoryBuffer::getMemBuffer(Content))); |
| EXPECT_FALSE(FS.addHardLink(Link, Dir)); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddHardLinkFromADirectory) { |
| StringRef Dir = "path/to/dummy/dir"; |
| StringRef Target = "path/to/dummy/dir/target"; |
| StringRef Content = "content of target"; |
| EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content))); |
| EXPECT_FALSE(FS.addHardLink(Dir, Target)); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, AddHardLinkUnderAFile) { |
| StringRef CommonContent = "content string"; |
| FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer(CommonContent)); |
| FS.addFile("/c/d", 0, MemoryBuffer::getMemBuffer(CommonContent)); |
| EXPECT_FALSE(FS.addHardLink("/c/d/e", "/a/b")); |
| } |
| |
| TEST_F(InMemoryFileSystemTest, RecursiveIterationWithHardLink) { |
| std::error_code EC; |
| FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("content string")); |
| EXPECT_TRUE(FS.addHardLink("/c/d", "/a/b")); |
| auto I = vfs::recursive_directory_iterator(FS, "/", EC); |
| ASSERT_FALSE(EC); |
| std::vector<std::string> Nodes; |
| for (auto E = vfs::recursive_directory_iterator(); !EC && I != E; |
| I.increment(EC)) { |
| Nodes.push_back(getPosixPath(std::string(I->path()))); |
| } |
| EXPECT_THAT(Nodes, testing::UnorderedElementsAre("/a", "/a/b", "/c", "/c/d")); |
| } |
| |
| // NOTE: in the tests below, we use '//root/' as our root directory, since it is |
| // a legal *absolute* path on Windows as well as *nix. |
| class VFSFromYAMLTest : public ::testing::Test { |
| public: |
| int NumDiagnostics; |
| |
| void SetUp() override { NumDiagnostics = 0; } |
| |
| static void CountingDiagHandler(const SMDiagnostic &, void *Context) { |
| VFSFromYAMLTest *Test = static_cast<VFSFromYAMLTest *>(Context); |
| ++Test->NumDiagnostics; |
| } |
| |
| std::unique_ptr<vfs::FileSystem> |
| getFromYAMLRawString(StringRef Content, |
| IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS) { |
| std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Content); |
| return getVFSFromYAML(std::move(Buffer), CountingDiagHandler, "", this, |
| ExternalFS); |
| } |
| |
| std::unique_ptr<vfs::FileSystem> getFromYAMLString( |
| StringRef Content, |
| IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS = new DummyFileSystem()) { |
| std::string VersionPlusContent("{\n 'version':0,\n"); |
| VersionPlusContent += Content.slice(Content.find('{') + 1, StringRef::npos); |
| return getFromYAMLRawString(VersionPlusContent, ExternalFS); |
| } |
| |
| // This is intended as a "XFAIL" for windows hosts. |
| bool supportsSameDirMultipleYAMLEntries() { |
| Triple Host(Triple::normalize(sys::getProcessTriple())); |
| return !Host.isOSWindows(); |
| } |
| }; |
| |
| TEST_F(VFSFromYAMLTest, BasicVFSFromYAML) { |
| IntrusiveRefCntPtr<vfs::FileSystem> FS; |
| FS = getFromYAMLString(""); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString("[]"); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString("'string'"); |
| EXPECT_EQ(nullptr, FS.get()); |
| EXPECT_EQ(3, NumDiagnostics); |
| } |
| |
| TEST_F(VFSFromYAMLTest, MappedFiles) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/foo/bar"); |
| Lower->addRegularFile("//root/foo/bar/a"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'file1',\n" |
| " 'external-contents': '//root/foo/bar/a'\n" |
| " },\n" |
| " {\n" |
| " 'type': 'file',\n" |
| " 'name': 'file2',\n" |
| " 'external-contents': '//root/foo/b'\n" |
| " },\n" |
| " {\n" |
| " 'type': 'directory-remap',\n" |
| " 'name': 'mappeddir',\n" |
| " 'external-contents': '//root/foo/bar'\n" |
| " },\n" |
| " {\n" |
| " 'type': 'directory-remap',\n" |
| " 'name': 'mappeddir2',\n" |
| " 'use-external-name': false,\n" |
| " 'external-contents': '//root/foo/bar'\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(FS); |
| |
| // file |
| ErrorOr<vfs::Status> S = O->status("//root/file1"); |
| ASSERT_FALSE(S.getError()); |
| EXPECT_EQ("//root/foo/bar/a", S->getName()); |
| EXPECT_TRUE(S->IsVFSMapped); |
| |
| ErrorOr<vfs::Status> SLower = O->status("//root/foo/bar/a"); |
| EXPECT_EQ("//root/foo/bar/a", SLower->getName()); |
| EXPECT_TRUE(S->equivalent(*SLower)); |
| EXPECT_FALSE(SLower->IsVFSMapped); |
| |
| // file after opening |
| auto OpenedF = O->openFileForRead("//root/file1"); |
| ASSERT_FALSE(OpenedF.getError()); |
| auto OpenedS = (*OpenedF)->status(); |
| ASSERT_FALSE(OpenedS.getError()); |
| EXPECT_EQ("//root/foo/bar/a", OpenedS->getName()); |
| EXPECT_TRUE(OpenedS->IsVFSMapped); |
| |
| // directory |
| S = O->status("//root/"); |
| ASSERT_FALSE(S.getError()); |
| EXPECT_TRUE(S->isDirectory()); |
| EXPECT_TRUE(S->equivalent(*O->status("//root/"))); // non-volatile UniqueID |
| |
| // remapped directory |
| S = O->status("//root/mappeddir"); |
| ASSERT_FALSE(S.getError()); |
| EXPECT_TRUE(S->isDirectory()); |
| EXPECT_TRUE(S->IsVFSMapped); |
| EXPECT_TRUE(S->equivalent(*O->status("//root/foo/bar"))); |
| |
| SLower = O->status("//root/foo/bar"); |
| EXPECT_EQ("//root/foo/bar", SLower->getName()); |
| EXPECT_TRUE(S->equivalent(*SLower)); |
| EXPECT_FALSE(SLower->IsVFSMapped); |
| |
| // file in remapped directory |
| S = O->status("//root/mappeddir/a"); |
| ASSERT_FALSE(S.getError()); |
| ASSERT_FALSE(S->isDirectory()); |
| ASSERT_TRUE(S->IsVFSMapped); |
| ASSERT_EQ("//root/foo/bar/a", S->getName()); |
| |
| // file in remapped directory, with use-external-name=false |
| S = O->status("//root/mappeddir2/a"); |
| ASSERT_FALSE(S.getError()); |
| ASSERT_FALSE(S->isDirectory()); |
| ASSERT_TRUE(S->IsVFSMapped); |
| ASSERT_EQ("//root/mappeddir2/a", S->getName()); |
| |
| // file contents in remapped directory |
| OpenedF = O->openFileForRead("//root/mappeddir/a"); |
| ASSERT_FALSE(OpenedF.getError()); |
| OpenedS = (*OpenedF)->status(); |
| ASSERT_FALSE(OpenedS.getError()); |
| EXPECT_EQ("//root/foo/bar/a", OpenedS->getName()); |
| EXPECT_TRUE(OpenedS->IsVFSMapped); |
| |
| // file contents in remapped directory, with use-external-name=false |
| OpenedF = O->openFileForRead("//root/mappeddir2/a"); |
| ASSERT_FALSE(OpenedF.getError()); |
| OpenedS = (*OpenedF)->status(); |
| ASSERT_FALSE(OpenedS.getError()); |
| EXPECT_EQ("//root/mappeddir2/a", OpenedS->getName()); |
| EXPECT_TRUE(OpenedS->IsVFSMapped); |
| |
| // broken mapping |
| EXPECT_EQ(O->status("//root/file2").getError(), |
| llvm::errc::no_such_file_or_directory); |
| EXPECT_EQ(0, NumDiagnostics); |
| } |
| |
| TEST_F(VFSFromYAMLTest, MappedRoot) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/foo/bar"); |
| Lower->addRegularFile("//root/foo/bar/a"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = |
| getFromYAMLString("{ 'roots': [\n" |
| "{\n" |
| " 'type': 'directory-remap',\n" |
| " 'name': '//mappedroot/',\n" |
| " 'external-contents': '//root/foo/bar'\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(FS); |
| |
| // file |
| ErrorOr<vfs::Status> S = O->status("//mappedroot/a"); |
| ASSERT_FALSE(S.getError()); |
| EXPECT_EQ("//root/foo/bar/a", S->getName()); |
| EXPECT_TRUE(S->IsVFSMapped); |
| |
| ErrorOr<vfs::Status> SLower = O->status("//root/foo/bar/a"); |
| EXPECT_EQ("//root/foo/bar/a", SLower->getName()); |
| EXPECT_TRUE(S->equivalent(*SLower)); |
| EXPECT_FALSE(SLower->IsVFSMapped); |
| |
| // file after opening |
| auto OpenedF = O->openFileForRead("//mappedroot/a"); |
| ASSERT_FALSE(OpenedF.getError()); |
| auto OpenedS = (*OpenedF)->status(); |
| ASSERT_FALSE(OpenedS.getError()); |
| EXPECT_EQ("//root/foo/bar/a", OpenedS->getName()); |
| EXPECT_TRUE(OpenedS->IsVFSMapped); |
| |
| EXPECT_EQ(0, NumDiagnostics); |
| } |
| |
| TEST_F(VFSFromYAMLTest, RemappedDirectoryOverlay) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/foo"); |
| Lower->addRegularFile("//root/foo/a"); |
| Lower->addDirectory("//root/bar"); |
| Lower->addRegularFile("//root/bar/b"); |
| Lower->addRegularFile("//root/bar/c"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = |
| getFromYAMLString("{ 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'directory-remap',\n" |
| " 'name': 'bar',\n" |
| " 'external-contents': '//root/foo'\n" |
| " }\n" |
| " ]\n" |
| "}]}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(FS); |
| |
| ErrorOr<vfs::Status> S = O->status("//root/foo"); |
| ASSERT_FALSE(S.getError()); |
| |
| ErrorOr<vfs::Status> SS = O->status("//root/bar"); |
| ASSERT_FALSE(SS.getError()); |
| EXPECT_TRUE(S->equivalent(*SS)); |
| |
| std::error_code EC; |
| checkContents(O->dir_begin("//root/bar", EC), |
| {"//root/foo/a", "//root/bar/b", "//root/bar/c"}); |
| |
| Lower->addRegularFile("//root/foo/b"); |
| checkContents(O->dir_begin("//root/bar", EC), |
| {"//root/foo/a", "//root/foo/b", "//root/bar/c"}); |
| |
| EXPECT_EQ(0, NumDiagnostics); |
| } |
| |
| TEST_F(VFSFromYAMLTest, RemappedDirectoryOverlayNoExternalNames) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/foo"); |
| Lower->addRegularFile("//root/foo/a"); |
| Lower->addDirectory("//root/bar"); |
| Lower->addRegularFile("//root/bar/b"); |
| Lower->addRegularFile("//root/bar/c"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = |
| getFromYAMLString("{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'directory-remap',\n" |
| " 'name': 'bar',\n" |
| " 'external-contents': '//root/foo'\n" |
| " }\n" |
| " ]\n" |
| "}]}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| ErrorOr<vfs::Status> S = FS->status("//root/foo"); |
| ASSERT_FALSE(S.getError()); |
| |
| ErrorOr<vfs::Status> SS = FS->status("//root/bar"); |
| ASSERT_FALSE(SS.getError()); |
| EXPECT_TRUE(S->equivalent(*SS)); |
| |
| std::error_code EC; |
| checkContents(FS->dir_begin("//root/bar", EC), |
| {"//root/bar/a", "//root/bar/b", "//root/bar/c"}); |
| |
| Lower->addRegularFile("//root/foo/b"); |
| checkContents(FS->dir_begin("//root/bar", EC), |
| {"//root/bar/a", "//root/bar/b", "//root/bar/c"}); |
| |
| EXPECT_EQ(0, NumDiagnostics); |
| } |
| |
| TEST_F(VFSFromYAMLTest, RemappedDirectoryOverlayNoFallthrough) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/foo"); |
| Lower->addRegularFile("//root/foo/a"); |
| Lower->addDirectory("//root/bar"); |
| Lower->addRegularFile("//root/bar/b"); |
| Lower->addRegularFile("//root/bar/c"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = |
| getFromYAMLString("{ 'fallthrough': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'directory-remap',\n" |
| " 'name': 'bar',\n" |
| " 'external-contents': '//root/foo'\n" |
| " }\n" |
| " ]\n" |
| "}]}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| ErrorOr<vfs::Status> S = Lower->status("//root/foo"); |
| ASSERT_FALSE(S.getError()); |
| |
| ErrorOr<vfs::Status> SS = FS->status("//root/bar"); |
| ASSERT_FALSE(SS.getError()); |
| EXPECT_TRUE(S->equivalent(*SS)); |
| |
| std::error_code EC; |
| checkContents(FS->dir_begin("//root/bar", EC), {"//root/foo/a"}); |
| |
| Lower->addRegularFile("//root/foo/b"); |
| checkContents(FS->dir_begin("//root/bar", EC), |
| {"//root/foo/a", "//root/foo/b"}); |
| |
| EXPECT_EQ(0, NumDiagnostics); |
| } |
| |
| TEST_F(VFSFromYAMLTest, CaseInsensitive) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addRegularFile("//root/foo/bar/a"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'case-sensitive': 'false',\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'XX',\n" |
| " 'external-contents': '//root/foo/bar/a'\n" |
| " }\n" |
| " ]\n" |
| "}]}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(FS); |
| |
| ErrorOr<vfs::Status> S = O->status("//root/XX"); |
| ASSERT_FALSE(S.getError()); |
| |
| ErrorOr<vfs::Status> SS = O->status("//root/xx"); |
| ASSERT_FALSE(SS.getError()); |
| EXPECT_TRUE(S->equivalent(*SS)); |
| SS = O->status("//root/xX"); |
| EXPECT_TRUE(S->equivalent(*SS)); |
| SS = O->status("//root/Xx"); |
| EXPECT_TRUE(S->equivalent(*SS)); |
| EXPECT_EQ(0, NumDiagnostics); |
| } |
| |
| TEST_F(VFSFromYAMLTest, CaseSensitive) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addRegularFile("//root/foo/bar/a"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'case-sensitive': 'true',\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'XX',\n" |
| " 'external-contents': '//root/foo/bar/a'\n" |
| " }\n" |
| " ]\n" |
| "}]}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(FS); |
| |
| ErrorOr<vfs::Status> SS = O->status("//root/xx"); |
| EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory); |
| SS = O->status("//root/xX"); |
| EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory); |
| SS = O->status("//root/Xx"); |
| EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory); |
| EXPECT_EQ(0, NumDiagnostics); |
| } |
| |
| TEST_F(VFSFromYAMLTest, IllegalVFSFile) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| |
| // invalid YAML at top-level |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString("{]", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| // invalid YAML in roots |
| FS = getFromYAMLString("{ 'roots':[}", Lower); |
| // invalid YAML in directory |
| FS = getFromYAMLString( |
| "{ 'roots':[ { 'name': 'foo', 'type': 'directory', 'contents': [}", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // invalid configuration |
| FS = getFromYAMLString("{ 'knobular': 'true', 'roots':[] }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString("{ 'case-sensitive': 'maybe', 'roots':[] }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // invalid roots |
| FS = getFromYAMLString("{ 'roots':'' }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString("{ 'roots':{} }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // invalid entries |
| FS = getFromYAMLString( |
| "{ 'roots':[ { 'type': 'other', 'name': 'me', 'contents': '' }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': [], " |
| "'external-contents': 'other' }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString( |
| "{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': [] }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString( |
| "{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': {} }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString( |
| "{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': {} }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString( |
| "{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': '' }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString( |
| "{ 'roots':[ { 'thingy': 'directory', 'name': 'me', 'contents': [] }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // missing mandatory fields |
| FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': 'me' }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString( |
| "{ 'roots':[ { 'type': 'file', 'external-contents': 'other' }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString("{ 'roots':[ { 'name': 'me', 'contents': [] }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // duplicate keys |
| FS = getFromYAMLString("{ 'roots':[], 'roots':[] }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLString( |
| "{ 'case-sensitive':'true', 'case-sensitive':'true', 'roots':[] }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = |
| getFromYAMLString("{ 'roots':[{'name':'me', 'name':'you', 'type':'file', " |
| "'external-contents':'blah' } ] }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // missing version |
| FS = getFromYAMLRawString("{ 'roots':[] }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // bad version number |
| FS = getFromYAMLRawString("{ 'version':'foo', 'roots':[] }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLRawString("{ 'version':-1, 'roots':[] }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| FS = getFromYAMLRawString("{ 'version':100000, 'roots':[] }", Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // both 'external-contents' and 'contents' specified |
| Lower->addDirectory("//root/external/dir"); |
| FS = getFromYAMLString( |
| "{ 'roots':[ \n" |
| "{ 'type': 'directory', 'name': '//root/A', 'contents': [],\n" |
| " 'external-contents': '//root/external/dir'}]}", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // 'directory-remap' with 'contents' |
| FS = getFromYAMLString( |
| "{ 'roots':[ \n" |
| "{ 'type': 'directory-remap', 'name': '//root/A', 'contents': [] }]}", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| EXPECT_EQ(26, NumDiagnostics); |
| } |
| |
| TEST_F(VFSFromYAMLTest, UseExternalName) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addRegularFile("//root/external/file"); |
| |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = |
| getFromYAMLString("{ 'roots': [\n" |
| " { 'type': 'file', 'name': '//root/A',\n" |
| " 'external-contents': '//root/external/file'\n" |
| " },\n" |
| " { 'type': 'file', 'name': '//root/B',\n" |
| " 'use-external-name': true,\n" |
| " 'external-contents': '//root/external/file'\n" |
| " },\n" |
| " { 'type': 'file', 'name': '//root/C',\n" |
| " 'use-external-name': false,\n" |
| " 'external-contents': '//root/external/file'\n" |
| " }\n" |
| "] }", |
| Lower); |
| ASSERT_TRUE(nullptr != FS.get()); |
| |
| // default true |
| EXPECT_EQ("//root/external/file", FS->status("//root/A")->getName()); |
| // explicit |
| EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName()); |
| EXPECT_EQ("//root/C", FS->status("//root/C")->getName()); |
| |
| // global configuration |
| FS = getFromYAMLString("{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| " { 'type': 'file', 'name': '//root/A',\n" |
| " 'external-contents': '//root/external/file'\n" |
| " },\n" |
| " { 'type': 'file', 'name': '//root/B',\n" |
| " 'use-external-name': true,\n" |
| " 'external-contents': '//root/external/file'\n" |
| " },\n" |
| " { 'type': 'file', 'name': '//root/C',\n" |
| " 'use-external-name': false,\n" |
| " 'external-contents': '//root/external/file'\n" |
| " }\n" |
| "] }", |
| Lower); |
| ASSERT_TRUE(nullptr != FS.get()); |
| |
| // default |
| EXPECT_EQ("//root/A", FS->status("//root/A")->getName()); |
| // explicit |
| EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName()); |
| EXPECT_EQ("//root/C", FS->status("//root/C")->getName()); |
| } |
| |
| TEST_F(VFSFromYAMLTest, MultiComponentPath) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addRegularFile("//root/other"); |
| |
| // file in roots |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = |
| getFromYAMLString("{ 'roots': [\n" |
| " { 'type': 'file', 'name': '//root/path/to/file',\n" |
| " 'external-contents': '//root/other' }]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(nullptr != FS.get()); |
| EXPECT_FALSE(FS->status("//root/path/to/file").getError()); |
| EXPECT_FALSE(FS->status("//root/path/to").getError()); |
| EXPECT_FALSE(FS->status("//root/path").getError()); |
| EXPECT_FALSE(FS->status("//root/").getError()); |
| |
| // at the start |
| FS = getFromYAMLString( |
| "{ 'roots': [\n" |
| " { 'type': 'directory', 'name': '//root/path/to',\n" |
| " 'contents': [ { 'type': 'file', 'name': 'file',\n" |
| " 'external-contents': '//root/other' }]}]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(nullptr != FS.get()); |
| EXPECT_FALSE(FS->status("//root/path/to/file").getError()); |
| EXPECT_FALSE(FS->status("//root/path/to").getError()); |
| EXPECT_FALSE(FS->status("//root/path").getError()); |
| EXPECT_FALSE(FS->status("//root/").getError()); |
| |
| // at the end |
| FS = getFromYAMLString( |
| "{ 'roots': [\n" |
| " { 'type': 'directory', 'name': '//root/',\n" |
| " 'contents': [ { 'type': 'file', 'name': 'path/to/file',\n" |
| " 'external-contents': '//root/other' }]}]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(nullptr != FS.get()); |
| EXPECT_FALSE(FS->status("//root/path/to/file").getError()); |
| EXPECT_FALSE(FS->status("//root/path/to").getError()); |
| EXPECT_FALSE(FS->status("//root/path").getError()); |
| EXPECT_FALSE(FS->status("//root/").getError()); |
| } |
| |
| TEST_F(VFSFromYAMLTest, TrailingSlashes) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addRegularFile("//root/other"); |
| |
| // file in roots |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'roots': [\n" |
| " { 'type': 'directory', 'name': '//root/path/to////',\n" |
| " 'contents': [ { 'type': 'file', 'name': 'file',\n" |
| " 'external-contents': '//root/other' }]}]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(nullptr != FS.get()); |
| EXPECT_FALSE(FS->status("//root/path/to/file").getError()); |
| EXPECT_FALSE(FS->status("//root/path/to").getError()); |
| EXPECT_FALSE(FS->status("//root/path").getError()); |
| EXPECT_FALSE(FS->status("//root/").getError()); |
| } |
| |
| TEST_F(VFSFromYAMLTest, DirectoryIteration) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/"); |
| Lower->addDirectory("//root/foo"); |
| Lower->addDirectory("//root/foo/bar"); |
| Lower->addRegularFile("//root/foo/bar/a"); |
| Lower->addRegularFile("//root/foo/bar/b"); |
| Lower->addRegularFile("//root/file3"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'file1',\n" |
| " 'external-contents': '//root/foo/bar/a'\n" |
| " },\n" |
| " {\n" |
| " 'type': 'file',\n" |
| " 'name': 'file2',\n" |
| " 'external-contents': '//root/foo/bar/b'\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(FS); |
| |
| std::error_code EC; |
| checkContents(O->dir_begin("//root/", EC), |
| {"//root/file1", "//root/file2", "//root/file3", "//root/foo"}); |
| |
| checkContents(O->dir_begin("//root/foo/bar", EC), |
| {"//root/foo/bar/a", "//root/foo/bar/b"}); |
| } |
| |
| TEST_F(VFSFromYAMLTest, DirectoryIterationSameDirMultipleEntries) { |
| // https://llvm.org/bugs/show_bug.cgi?id=27725 |
| if (!supportsSameDirMultipleYAMLEntries()) |
| return; |
| |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/zab"); |
| Lower->addDirectory("//root/baz"); |
| Lower->addRegularFile("//root/zab/a"); |
| Lower->addRegularFile("//root/zab/b"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/baz/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'x',\n" |
| " 'external-contents': '//root/zab/a'\n" |
| " }\n" |
| " ]\n" |
| "},\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/baz/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'y',\n" |
| " 'external-contents': '//root/zab/b'\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(FS); |
| |
| std::error_code EC; |
| |
| checkContents(O->dir_begin("//root/baz/", EC), |
| {"//root/baz/x", "//root/baz/y"}); |
| } |
| |
| TEST_F(VFSFromYAMLTest, RecursiveDirectoryIterationLevel) { |
| |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/a"); |
| Lower->addDirectory("//root/a/b"); |
| Lower->addDirectory("//root/a/b/c"); |
| Lower->addRegularFile("//root/a/b/c/file"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/a/b/c/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'file',\n" |
| " 'external-contents': '//root/a/b/c/file'\n" |
| " }\n" |
| " ]\n" |
| "},\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| IntrusiveRefCntPtr<vfs::OverlayFileSystem> O( |
| new vfs::OverlayFileSystem(Lower)); |
| O->pushOverlay(FS); |
| |
| std::error_code EC; |
| |
| // Test recursive_directory_iterator level() |
| vfs::recursive_directory_iterator I = vfs::recursive_directory_iterator( |
| *O, "//root", EC), |
| E; |
| ASSERT_FALSE(EC); |
| for (int l = 0; I != E; I.increment(EC), ++l) { |
| ASSERT_FALSE(EC); |
| EXPECT_EQ(I.level(), l); |
| } |
| EXPECT_EQ(I, E); |
| } |
| |
| TEST_F(VFSFromYAMLTest, RelativePaths) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| // Filename at root level without a parent directory. |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'roots': [\n" |
| " { 'type': 'file', 'name': 'file-not-in-directory.h',\n" |
| " 'external-contents': '//root/external/file'\n" |
| " }\n" |
| "] }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // Relative file path. |
| FS = getFromYAMLString("{ 'roots': [\n" |
| " { 'type': 'file', 'name': 'relative/file/path.h',\n" |
| " 'external-contents': '//root/external/file'\n" |
| " }\n" |
| "] }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| // Relative directory path. |
| FS = getFromYAMLString( |
| "{ 'roots': [\n" |
| " { 'type': 'directory', 'name': 'relative/directory/path.h',\n" |
| " 'contents': []\n" |
| " }\n" |
| "] }", |
| Lower); |
| EXPECT_EQ(nullptr, FS.get()); |
| |
| EXPECT_EQ(3, NumDiagnostics); |
| } |
| |
| TEST_F(VFSFromYAMLTest, NonFallthroughDirectoryIteration) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/"); |
| Lower->addRegularFile("//root/a"); |
| Lower->addRegularFile("//root/b"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'fallthrough': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'c',\n" |
| " 'external-contents': '//root/a'\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| std::error_code EC; |
| checkContents(FS->dir_begin("//root/", EC), |
| {"//root/c"}); |
| } |
| |
| TEST_F(VFSFromYAMLTest, DirectoryIterationWithDuplicates) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/"); |
| Lower->addRegularFile("//root/a"); |
| Lower->addRegularFile("//root/b"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'a',\n" |
| " 'external-contents': '//root/a'\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| std::error_code EC; |
| checkContents(FS->dir_begin("//root/", EC), |
| {"//root/a", "//root/b"}); |
| } |
| |
| TEST_F(VFSFromYAMLTest, DirectoryIterationErrorInVFSLayer) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/"); |
| Lower->addDirectory("//root/foo"); |
| Lower->addRegularFile("//root/foo/a"); |
| Lower->addRegularFile("//root/foo/b"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'bar/a',\n" |
| " 'external-contents': '//root/foo/a'\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| std::error_code EC; |
| checkContents(FS->dir_begin("//root/foo", EC), |
| {"//root/foo/a", "//root/foo/b"}); |
| } |
| |
| TEST_F(VFSFromYAMLTest, GetRealPath) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//dir/"); |
| Lower->addRegularFile("/foo"); |
| Lower->addSymlink("/link"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'bar',\n" |
| " 'external-contents': '/link'\n" |
| " }\n" |
| " ]\n" |
| "},\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//dir/',\n" |
| " 'contents': []\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| // Regular file present in underlying file system. |
| SmallString<16> RealPath; |
| EXPECT_FALSE(FS->getRealPath("/foo", RealPath)); |
| EXPECT_EQ(RealPath.str(), "/foo"); |
| |
| // File present in YAML pointing to symlink in underlying file system. |
| EXPECT_FALSE(FS->getRealPath("//root/bar", RealPath)); |
| EXPECT_EQ(RealPath.str(), "/symlink"); |
| |
| // Directories should fall back to the underlying file system is possible. |
| EXPECT_FALSE(FS->getRealPath("//dir/", RealPath)); |
| EXPECT_EQ(RealPath.str(), "//dir/"); |
| |
| // Try a non-existing file. |
| EXPECT_EQ(FS->getRealPath("/non_existing", RealPath), |
| errc::no_such_file_or_directory); |
| } |
| |
| TEST_F(VFSFromYAMLTest, WorkingDirectory) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/"); |
| Lower->addDirectory("//root/foo"); |
| Lower->addRegularFile("//root/foo/a"); |
| Lower->addRegularFile("//root/foo/b"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/bar',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'a',\n" |
| " 'external-contents': '//root/foo/a'\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| std::error_code EC = FS->setCurrentWorkingDirectory("//root/bar"); |
| ASSERT_FALSE(EC); |
| |
| llvm::ErrorOr<std::string> WorkingDir = FS->getCurrentWorkingDirectory(); |
| ASSERT_TRUE(WorkingDir); |
| EXPECT_EQ(*WorkingDir, "//root/bar"); |
| |
| llvm::ErrorOr<vfs::Status> Status = FS->status("./a"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->isStatusKnown()); |
| EXPECT_FALSE(Status->isDirectory()); |
| EXPECT_TRUE(Status->isRegularFile()); |
| EXPECT_FALSE(Status->isSymlink()); |
| EXPECT_FALSE(Status->isOther()); |
| EXPECT_TRUE(Status->exists()); |
| |
| EC = FS->setCurrentWorkingDirectory("bogus"); |
| ASSERT_TRUE(EC); |
| WorkingDir = FS->getCurrentWorkingDirectory(); |
| ASSERT_TRUE(WorkingDir); |
| EXPECT_EQ(*WorkingDir, "//root/bar"); |
| |
| EC = FS->setCurrentWorkingDirectory("//root/"); |
| ASSERT_FALSE(EC); |
| WorkingDir = FS->getCurrentWorkingDirectory(); |
| ASSERT_TRUE(WorkingDir); |
| EXPECT_EQ(*WorkingDir, "//root/"); |
| |
| EC = FS->setCurrentWorkingDirectory("bar"); |
| ASSERT_FALSE(EC); |
| WorkingDir = FS->getCurrentWorkingDirectory(); |
| ASSERT_TRUE(WorkingDir); |
| EXPECT_EQ(*WorkingDir, "//root/bar"); |
| } |
| |
| TEST_F(VFSFromYAMLTest, WorkingDirectoryFallthrough) { |
| IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem()); |
| Lower->addDirectory("//root/"); |
| Lower->addDirectory("//root/foo"); |
| Lower->addRegularFile("//root/foo/a"); |
| Lower->addRegularFile("//root/foo/b"); |
| Lower->addRegularFile("//root/c"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/bar',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'a',\n" |
| " 'external-contents': '//root/foo/a'\n" |
| " }\n" |
| " ]\n" |
| "},\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/bar/baz',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'a',\n" |
| " 'external-contents': '//root/foo/a'\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| std::error_code EC = FS->setCurrentWorkingDirectory("//root/"); |
| ASSERT_FALSE(EC); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| llvm::ErrorOr<vfs::Status> Status = FS->status("bar/a"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| |
| Status = FS->status("foo/a"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| |
| EC = FS->setCurrentWorkingDirectory("//root/bar"); |
| ASSERT_FALSE(EC); |
| |
| Status = FS->status("./a"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| |
| Status = FS->status("./b"); |
| ASSERT_TRUE(Status.getError()); |
| |
| Status = FS->status("./c"); |
| ASSERT_TRUE(Status.getError()); |
| |
| EC = FS->setCurrentWorkingDirectory("//root/"); |
| ASSERT_FALSE(EC); |
| |
| Status = FS->status("c"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| |
| Status = FS->status("./bar/baz/a"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| |
| EC = FS->setCurrentWorkingDirectory("//root/bar"); |
| ASSERT_FALSE(EC); |
| |
| Status = FS->status("./baz/a"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| |
| Status = FS->status("../bar/baz/a"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| } |
| |
| TEST_F(VFSFromYAMLTest, WorkingDirectoryFallthroughInvalid) { |
| IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem()); |
| Lower->addDirectory("//root/"); |
| Lower->addDirectory("//root/foo"); |
| Lower->addRegularFile("//root/foo/a"); |
| Lower->addRegularFile("//root/foo/b"); |
| Lower->addRegularFile("//root/c"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/bar',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'a',\n" |
| " 'external-contents': '//root/foo/a'\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| std::error_code EC = FS->setCurrentWorkingDirectory("//root/"); |
| ASSERT_FALSE(EC); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| llvm::ErrorOr<vfs::Status> Status = FS->status("bar/a"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| |
| Status = FS->status("foo/a"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| } |
| |
| TEST_F(VFSFromYAMLTest, VirtualWorkingDirectory) { |
| IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem()); |
| Lower->addDirectory("//root/"); |
| Lower->addDirectory("//root/foo"); |
| Lower->addRegularFile("//root/foo/a"); |
| Lower->addRegularFile("//root/foo/b"); |
| Lower->addRegularFile("//root/c"); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString( |
| "{ 'use-external-names': false,\n" |
| " 'roots': [\n" |
| "{\n" |
| " 'type': 'directory',\n" |
| " 'name': '//root/bar',\n" |
| " 'contents': [ {\n" |
| " 'type': 'file',\n" |
| " 'name': 'a',\n" |
| " 'external-contents': '//root/foo/a'\n" |
| " }\n" |
| " ]\n" |
| "}\n" |
| "]\n" |
| "}", |
| Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| std::error_code EC = FS->setCurrentWorkingDirectory("//root/bar"); |
| ASSERT_FALSE(EC); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| llvm::ErrorOr<vfs::Status> Status = FS->status("a"); |
| ASSERT_FALSE(Status.getError()); |
| EXPECT_TRUE(Status->exists()); |
| } |
| |
| TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest) { |
| TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true); |
| TempDir _a(TestDirectory.path("a")); |
| TempFile _ab(TestDirectory.path("a, b")); |
| TempDir _c(TestDirectory.path("c")); |
| TempFile _cd(TestDirectory.path("c/d")); |
| TempDir _e(TestDirectory.path("e")); |
| TempDir _ef(TestDirectory.path("e/f")); |
| TempFile _g(TestDirectory.path("g")); |
| TempDir _h(TestDirectory.path("h")); |
| |
| vfs::YAMLVFSWriter VFSWriter; |
| VFSWriter.addDirectoryMapping(_a.path(), "//root/a"); |
| VFSWriter.addFileMapping(_ab.path(), "//root/a/b"); |
| VFSWriter.addFileMapping(_cd.path(), "//root/c/d"); |
| VFSWriter.addDirectoryMapping(_e.path(), "//root/e"); |
| VFSWriter.addDirectoryMapping(_ef.path(), "//root/e/f"); |
| VFSWriter.addFileMapping(_g.path(), "//root/g"); |
| VFSWriter.addDirectoryMapping(_h.path(), "//root/h"); |
| |
| std::string Buffer; |
| raw_string_ostream OS(Buffer); |
| VFSWriter.write(OS); |
| OS.flush(); |
| |
| IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem()); |
| Lower->addDirectory("//root/"); |
| Lower->addDirectory("//root/a"); |
| Lower->addRegularFile("//root/a/b"); |
| Lower->addDirectory("//root/b"); |
| Lower->addDirectory("//root/c"); |
| Lower->addRegularFile("//root/c/d"); |
| Lower->addDirectory("//root/e"); |
| Lower->addDirectory("//root/e/f"); |
| Lower->addRegularFile("//root/g"); |
| Lower->addDirectory("//root/h"); |
| |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| EXPECT_TRUE(FS->exists(_a.path())); |
| EXPECT_TRUE(FS->exists(_ab.path())); |
| EXPECT_TRUE(FS->exists(_c.path())); |
| EXPECT_TRUE(FS->exists(_cd.path())); |
| EXPECT_TRUE(FS->exists(_e.path())); |
| EXPECT_TRUE(FS->exists(_ef.path())); |
| EXPECT_TRUE(FS->exists(_g.path())); |
| EXPECT_TRUE(FS->exists(_h.path())); |
| } |
| |
| TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest2) { |
| TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true); |
| TempDir _a(TestDirectory.path("a")); |
| TempFile _ab(TestDirectory.path("a/b")); |
| TempDir _ac(TestDirectory.path("a/c")); |
| TempFile _acd(TestDirectory.path("a/c/d")); |
| TempFile _ace(TestDirectory.path("a/c/e")); |
| TempFile _acf(TestDirectory.path("a/c/f")); |
| TempDir _ag(TestDirectory.path("a/g")); |
| TempFile _agh(TestDirectory.path("a/g/h")); |
| |
| vfs::YAMLVFSWriter VFSWriter; |
| VFSWriter.addDirectoryMapping(_a.path(), "//root/a"); |
| VFSWriter.addFileMapping(_ab.path(), "//root/a/b"); |
| VFSWriter.addDirectoryMapping(_ac.path(), "//root/a/c"); |
| VFSWriter.addFileMapping(_acd.path(), "//root/a/c/d"); |
| VFSWriter.addFileMapping(_ace.path(), "//root/a/c/e"); |
| VFSWriter.addFileMapping(_acf.path(), "//root/a/c/f"); |
| VFSWriter.addDirectoryMapping(_ag.path(), "//root/a/g"); |
| VFSWriter.addFileMapping(_agh.path(), "//root/a/g/h"); |
| |
| std::string Buffer; |
| raw_string_ostream OS(Buffer); |
| VFSWriter.write(OS); |
| OS.flush(); |
| |
| IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem()); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower); |
| EXPECT_TRUE(FS.get() != nullptr); |
| } |
| |
| TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest3) { |
| TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true); |
| TempDir _a(TestDirectory.path("a")); |
| TempFile _ab(TestDirectory.path("a/b")); |
| TempDir _ac(TestDirectory.path("a/c")); |
| TempDir _acd(TestDirectory.path("a/c/d")); |
| TempDir _acde(TestDirectory.path("a/c/d/e")); |
| TempFile _acdef(TestDirectory.path("a/c/d/e/f")); |
| TempFile _acdeg(TestDirectory.path("a/c/d/e/g")); |
| TempDir _ah(TestDirectory.path("a/h")); |
| TempFile _ahi(TestDirectory.path("a/h/i")); |
| |
| vfs::YAMLVFSWriter VFSWriter; |
| VFSWriter.addDirectoryMapping(_a.path(), "//root/a"); |
| VFSWriter.addFileMapping(_ab.path(), "//root/a/b"); |
| VFSWriter.addDirectoryMapping(_ac.path(), "//root/a/c"); |
| VFSWriter.addDirectoryMapping(_acd.path(), "//root/a/c/d"); |
| VFSWriter.addDirectoryMapping(_acde.path(), "//root/a/c/d/e"); |
| VFSWriter.addFileMapping(_acdef.path(), "//root/a/c/d/e/f"); |
| VFSWriter.addFileMapping(_acdeg.path(), "//root/a/c/d/e/g"); |
| VFSWriter.addDirectoryMapping(_ahi.path(), "//root/a/h"); |
| VFSWriter.addFileMapping(_ahi.path(), "//root/a/h/i"); |
| |
| std::string Buffer; |
| raw_string_ostream OS(Buffer); |
| VFSWriter.write(OS); |
| OS.flush(); |
| |
| IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem()); |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower); |
| EXPECT_TRUE(FS.get() != nullptr); |
| } |
| |
| TEST_F(VFSFromYAMLTest, YAMLVFSWriterTestHandleDirs) { |
| TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true); |
| TempDir _a(TestDirectory.path("a")); |
| TempDir _b(TestDirectory.path("b")); |
| TempDir _c(TestDirectory.path("c")); |
| |
| vfs::YAMLVFSWriter VFSWriter; |
| VFSWriter.addDirectoryMapping(_a.path(), "//root/a"); |
| VFSWriter.addDirectoryMapping(_b.path(), "//root/b"); |
| VFSWriter.addDirectoryMapping(_c.path(), "//root/c"); |
| |
| std::string Buffer; |
| raw_string_ostream OS(Buffer); |
| VFSWriter.write(OS); |
| OS.flush(); |
| |
| // We didn't add a single file - only directories. |
| EXPECT_TRUE(Buffer.find("'type': 'file'") == std::string::npos); |
| |
| IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem()); |
| Lower->addDirectory("//root/a"); |
| Lower->addDirectory("//root/b"); |
| Lower->addDirectory("//root/c"); |
| // canaries |
| Lower->addRegularFile("//root/a/a"); |
| Lower->addRegularFile("//root/b/b"); |
| Lower->addRegularFile("//root/c/c"); |
| |
| IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower); |
| ASSERT_TRUE(FS.get() != nullptr); |
| |
| EXPECT_FALSE(FS->exists(_a.path("a"))); |
| EXPECT_FALSE(FS->exists(_b.path("b"))); |
| EXPECT_FALSE(FS->exists(_c.path("c"))); |
| } |
| |
| TEST(VFSFromRemappedFilesTest, Basic) { |
| IntrusiveRefCntPtr<vfs::InMemoryFileSystem> BaseFS = |
| new vfs::InMemoryFileSystem; |
| BaseFS->addFile("//root/b", 0, MemoryBuffer::getMemBuffer("contents of b")); |
| BaseFS->addFile("//root/c", 0, MemoryBuffer::getMemBuffer("contents of c")); |
| |
| std::vector<std::pair<std::string, std::string>> RemappedFiles = { |
| {"//root/a/a", "//root/b"}, |
| {"//root/a/b/c", "//root/c"}, |
| }; |
| auto RemappedFS = vfs::RedirectingFileSystem::create( |
| RemappedFiles, /*UseExternalNames=*/false, *BaseFS); |
| |
| auto StatA = RemappedFS->status("//root/a/a"); |
| auto StatB = RemappedFS->status("//root/a/b/c"); |
| ASSERT_TRUE(StatA); |
| ASSERT_TRUE(StatB); |
| EXPECT_EQ("//root/a/a", StatA->getName()); |
| EXPECT_EQ("//root/a/b/c", StatB->getName()); |
| |
| auto BufferA = RemappedFS->getBufferForFile("//root/a/a"); |
| auto BufferB = RemappedFS->getBufferForFile("//root/a/b/c"); |
| ASSERT_TRUE(BufferA); |
| ASSERT_TRUE(BufferB); |
| EXPECT_EQ("contents of b", (*BufferA)->getBuffer()); |
| EXPECT_EQ("contents of c", (*BufferB)->getBuffer()); |
| } |
| |
| TEST(VFSFromRemappedFilesTest, UseExternalNames) { |
| IntrusiveRefCntPtr<vfs::InMemoryFileSystem> BaseFS = |
| new vfs::InMemoryFileSystem; |
| BaseFS->addFile("//root/b", 0, MemoryBuffer::getMemBuffer("contents of b")); |
| BaseFS->addFile("//root/c", 0, MemoryBuffer::getMemBuffer("contents of c")); |
| |
| std::vector<std::pair<std::string, std::string>> RemappedFiles = { |
| {"//root/a/a", "//root/b"}, |
| {"//root/a/b/c", "//root/c"}, |
| }; |
| auto RemappedFS = vfs::RedirectingFileSystem::create( |
| RemappedFiles, /*UseExternalNames=*/true, *BaseFS); |
| |
| auto StatA = RemappedFS->status("//root/a/a"); |
| auto StatB = RemappedFS->status("//root/a/b/c"); |
| ASSERT_TRUE(StatA); |
| ASSERT_TRUE(StatB); |
| EXPECT_EQ("//root/b", StatA->getName()); |
| EXPECT_EQ("//root/c", StatB->getName()); |
| |
| auto BufferA = RemappedFS->getBufferForFile("//root/a/a"); |
| auto BufferB = RemappedFS->getBufferForFile("//root/a/b/c"); |
| ASSERT_TRUE(BufferA); |
| ASSERT_TRUE(BufferB); |
| EXPECT_EQ("contents of b", (*BufferA)->getBuffer()); |
| EXPECT_EQ("contents of c", (*BufferB)->getBuffer()); |
| } |
| |
| TEST(VFSFromRemappedFilesTest, LastMappingWins) { |
| IntrusiveRefCntPtr<vfs::InMemoryFileSystem> BaseFS = |
| new vfs::InMemoryFileSystem; |
| BaseFS->addFile("//root/b", 0, MemoryBuffer::getMemBuffer("contents of b")); |
| BaseFS->addFile("//root/c", 0, MemoryBuffer::getMemBuffer("contents of c")); |
| |
| std::vector<std::pair<std::string, std::string>> RemappedFiles = { |
| {"//root/a", "//root/b"}, |
| {"//root/a", "//root/c"}, |
| }; |
| auto RemappedFSKeepName = vfs::RedirectingFileSystem::create( |
| RemappedFiles, /*UseExternalNames=*/false, *BaseFS); |
| auto RemappedFSExternalName = vfs::RedirectingFileSystem::create( |
| RemappedFiles, /*UseExternalNames=*/true, *BaseFS); |
| |
| auto StatKeepA = RemappedFSKeepName->status("//root/a"); |
| auto StatExternalA = RemappedFSExternalName->status("//root/a"); |
| ASSERT_TRUE(StatKeepA); |
| ASSERT_TRUE(StatExternalA); |
| EXPECT_EQ("//root/a", StatKeepA->getName()); |
| EXPECT_EQ("//root/c", StatExternalA->getName()); |
| |
| auto BufferKeepA = RemappedFSKeepName->getBufferForFile("//root/a"); |
| auto BufferExternalA = RemappedFSExternalName->getBufferForFile("//root/a"); |
| ASSERT_TRUE(BufferKeepA); |
| ASSERT_TRUE(BufferExternalA); |
| EXPECT_EQ("contents of c", (*BufferKeepA)->getBuffer()); |
| EXPECT_EQ("contents of c", (*BufferExternalA)->getBuffer()); |
| } |