xref: /llvm-project/llvm/unittests/Support/VirtualFileSystemTest.cpp (revision 5c9d82de6b72cc0c037daecce452c450870f0034) 
1 //===- unittests/Support/VirtualFileSystem.cpp -------------- VFS tests ---===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "llvm/Support/VirtualFileSystem.h"
10 #include "llvm/ADT/ScopeExit.h"
11 #include "llvm/Config/llvm-config.h"
12 #include "llvm/Support/Errc.h"
13 #include "llvm/Support/MemoryBuffer.h"
14 #include "llvm/Support/Path.h"
15 #include "llvm/Support/SourceMgr.h"
16 #include "llvm/TargetParser/Host.h"
17 #include "llvm/TargetParser/Triple.h"
18 #include "llvm/Testing/Support/SupportHelpers.h"
19 #include "gmock/gmock.h"
20 #include "gtest/gtest.h"
21 #include <map>
22 #include <string>
23 
24 using namespace llvm;
25 using llvm::sys::fs::UniqueID;
26 using llvm::unittest::TempDir;
27 using llvm::unittest::TempFile;
28 using llvm::unittest::TempLink;
29 using testing::ElementsAre;
30 using testing::Pair;
31 using testing::UnorderedElementsAre;
32 
33 namespace {
34 struct DummyFile : public vfs::File {
35   vfs::Status S;
36   explicit DummyFile(vfs::Status S) : S(S) {}
37   llvm::ErrorOr<vfs::Status> status() override { return S; }
38   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
39   getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
40             bool IsVolatile) override {
41     llvm_unreachable("unimplemented");
42   }
43   std::error_code close() override { return std::error_code(); }
44 };
45 
46 class DummyFileSystem : public vfs::FileSystem {
47   int FSID;   // used to produce UniqueIDs
48   int FileID; // used to produce UniqueIDs
49   std::string WorkingDirectory;
50   std::map<std::string, vfs::Status> FilesAndDirs;
51   typedef std::map<std::string, vfs::Status>::const_iterator const_iterator;
52 
53   static int getNextFSID() {
54     static int Count = 0;
55     return Count++;
56   }
57 
58 public:
59   DummyFileSystem() : FSID(getNextFSID()), FileID(0) {}
60 
61   ErrorOr<vfs::Status> status(const Twine &Path) override {
62     auto I = findEntry(Path);
63     if (I == FilesAndDirs.end())
64       return make_error_code(llvm::errc::no_such_file_or_directory);
65     return I->second;
66   }
67   ErrorOr<std::unique_ptr<vfs::File>>
68   openFileForRead(const Twine &Path) override {
69     auto S = status(Path);
70     if (S)
71       return std::unique_ptr<vfs::File>(new DummyFile{*S});
72     return S.getError();
73   }
74   llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override {
75     return WorkingDirectory;
76   }
77   std::error_code setCurrentWorkingDirectory(const Twine &Path) override {
78     WorkingDirectory = Path.str();
79     return std::error_code();
80   }
81   // Map any symlink to "/symlink".
82   std::error_code getRealPath(const Twine &Path,
83                               SmallVectorImpl<char> &Output) const override {
84     auto I = findEntry(Path);
85     if (I == FilesAndDirs.end())
86       return make_error_code(llvm::errc::no_such_file_or_directory);
87     if (I->second.isSymlink()) {
88       Output.clear();
89       Twine("/symlink").toVector(Output);
90       return std::error_code();
91     }
92     Output.clear();
93     Path.toVector(Output);
94     return std::error_code();
95   }
96 
97   struct DirIterImpl : public llvm::vfs::detail::DirIterImpl {
98     std::map<std::string, vfs::Status> &FilesAndDirs;
99     std::map<std::string, vfs::Status>::iterator I;
100     std::string Path;
101     bool isInPath(StringRef S) {
102       if (Path.size() < S.size() && S.find(Path) == 0) {
103         auto LastSep = S.find_last_of('/');
104         if (LastSep == Path.size() || LastSep == Path.size() - 1)
105           return true;
106       }
107       return false;
108     }
109     DirIterImpl(std::map<std::string, vfs::Status> &FilesAndDirs,
110                 const Twine &_Path)
111         : FilesAndDirs(FilesAndDirs), I(FilesAndDirs.begin()),
112           Path(_Path.str()) {
113       for (; I != FilesAndDirs.end(); ++I) {
114         if (isInPath(I->first)) {
115           CurrentEntry = vfs::directory_entry(std::string(I->second.getName()),
116                                               I->second.getType());
117           break;
118         }
119       }
120     }
121     std::error_code increment() override {
122       ++I;
123       for (; I != FilesAndDirs.end(); ++I) {
124         if (isInPath(I->first)) {
125           CurrentEntry = vfs::directory_entry(std::string(I->second.getName()),
126                                               I->second.getType());
127           break;
128         }
129       }
130       if (I == FilesAndDirs.end())
131         CurrentEntry = vfs::directory_entry();
132       return std::error_code();
133     }
134   };
135 
136   vfs::directory_iterator dir_begin(const Twine &Dir,
137                                     std::error_code &EC) override {
138     return vfs::directory_iterator(
139         std::make_shared<DirIterImpl>(FilesAndDirs, Dir));
140   }
141 
142   void addEntry(StringRef Path, const vfs::Status &Status) {
143     FilesAndDirs[std::string(Path)] = Status;
144   }
145 
146   const_iterator findEntry(const Twine &Path) const {
147     SmallString<128> P;
148     Path.toVector(P);
149     std::error_code EC = makeAbsolute(P);
150     assert(!EC);
151     (void)EC;
152     return FilesAndDirs.find(std::string(P.str()));
153   }
154 
155   void addRegularFile(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
156     vfs::Status S(Path, UniqueID(FSID, FileID++),
157                   std::chrono::system_clock::now(), 0, 0, 1024,
158                   sys::fs::file_type::regular_file, Perms);
159     addEntry(Path, S);
160   }
161 
162   void addDirectory(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
163     vfs::Status S(Path, UniqueID(FSID, FileID++),
164                   std::chrono::system_clock::now(), 0, 0, 0,
165                   sys::fs::file_type::directory_file, Perms);
166     addEntry(Path, S);
167   }
168 
169   void addSymlink(StringRef Path) {
170     vfs::Status S(Path, UniqueID(FSID, FileID++),
171                   std::chrono::system_clock::now(), 0, 0, 0,
172                   sys::fs::file_type::symlink_file, sys::fs::all_all);
173     addEntry(Path, S);
174   }
175 
176 protected:
177   void printImpl(raw_ostream &OS, PrintType Type,
178                  unsigned IndentLevel) const override {
179     printIndent(OS, IndentLevel);
180     OS << "DummyFileSystem (";
181     switch (Type) {
182     case vfs::FileSystem::PrintType::Summary:
183       OS << "Summary";
184       break;
185     case vfs::FileSystem::PrintType::Contents:
186       OS << "Contents";
187       break;
188     case vfs::FileSystem::PrintType::RecursiveContents:
189       OS << "RecursiveContents";
190       break;
191     }
192     OS << ")\n";
193   }
194 };
195 
196 class ErrorDummyFileSystem : public DummyFileSystem {
197   std::error_code setCurrentWorkingDirectory(const Twine &Path) override {
198     return llvm::errc::no_such_file_or_directory;
199   }
200 };
201 
202 /// Replace back-slashes by front-slashes.
203 std::string getPosixPath(const Twine &S) {
204   SmallString<128> Result;
205   llvm::sys::path::native(S, Result, llvm::sys::path::Style::posix);
206   return std::string(Result.str());
207 }
208 } // end anonymous namespace
209 
210 TEST(VirtualFileSystemTest, StatusQueries) {
211   IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
212   ErrorOr<vfs::Status> Status((std::error_code()));
213 
214   D->addRegularFile("/foo");
215   Status = D->status("/foo");
216   ASSERT_FALSE(Status.getError());
217   EXPECT_TRUE(Status->isStatusKnown());
218   EXPECT_FALSE(Status->isDirectory());
219   EXPECT_TRUE(Status->isRegularFile());
220   EXPECT_FALSE(Status->isSymlink());
221   EXPECT_FALSE(Status->isOther());
222   EXPECT_TRUE(Status->exists());
223 
224   D->addDirectory("/bar");
225   Status = D->status("/bar");
226   ASSERT_FALSE(Status.getError());
227   EXPECT_TRUE(Status->isStatusKnown());
228   EXPECT_TRUE(Status->isDirectory());
229   EXPECT_FALSE(Status->isRegularFile());
230   EXPECT_FALSE(Status->isSymlink());
231   EXPECT_FALSE(Status->isOther());
232   EXPECT_TRUE(Status->exists());
233 
234   D->addSymlink("/baz");
235   Status = D->status("/baz");
236   ASSERT_FALSE(Status.getError());
237   EXPECT_TRUE(Status->isStatusKnown());
238   EXPECT_FALSE(Status->isDirectory());
239   EXPECT_FALSE(Status->isRegularFile());
240   EXPECT_TRUE(Status->isSymlink());
241   EXPECT_FALSE(Status->isOther());
242   EXPECT_TRUE(Status->exists());
243 
244   EXPECT_TRUE(Status->equivalent(*Status));
245   ErrorOr<vfs::Status> Status2 = D->status("/foo");
246   ASSERT_FALSE(Status2.getError());
247   EXPECT_FALSE(Status->equivalent(*Status2));
248 }
249 
250 TEST(VirtualFileSystemTest, BaseOnlyOverlay) {
251   IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
252   ErrorOr<vfs::Status> Status((std::error_code()));
253   EXPECT_FALSE(Status = D->status("/foo"));
254 
255   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(new vfs::OverlayFileSystem(D));
256   EXPECT_FALSE(Status = O->status("/foo"));
257 
258   D->addRegularFile("/foo");
259   Status = D->status("/foo");
260   EXPECT_FALSE(Status.getError());
261 
262   ErrorOr<vfs::Status> Status2((std::error_code()));
263   Status2 = O->status("/foo");
264   EXPECT_FALSE(Status2.getError());
265   EXPECT_TRUE(Status->equivalent(*Status2));
266 }
267 
268 TEST(VirtualFileSystemTest, GetRealPathInOverlay) {
269   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
270   Lower->addRegularFile("/foo");
271   Lower->addSymlink("/lower_link");
272   IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
273 
274   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
275       new vfs::OverlayFileSystem(Lower));
276   O->pushOverlay(Upper);
277 
278   // Regular file.
279   SmallString<16> RealPath;
280   EXPECT_FALSE(O->getRealPath("/foo", RealPath));
281   EXPECT_EQ(RealPath.str(), "/foo");
282 
283   // Expect no error getting real path for symlink in lower overlay.
284   EXPECT_FALSE(O->getRealPath("/lower_link", RealPath));
285   EXPECT_EQ(RealPath.str(), "/symlink");
286 
287   // Try a non-existing link.
288   EXPECT_EQ(O->getRealPath("/upper_link", RealPath),
289             errc::no_such_file_or_directory);
290 
291   // Add a new symlink in upper.
292   Upper->addSymlink("/upper_link");
293   EXPECT_FALSE(O->getRealPath("/upper_link", RealPath));
294   EXPECT_EQ(RealPath.str(), "/symlink");
295 }
296 
297 TEST(VirtualFileSystemTest, OverlayFiles) {
298   IntrusiveRefCntPtr<DummyFileSystem> Base(new DummyFileSystem());
299   IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
300   IntrusiveRefCntPtr<DummyFileSystem> Top(new DummyFileSystem());
301   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
302       new vfs::OverlayFileSystem(Base));
303   O->pushOverlay(Middle);
304   O->pushOverlay(Top);
305 
306   ErrorOr<vfs::Status> Status1((std::error_code())),
307       Status2((std::error_code())), Status3((std::error_code())),
308       StatusB((std::error_code())), StatusM((std::error_code())),
309       StatusT((std::error_code()));
310 
311   Base->addRegularFile("/foo");
312   StatusB = Base->status("/foo");
313   ASSERT_FALSE(StatusB.getError());
314   Status1 = O->status("/foo");
315   ASSERT_FALSE(Status1.getError());
316   Middle->addRegularFile("/foo");
317   StatusM = Middle->status("/foo");
318   ASSERT_FALSE(StatusM.getError());
319   Status2 = O->status("/foo");
320   ASSERT_FALSE(Status2.getError());
321   Top->addRegularFile("/foo");
322   StatusT = Top->status("/foo");
323   ASSERT_FALSE(StatusT.getError());
324   Status3 = O->status("/foo");
325   ASSERT_FALSE(Status3.getError());
326 
327   EXPECT_TRUE(Status1->equivalent(*StatusB));
328   EXPECT_TRUE(Status2->equivalent(*StatusM));
329   EXPECT_TRUE(Status3->equivalent(*StatusT));
330 
331   EXPECT_FALSE(Status1->equivalent(*Status2));
332   EXPECT_FALSE(Status2->equivalent(*Status3));
333   EXPECT_FALSE(Status1->equivalent(*Status3));
334 }
335 
336 TEST(VirtualFileSystemTest, OverlayDirsNonMerged) {
337   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
338   IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
339   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
340       new vfs::OverlayFileSystem(Lower));
341   O->pushOverlay(Upper);
342 
343   Lower->addDirectory("/lower-only");
344   Upper->addDirectory("/upper-only");
345 
346   // non-merged paths should be the same
347   ErrorOr<vfs::Status> Status1 = Lower->status("/lower-only");
348   ASSERT_FALSE(Status1.getError());
349   ErrorOr<vfs::Status> Status2 = O->status("/lower-only");
350   ASSERT_FALSE(Status2.getError());
351   EXPECT_TRUE(Status1->equivalent(*Status2));
352 
353   Status1 = Upper->status("/upper-only");
354   ASSERT_FALSE(Status1.getError());
355   Status2 = O->status("/upper-only");
356   ASSERT_FALSE(Status2.getError());
357   EXPECT_TRUE(Status1->equivalent(*Status2));
358 }
359 
360 TEST(VirtualFileSystemTest, MergedDirPermissions) {
361   // merged directories get the permissions of the upper dir
362   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
363   IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
364   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
365       new vfs::OverlayFileSystem(Lower));
366   O->pushOverlay(Upper);
367 
368   ErrorOr<vfs::Status> Status((std::error_code()));
369   Lower->addDirectory("/both", sys::fs::owner_read);
370   Upper->addDirectory("/both", sys::fs::owner_all | sys::fs::group_read);
371   Status = O->status("/both");
372   ASSERT_FALSE(Status.getError());
373   EXPECT_EQ(0740, Status->getPermissions());
374 
375   // permissions (as usual) are not recursively applied
376   Lower->addRegularFile("/both/foo", sys::fs::owner_read);
377   Upper->addRegularFile("/both/bar", sys::fs::owner_write);
378   Status = O->status("/both/foo");
379   ASSERT_FALSE(Status.getError());
380   EXPECT_EQ(0400, Status->getPermissions());
381   Status = O->status("/both/bar");
382   ASSERT_FALSE(Status.getError());
383   EXPECT_EQ(0200, Status->getPermissions());
384 }
385 
386 TEST(VirtualFileSystemTest, OverlayIterator) {
387   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
388   Lower->addRegularFile("/foo");
389   IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
390 
391   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
392       new vfs::OverlayFileSystem(Lower));
393   O->pushOverlay(Upper);
394 
395   ErrorOr<vfs::Status> Status((std::error_code()));
396   {
397     auto it = O->overlays_begin();
398     auto end = O->overlays_end();
399 
400     EXPECT_NE(it, end);
401 
402     Status = (*it)->status("/foo");
403     ASSERT_TRUE(Status.getError());
404 
405     it++;
406     EXPECT_NE(it, end);
407 
408     Status = (*it)->status("/foo");
409     ASSERT_FALSE(Status.getError());
410     EXPECT_TRUE(Status->exists());
411 
412     it++;
413     EXPECT_EQ(it, end);
414   }
415 
416   {
417     auto it = O->overlays_rbegin();
418     auto end = O->overlays_rend();
419 
420     EXPECT_NE(it, end);
421 
422     Status = (*it)->status("/foo");
423     ASSERT_FALSE(Status.getError());
424     EXPECT_TRUE(Status->exists());
425 
426     it++;
427     EXPECT_NE(it, end);
428 
429     Status = (*it)->status("/foo");
430     ASSERT_TRUE(Status.getError());
431 
432     it++;
433     EXPECT_EQ(it, end);
434   }
435 }
436 
437 TEST(VirtualFileSystemTest, BasicRealFSIteration) {
438   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
439   IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
440 
441   std::error_code EC;
442   vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory.path()), EC);
443   ASSERT_FALSE(EC);
444   EXPECT_EQ(vfs::directory_iterator(), I); // empty directory is empty
445 
446   TempDir _a(TestDirectory.path("a"));
447   TempDir _ab(TestDirectory.path("a/b"));
448   TempDir _c(TestDirectory.path("c"));
449   TempDir _cd(TestDirectory.path("c/d"));
450 
451   I = FS->dir_begin(Twine(TestDirectory.path()), EC);
452   ASSERT_FALSE(EC);
453   ASSERT_NE(vfs::directory_iterator(), I);
454   // Check either a or c, since we can't rely on the iteration order.
455   EXPECT_TRUE(I->path().ends_with("a") || I->path().ends_with("c"));
456   I.increment(EC);
457   ASSERT_FALSE(EC);
458   ASSERT_NE(vfs::directory_iterator(), I);
459   EXPECT_TRUE(I->path().ends_with("a") || I->path().ends_with("c"));
460   I.increment(EC);
461   EXPECT_EQ(vfs::directory_iterator(), I);
462 }
463 
464 #ifdef LLVM_ON_UNIX
465 TEST(VirtualFileSystemTest, MultipleWorkingDirs) {
466   // Our root contains a/aa, b/bb, c, where c is a link to a/.
467   // Run tests both in root/b/ and root/c/ (to test "normal" and symlink dirs).
468   // Interleave operations to show the working directories are independent.
469   TempDir Root("r", /*Unique*/ true);
470   TempDir ADir(Root.path("a"));
471   TempDir BDir(Root.path("b"));
472   TempLink C(ADir.path(), Root.path("c"));
473   TempFile AA(ADir.path("aa"), "", "aaaa");
474   TempFile BB(BDir.path("bb"), "", "bbbb");
475   std::unique_ptr<vfs::FileSystem> BFS = vfs::createPhysicalFileSystem(),
476                                    CFS = vfs::createPhysicalFileSystem();
477 
478   ASSERT_FALSE(BFS->setCurrentWorkingDirectory(BDir.path()));
479   ASSERT_FALSE(CFS->setCurrentWorkingDirectory(C.path()));
480   EXPECT_EQ(BDir.path(), *BFS->getCurrentWorkingDirectory());
481   EXPECT_EQ(C.path(), *CFS->getCurrentWorkingDirectory());
482 
483   // openFileForRead(), indirectly.
484   auto BBuf = BFS->getBufferForFile("bb");
485   ASSERT_TRUE(BBuf);
486   EXPECT_EQ("bbbb", (*BBuf)->getBuffer());
487 
488   auto ABuf = CFS->getBufferForFile("aa");
489   ASSERT_TRUE(ABuf);
490   EXPECT_EQ("aaaa", (*ABuf)->getBuffer());
491 
492   // status()
493   auto BStat = BFS->status("bb");
494   ASSERT_TRUE(BStat);
495   EXPECT_EQ("bb", BStat->getName());
496 
497   auto AStat = CFS->status("aa");
498   ASSERT_TRUE(AStat);
499   EXPECT_EQ("aa", AStat->getName()); // unresolved name
500 
501   // getRealPath()
502   SmallString<128> BPath;
503   ASSERT_FALSE(BFS->getRealPath("bb", BPath));
504   EXPECT_EQ(BB.path(), BPath);
505 
506   SmallString<128> APath;
507   ASSERT_FALSE(CFS->getRealPath("aa", APath));
508   EXPECT_EQ(AA.path(), APath); // Reports resolved name.
509 
510   // dir_begin
511   std::error_code EC;
512   auto BIt = BFS->dir_begin(".", EC);
513   ASSERT_FALSE(EC);
514   ASSERT_NE(BIt, vfs::directory_iterator());
515   EXPECT_EQ((BDir.path() + "/./bb").str(), BIt->path());
516   BIt.increment(EC);
517   ASSERT_FALSE(EC);
518   ASSERT_EQ(BIt, vfs::directory_iterator());
519 
520   auto CIt = CFS->dir_begin(".", EC);
521   ASSERT_FALSE(EC);
522   ASSERT_NE(CIt, vfs::directory_iterator());
523   EXPECT_EQ((ADir.path() + "/./aa").str(),
524             CIt->path()); // Partly resolved name!
525   CIt.increment(EC); // Because likely to read through this path.
526   ASSERT_FALSE(EC);
527   ASSERT_EQ(CIt, vfs::directory_iterator());
528 }
529 
530 TEST(VirtualFileSystemTest, PhysicalFileSystemWorkingDirFailure) {
531   TempDir D2("d2", /*Unique*/ true);
532   SmallString<128> WD, PrevWD;
533   ASSERT_EQ(sys::fs::current_path(PrevWD), std::error_code());
534   ASSERT_EQ(sys::fs::createUniqueDirectory("d1", WD), std::error_code());
535   ASSERT_EQ(sys::fs::set_current_path(WD), std::error_code());
536   auto Restore =
537       llvm::make_scope_exit([&] { sys::fs::set_current_path(PrevWD); });
538 
539   // Delete the working directory to create an error.
540   if (sys::fs::remove_directories(WD, /*IgnoreErrors=*/false))
541     // Some platforms (e.g. Solaris) disallow removal of the working directory.
542     GTEST_SKIP() << "test requires deletion of working directory";
543 
544   // Verify that we still get two separate working directories.
545   auto FS1 = vfs::createPhysicalFileSystem();
546   auto FS2 = vfs::createPhysicalFileSystem();
547   ASSERT_EQ(FS1->getCurrentWorkingDirectory().getError(),
548             errc::no_such_file_or_directory);
549   ASSERT_EQ(FS1->setCurrentWorkingDirectory(D2.path()), std::error_code());
550   ASSERT_EQ(FS1->getCurrentWorkingDirectory().get(), D2.path());
551   EXPECT_EQ(FS2->getCurrentWorkingDirectory().getError(),
552             errc::no_such_file_or_directory);
553   SmallString<128> WD2;
554   EXPECT_EQ(sys::fs::current_path(WD2), errc::no_such_file_or_directory);
555 }
556 
557 TEST(VirtualFileSystemTest, BrokenSymlinkRealFSIteration) {
558   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
559   IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
560 
561   TempLink _a("no_such_file", TestDirectory.path("a"));
562   TempDir _b(TestDirectory.path("b"));
563   TempLink _c("no_such_file", TestDirectory.path("c"));
564 
565   // Should get no iteration error, but a stat error for the broken symlinks.
566   std::map<std::string, std::error_code> StatResults;
567   std::error_code EC;
568   for (vfs::directory_iterator
569            I = FS->dir_begin(Twine(TestDirectory.path()), EC),
570            E;
571        I != E; I.increment(EC)) {
572     EXPECT_FALSE(EC);
573     StatResults[std::string(sys::path::filename(I->path()))] =
574         FS->status(I->path()).getError();
575   }
576   EXPECT_THAT(
577       StatResults,
578       ElementsAre(
579           Pair("a", std::make_error_code(std::errc::no_such_file_or_directory)),
580           Pair("b", std::error_code()),
581           Pair("c",
582                std::make_error_code(std::errc::no_such_file_or_directory))));
583 }
584 #endif
585 
586 TEST(VirtualFileSystemTest, BasicRealFSRecursiveIteration) {
587   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
588   IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
589 
590   std::error_code EC;
591   auto I =
592       vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC);
593   ASSERT_FALSE(EC);
594   EXPECT_EQ(vfs::recursive_directory_iterator(), I); // empty directory is empty
595 
596   TempDir _a(TestDirectory.path("a"));
597   TempDir _ab(TestDirectory.path("a/b"));
598   TempDir _c(TestDirectory.path("c"));
599   TempDir _cd(TestDirectory.path("c/d"));
600 
601   I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC);
602   ASSERT_FALSE(EC);
603   ASSERT_NE(vfs::recursive_directory_iterator(), I);
604 
605   std::vector<std::string> Contents;
606   for (auto E = vfs::recursive_directory_iterator(); !EC && I != E;
607        I.increment(EC)) {
608     Contents.push_back(std::string(I->path()));
609   }
610 
611   // Check contents, which may be in any order
612   EXPECT_EQ(4U, Contents.size());
613   int Counts[4] = {0, 0, 0, 0};
614   for (const std::string &Name : Contents) {
615     ASSERT_FALSE(Name.empty());
616     int Index = Name[Name.size() - 1] - 'a';
617     ASSERT_GE(Index, 0);
618     ASSERT_LT(Index, 4);
619     Counts[Index]++;
620   }
621   EXPECT_EQ(1, Counts[0]); // a
622   EXPECT_EQ(1, Counts[1]); // b
623   EXPECT_EQ(1, Counts[2]); // c
624   EXPECT_EQ(1, Counts[3]); // d
625 }
626 
627 TEST(VirtualFileSystemTest, BasicRealFSRecursiveIterationNoPush) {
628   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
629 
630   TempDir _a(TestDirectory.path("a"));
631   TempDir _ab(TestDirectory.path("a/b"));
632   TempDir _c(TestDirectory.path("c"));
633   TempDir _cd(TestDirectory.path("c/d"));
634   TempDir _e(TestDirectory.path("e"));
635   TempDir _ef(TestDirectory.path("e/f"));
636   TempDir _g(TestDirectory.path("g"));
637 
638   IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
639 
640   // Test that calling no_push on entries without subdirectories has no effect.
641   {
642     std::error_code EC;
643     auto I =
644         vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC);
645     ASSERT_FALSE(EC);
646 
647     std::vector<std::string> Contents;
648     for (auto E = vfs::recursive_directory_iterator(); !EC && I != E;
649          I.increment(EC)) {
650       Contents.push_back(std::string(I->path()));
651       char last = I->path().back();
652       switch (last) {
653       case 'b':
654       case 'd':
655       case 'f':
656       case 'g':
657         I.no_push();
658         break;
659       default:
660         break;
661       }
662     }
663     EXPECT_EQ(7U, Contents.size());
664   }
665 
666   // Test that calling no_push skips subdirectories.
667   {
668     std::error_code EC;
669     auto I =
670         vfs::recursive_directory_iterator(*FS, Twine(TestDirectory.path()), EC);
671     ASSERT_FALSE(EC);
672 
673     std::vector<std::string> Contents;
674     for (auto E = vfs::recursive_directory_iterator(); !EC && I != E;
675          I.increment(EC)) {
676       Contents.push_back(std::string(I->path()));
677       char last = I->path().back();
678       switch (last) {
679       case 'a':
680       case 'c':
681       case 'e':
682         I.no_push();
683         break;
684       default:
685         break;
686       }
687     }
688 
689     // Check contents, which may be in any order
690     EXPECT_EQ(4U, Contents.size());
691     int Counts[7] = {0, 0, 0, 0, 0, 0, 0};
692     for (const std::string &Name : Contents) {
693       ASSERT_FALSE(Name.empty());
694       int Index = Name[Name.size() - 1] - 'a';
695       ASSERT_GE(Index, 0);
696       ASSERT_LT(Index, 7);
697       Counts[Index]++;
698     }
699     EXPECT_EQ(1, Counts[0]); // a
700     EXPECT_EQ(0, Counts[1]); // b
701     EXPECT_EQ(1, Counts[2]); // c
702     EXPECT_EQ(0, Counts[3]); // d
703     EXPECT_EQ(1, Counts[4]); // e
704     EXPECT_EQ(0, Counts[5]); // f
705     EXPECT_EQ(1, Counts[6]); // g
706   }
707 }
708 
709 #ifdef LLVM_ON_UNIX
710 TEST(VirtualFileSystemTest, BrokenSymlinkRealFSRecursiveIteration) {
711   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
712   IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
713 
714   TempLink _a("no_such_file", TestDirectory.path("a"));
715   TempDir _b(TestDirectory.path("b"));
716   TempLink _ba("no_such_file", TestDirectory.path("b/a"));
717   TempDir _bb(TestDirectory.path("b/b"));
718   TempLink _bc("no_such_file", TestDirectory.path("b/c"));
719   TempLink _c("no_such_file", TestDirectory.path("c"));
720   TempDir _d(TestDirectory.path("d"));
721   TempDir _dd(TestDirectory.path("d/d"));
722   TempDir _ddd(TestDirectory.path("d/d/d"));
723   TempLink _e("no_such_file", TestDirectory.path("e"));
724 
725   std::vector<std::string> VisitedBrokenSymlinks;
726   std::vector<std::string> VisitedNonBrokenSymlinks;
727   std::error_code EC;
728   for (vfs::recursive_directory_iterator
729            I(*FS, Twine(TestDirectory.path()), EC),
730        E;
731        I != E; I.increment(EC)) {
732     EXPECT_FALSE(EC);
733     (FS->status(I->path()) ? VisitedNonBrokenSymlinks : VisitedBrokenSymlinks)
734         .push_back(std::string(I->path()));
735   }
736 
737   // Check visited file names.
738   EXPECT_THAT(VisitedBrokenSymlinks,
739               UnorderedElementsAre(_a.path().str(), _ba.path().str(),
740                                    _bc.path().str(), _c.path().str(),
741                                    _e.path().str()));
742   EXPECT_THAT(VisitedNonBrokenSymlinks,
743               UnorderedElementsAre(_b.path().str(), _bb.path().str(),
744                                    _d.path().str(), _dd.path().str(),
745                                    _ddd.path().str()));
746 }
747 #endif
748 
749 template <typename DirIter>
750 static void checkContents(DirIter I, ArrayRef<StringRef> ExpectedOut) {
751   std::error_code EC;
752   SmallVector<StringRef, 4> Expected(ExpectedOut.begin(), ExpectedOut.end());
753   SmallVector<std::string, 4> InputToCheck;
754 
755   // Do not rely on iteration order to check for contents, sort both
756   // content vectors before comparison.
757   for (DirIter E; !EC && I != E; I.increment(EC))
758     InputToCheck.push_back(std::string(I->path()));
759 
760   llvm::sort(InputToCheck);
761   llvm::sort(Expected);
762   EXPECT_EQ(InputToCheck.size(), Expected.size());
763 
764   unsigned LastElt = std::min(InputToCheck.size(), Expected.size());
765   for (unsigned Idx = 0; Idx != LastElt; ++Idx)
766     EXPECT_EQ(StringRef(InputToCheck[Idx]), Expected[Idx]);
767 }
768 
769 TEST(VirtualFileSystemTest, OverlayIteration) {
770   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
771   IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
772   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
773       new vfs::OverlayFileSystem(Lower));
774   O->pushOverlay(Upper);
775 
776   std::error_code EC;
777   checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>());
778 
779   Lower->addRegularFile("/file1");
780   checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file1"));
781 
782   Upper->addRegularFile("/file2");
783   checkContents(O->dir_begin("/", EC), {"/file2", "/file1"});
784 
785   Lower->addDirectory("/dir1");
786   Lower->addRegularFile("/dir1/foo");
787   Upper->addDirectory("/dir2");
788   Upper->addRegularFile("/dir2/foo");
789   checkContents(O->dir_begin("/dir2", EC), ArrayRef<StringRef>("/dir2/foo"));
790   checkContents(O->dir_begin("/", EC), {"/dir2", "/file2", "/dir1", "/file1"});
791 }
792 
793 TEST(VirtualFileSystemTest, OverlayRecursiveIteration) {
794   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
795   IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
796   IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
797   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
798       new vfs::OverlayFileSystem(Lower));
799   O->pushOverlay(Middle);
800   O->pushOverlay(Upper);
801 
802   std::error_code EC;
803   checkContents(vfs::recursive_directory_iterator(*O, "/", EC),
804                 ArrayRef<StringRef>());
805 
806   Lower->addRegularFile("/file1");
807   checkContents(vfs::recursive_directory_iterator(*O, "/", EC),
808                 ArrayRef<StringRef>("/file1"));
809 
810   Upper->addDirectory("/dir");
811   Upper->addRegularFile("/dir/file2");
812   checkContents(vfs::recursive_directory_iterator(*O, "/", EC),
813                 {"/dir", "/dir/file2", "/file1"});
814 
815   Lower->addDirectory("/dir1");
816   Lower->addRegularFile("/dir1/foo");
817   Lower->addDirectory("/dir1/a");
818   Lower->addRegularFile("/dir1/a/b");
819   Middle->addDirectory("/a");
820   Middle->addDirectory("/a/b");
821   Middle->addDirectory("/a/b/c");
822   Middle->addRegularFile("/a/b/c/d");
823   Middle->addRegularFile("/hiddenByUp");
824   Upper->addDirectory("/dir2");
825   Upper->addRegularFile("/dir2/foo");
826   Upper->addRegularFile("/hiddenByUp");
827   checkContents(vfs::recursive_directory_iterator(*O, "/dir2", EC),
828                 ArrayRef<StringRef>("/dir2/foo"));
829   checkContents(vfs::recursive_directory_iterator(*O, "/", EC),
830                 {"/dir", "/dir/file2", "/dir2", "/dir2/foo", "/hiddenByUp",
831                  "/a", "/a/b", "/a/b/c", "/a/b/c/d", "/dir1", "/dir1/a",
832                  "/dir1/a/b", "/dir1/foo", "/file1"});
833 }
834 
835 TEST(VirtualFileSystemTest, ThreeLevelIteration) {
836   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
837   IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
838   IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
839   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
840       new vfs::OverlayFileSystem(Lower));
841   O->pushOverlay(Middle);
842   O->pushOverlay(Upper);
843 
844   std::error_code EC;
845   checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>());
846 
847   Middle->addRegularFile("/file2");
848   checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file2"));
849 
850   Lower->addRegularFile("/file1");
851   Upper->addRegularFile("/file3");
852   checkContents(O->dir_begin("/", EC), {"/file3", "/file2", "/file1"});
853 }
854 
855 TEST(VirtualFileSystemTest, HiddenInIteration) {
856   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
857   IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
858   IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
859   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
860       new vfs::OverlayFileSystem(Lower));
861   O->pushOverlay(Middle);
862   O->pushOverlay(Upper);
863 
864   std::error_code EC;
865   Lower->addRegularFile("/onlyInLow");
866   Lower->addDirectory("/hiddenByMid");
867   Lower->addDirectory("/hiddenByUp");
868   Middle->addRegularFile("/onlyInMid");
869   Middle->addRegularFile("/hiddenByMid");
870   Middle->addDirectory("/hiddenByUp");
871   Upper->addRegularFile("/onlyInUp");
872   Upper->addRegularFile("/hiddenByUp");
873   checkContents(
874       O->dir_begin("/", EC),
875       {"/hiddenByUp", "/onlyInUp", "/hiddenByMid", "/onlyInMid", "/onlyInLow"});
876 
877   // Make sure we get the top-most entry
878   {
879     std::error_code EC;
880     vfs::directory_iterator I = O->dir_begin("/", EC), E;
881     for (; !EC && I != E; I.increment(EC))
882       if (I->path() == "/hiddenByUp")
883         break;
884     ASSERT_NE(E, I);
885     EXPECT_EQ(sys::fs::file_type::regular_file, I->type());
886   }
887   {
888     std::error_code EC;
889     vfs::directory_iterator I = O->dir_begin("/", EC), E;
890     for (; !EC && I != E; I.increment(EC))
891       if (I->path() == "/hiddenByMid")
892         break;
893     ASSERT_NE(E, I);
894     EXPECT_EQ(sys::fs::file_type::regular_file, I->type());
895   }
896 }
897 
898 TEST(OverlayFileSystemTest, PrintOutput) {
899   auto Dummy = makeIntrusiveRefCnt<DummyFileSystem>();
900   auto Overlay1 = makeIntrusiveRefCnt<vfs::OverlayFileSystem>(Dummy);
901   Overlay1->pushOverlay(Dummy);
902   auto Overlay2 = makeIntrusiveRefCnt<vfs::OverlayFileSystem>(Overlay1);
903   Overlay2->pushOverlay(Dummy);
904 
905   SmallString<0> Output;
906   raw_svector_ostream OuputStream{Output};
907 
908   Overlay2->print(OuputStream, vfs::FileSystem::PrintType::Summary);
909   ASSERT_EQ("OverlayFileSystem\n", Output);
910 
911   Output.clear();
912   Overlay2->print(OuputStream, vfs::FileSystem::PrintType::Contents);
913   ASSERT_EQ("OverlayFileSystem\n"
914             "  DummyFileSystem (Summary)\n"
915             "  OverlayFileSystem\n",
916             Output);
917 
918   Output.clear();
919   Overlay2->print(OuputStream, vfs::FileSystem::PrintType::RecursiveContents);
920   ASSERT_EQ("OverlayFileSystem\n"
921             "  DummyFileSystem (RecursiveContents)\n"
922             "  OverlayFileSystem\n"
923             "    DummyFileSystem (RecursiveContents)\n"
924             "    DummyFileSystem (RecursiveContents)\n",
925             Output);
926 }
927 
928 TEST(ProxyFileSystemTest, Basic) {
929   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> Base(
930       new vfs::InMemoryFileSystem());
931   vfs::ProxyFileSystem PFS(Base);
932 
933   Base->addFile("/a", 0, MemoryBuffer::getMemBuffer("test"));
934 
935   auto Stat = PFS.status("/a");
936   ASSERT_FALSE(Stat.getError());
937 
938   auto File = PFS.openFileForRead("/a");
939   ASSERT_FALSE(File.getError());
940   EXPECT_EQ("test", (*(*File)->getBuffer("ignored"))->getBuffer());
941 
942   std::error_code EC;
943   vfs::directory_iterator I = PFS.dir_begin("/", EC);
944   ASSERT_FALSE(EC);
945   ASSERT_EQ("/a", I->path());
946   I.increment(EC);
947   ASSERT_FALSE(EC);
948   ASSERT_EQ(vfs::directory_iterator(), I);
949 
950   ASSERT_FALSE(PFS.setCurrentWorkingDirectory("/"));
951 
952   auto PWD = PFS.getCurrentWorkingDirectory();
953   ASSERT_FALSE(PWD.getError());
954   ASSERT_EQ("/", getPosixPath(*PWD));
955 
956   SmallString<16> Path;
957   ASSERT_FALSE(PFS.getRealPath("a", Path));
958   ASSERT_EQ("/a", getPosixPath(Path));
959 
960   bool Local = true;
961   ASSERT_FALSE(PFS.isLocal("/a", Local));
962   EXPECT_FALSE(Local);
963 }
964 
965 class InMemoryFileSystemTest : public ::testing::Test {
966 protected:
967   llvm::vfs::InMemoryFileSystem FS;
968   llvm::vfs::InMemoryFileSystem NormalizedFS;
969 
970   InMemoryFileSystemTest()
971       : FS(/*UseNormalizedPaths=*/false),
972         NormalizedFS(/*UseNormalizedPaths=*/true) {}
973 };
974 
975 MATCHER_P2(IsHardLinkTo, FS, Target, "") {
976   StringRef From = arg;
977   StringRef To = Target;
978   auto OpenedFrom = FS->openFileForRead(From);
979   auto OpenedTo = FS->openFileForRead(To);
980   return !OpenedFrom.getError() && !OpenedTo.getError() &&
981          (*OpenedFrom)->status()->getUniqueID() ==
982              (*OpenedTo)->status()->getUniqueID();
983 }
984 
985 TEST_F(InMemoryFileSystemTest, IsEmpty) {
986   auto Stat = FS.status("/a");
987   ASSERT_EQ(Stat.getError(), errc::no_such_file_or_directory) << FS.toString();
988   Stat = FS.status("/");
989   ASSERT_EQ(Stat.getError(), errc::no_such_file_or_directory) << FS.toString();
990 }
991 
992 TEST_F(InMemoryFileSystemTest, WindowsPath) {
993   FS.addFile("c:/windows/system128/foo.cpp", 0, MemoryBuffer::getMemBuffer(""));
994   auto Stat = FS.status("c:");
995 #if !defined(_WIN32)
996   ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString();
997 #endif
998   Stat = FS.status("c:/windows/system128/foo.cpp");
999   ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString();
1000   FS.addFile("d:/windows/foo.cpp", 0, MemoryBuffer::getMemBuffer(""));
1001   Stat = FS.status("d:/windows/foo.cpp");
1002   ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString();
1003 }
1004 
1005 TEST_F(InMemoryFileSystemTest, OverlayFile) {
1006   FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a"));
1007   NormalizedFS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a"));
1008   auto Stat = FS.status("/");
1009   ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString();
1010   Stat = FS.status("/.");
1011   ASSERT_FALSE(Stat);
1012   Stat = NormalizedFS.status("/.");
1013   ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString();
1014   Stat = FS.status("/a");
1015   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1016   ASSERT_EQ("/a", Stat->getName());
1017 }
1018 
1019 TEST_F(InMemoryFileSystemTest, OverlayFileNoOwn) {
1020   auto Buf = MemoryBuffer::getMemBuffer("a");
1021   FS.addFileNoOwn("/a", 0, *Buf);
1022   auto Stat = FS.status("/a");
1023   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1024   ASSERT_EQ("/a", Stat->getName());
1025 }
1026 
1027 TEST_F(InMemoryFileSystemTest, OpenFileForRead) {
1028   FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a"));
1029   FS.addFile("././c", 0, MemoryBuffer::getMemBuffer("c"));
1030   FS.addFile("./d/../d", 0, MemoryBuffer::getMemBuffer("d"));
1031   NormalizedFS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a"));
1032   NormalizedFS.addFile("././c", 0, MemoryBuffer::getMemBuffer("c"));
1033   NormalizedFS.addFile("./d/../d", 0, MemoryBuffer::getMemBuffer("d"));
1034   auto File = FS.openFileForRead("/a");
1035   ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer());
1036   File = FS.openFileForRead("/a"); // Open again.
1037   ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer());
1038   File = NormalizedFS.openFileForRead("/././a"); // Open again.
1039   ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer());
1040   File = FS.openFileForRead("/");
1041   ASSERT_EQ(File.getError(), errc::invalid_argument) << FS.toString();
1042   File = FS.openFileForRead("/b");
1043   ASSERT_EQ(File.getError(), errc::no_such_file_or_directory) << FS.toString();
1044   File = FS.openFileForRead("./c");
1045   ASSERT_FALSE(File);
1046   File = FS.openFileForRead("e/../d");
1047   ASSERT_FALSE(File);
1048   File = NormalizedFS.openFileForRead("./c");
1049   ASSERT_EQ("c", (*(*File)->getBuffer("ignored"))->getBuffer());
1050   File = NormalizedFS.openFileForRead("e/../d");
1051   ASSERT_EQ("d", (*(*File)->getBuffer("ignored"))->getBuffer());
1052 }
1053 
1054 TEST_F(InMemoryFileSystemTest, DuplicatedFile) {
1055   ASSERT_TRUE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")));
1056   ASSERT_FALSE(FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("a")));
1057   ASSERT_TRUE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a")));
1058   ASSERT_FALSE(FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("b")));
1059 }
1060 
1061 TEST_F(InMemoryFileSystemTest, DirectoryIteration) {
1062   FS.addFile("/a", 0, MemoryBuffer::getMemBuffer(""));
1063   FS.addFile("/b/c", 0, MemoryBuffer::getMemBuffer(""));
1064 
1065   std::error_code EC;
1066   vfs::directory_iterator I = FS.dir_begin("/", EC);
1067   ASSERT_FALSE(EC);
1068   ASSERT_EQ("/a", I->path());
1069   I.increment(EC);
1070   ASSERT_FALSE(EC);
1071   ASSERT_EQ("/b", I->path());
1072   I.increment(EC);
1073   ASSERT_FALSE(EC);
1074   ASSERT_EQ(vfs::directory_iterator(), I);
1075 
1076   I = FS.dir_begin("/b", EC);
1077   ASSERT_FALSE(EC);
1078   // When on Windows, we end up with "/b\\c" as the name.  Convert to Posix
1079   // path for the sake of the comparison.
1080   ASSERT_EQ("/b/c", getPosixPath(std::string(I->path())));
1081   I.increment(EC);
1082   ASSERT_FALSE(EC);
1083   ASSERT_EQ(vfs::directory_iterator(), I);
1084 }
1085 
1086 TEST_F(InMemoryFileSystemTest, WorkingDirectory) {
1087   FS.setCurrentWorkingDirectory("/b");
1088   FS.addFile("c", 0, MemoryBuffer::getMemBuffer(""));
1089 
1090   auto Stat = FS.status("/b/c");
1091   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1092   ASSERT_EQ("/b/c", Stat->getName());
1093   ASSERT_EQ("/b", *FS.getCurrentWorkingDirectory());
1094 
1095   Stat = FS.status("c");
1096   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1097 
1098   NormalizedFS.setCurrentWorkingDirectory("/b/c");
1099   NormalizedFS.setCurrentWorkingDirectory(".");
1100   ASSERT_EQ("/b/c",
1101             getPosixPath(NormalizedFS.getCurrentWorkingDirectory().get()));
1102   NormalizedFS.setCurrentWorkingDirectory("..");
1103   ASSERT_EQ("/b",
1104             getPosixPath(NormalizedFS.getCurrentWorkingDirectory().get()));
1105 }
1106 
1107 TEST_F(InMemoryFileSystemTest, IsLocal) {
1108   FS.setCurrentWorkingDirectory("/b");
1109   FS.addFile("c", 0, MemoryBuffer::getMemBuffer(""));
1110 
1111   std::error_code EC;
1112   bool IsLocal = true;
1113   EC = FS.isLocal("c", IsLocal);
1114   ASSERT_FALSE(EC);
1115   ASSERT_FALSE(IsLocal);
1116 }
1117 
1118 #if !defined(_WIN32)
1119 TEST_F(InMemoryFileSystemTest, GetRealPath) {
1120   SmallString<16> Path;
1121   EXPECT_EQ(FS.getRealPath("b", Path), errc::operation_not_permitted);
1122 
1123   auto GetRealPath = [this](StringRef P) {
1124     SmallString<16> Output;
1125     auto EC = FS.getRealPath(P, Output);
1126     EXPECT_FALSE(EC);
1127     return std::string(Output);
1128   };
1129 
1130   FS.setCurrentWorkingDirectory("a");
1131   EXPECT_EQ(GetRealPath("b"), "a/b");
1132   EXPECT_EQ(GetRealPath("../b"), "b");
1133   EXPECT_EQ(GetRealPath("b/./c"), "a/b/c");
1134 
1135   FS.setCurrentWorkingDirectory("/a");
1136   EXPECT_EQ(GetRealPath("b"), "/a/b");
1137   EXPECT_EQ(GetRealPath("../b"), "/b");
1138   EXPECT_EQ(GetRealPath("b/./c"), "/a/b/c");
1139 }
1140 #endif // _WIN32
1141 
1142 TEST_F(InMemoryFileSystemTest, AddFileWithUser) {
1143   FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), 0xFEEDFACE);
1144   auto Stat = FS.status("/a");
1145   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1146   ASSERT_TRUE(Stat->isDirectory());
1147   ASSERT_EQ(0xFEEDFACE, Stat->getUser());
1148   Stat = FS.status("/a/b");
1149   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1150   ASSERT_TRUE(Stat->isDirectory());
1151   ASSERT_EQ(0xFEEDFACE, Stat->getUser());
1152   Stat = FS.status("/a/b/c");
1153   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1154   ASSERT_TRUE(Stat->isRegularFile());
1155   ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions());
1156   ASSERT_EQ(0xFEEDFACE, Stat->getUser());
1157 }
1158 
1159 TEST_F(InMemoryFileSystemTest, AddFileWithGroup) {
1160   FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), std::nullopt,
1161              0xDABBAD00);
1162   auto Stat = FS.status("/a");
1163   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1164   ASSERT_TRUE(Stat->isDirectory());
1165   ASSERT_EQ(0xDABBAD00, Stat->getGroup());
1166   Stat = FS.status("/a/b");
1167   ASSERT_TRUE(Stat->isDirectory());
1168   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1169   ASSERT_EQ(0xDABBAD00, Stat->getGroup());
1170   Stat = FS.status("/a/b/c");
1171   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1172   ASSERT_TRUE(Stat->isRegularFile());
1173   ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions());
1174   ASSERT_EQ(0xDABBAD00, Stat->getGroup());
1175 }
1176 
1177 TEST_F(InMemoryFileSystemTest, AddFileWithFileType) {
1178   FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), std::nullopt,
1179              std::nullopt, sys::fs::file_type::socket_file);
1180   auto Stat = FS.status("/a");
1181   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1182   ASSERT_TRUE(Stat->isDirectory());
1183   Stat = FS.status("/a/b");
1184   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1185   ASSERT_TRUE(Stat->isDirectory());
1186   Stat = FS.status("/a/b/c");
1187   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1188   ASSERT_EQ(sys::fs::file_type::socket_file, Stat->getType());
1189   ASSERT_EQ(sys::fs::perms::all_all, Stat->getPermissions());
1190 }
1191 
1192 TEST_F(InMemoryFileSystemTest, AddFileWithPerms) {
1193   FS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"), std::nullopt,
1194              std::nullopt, std::nullopt,
1195              sys::fs::perms::owner_read | sys::fs::perms::owner_write);
1196   auto Stat = FS.status("/a");
1197   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1198   ASSERT_TRUE(Stat->isDirectory());
1199   ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write |
1200                 sys::fs::perms::owner_exe,
1201             Stat->getPermissions());
1202   Stat = FS.status("/a/b");
1203   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1204   ASSERT_TRUE(Stat->isDirectory());
1205   ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write |
1206                 sys::fs::perms::owner_exe,
1207             Stat->getPermissions());
1208   Stat = FS.status("/a/b/c");
1209   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1210   ASSERT_TRUE(Stat->isRegularFile());
1211   ASSERT_EQ(sys::fs::perms::owner_read | sys::fs::perms::owner_write,
1212             Stat->getPermissions());
1213 }
1214 
1215 TEST_F(InMemoryFileSystemTest, AddDirectoryThenAddChild) {
1216   FS.addFile("/a", 0, MemoryBuffer::getMemBuffer(""), /*User=*/std::nullopt,
1217              /*Group=*/std::nullopt, sys::fs::file_type::directory_file);
1218   FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("abc"),
1219              /*User=*/std::nullopt,
1220              /*Group=*/std::nullopt, sys::fs::file_type::regular_file);
1221   auto Stat = FS.status("/a");
1222   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1223   ASSERT_TRUE(Stat->isDirectory());
1224   Stat = FS.status("/a/b");
1225   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
1226   ASSERT_TRUE(Stat->isRegularFile());
1227 }
1228 
1229 // Test that the name returned by status() is in the same form as the path that
1230 // was requested (to match the behavior of RealFileSystem).
1231 TEST_F(InMemoryFileSystemTest, StatusName) {
1232   NormalizedFS.addFile("/a/b/c", 0, MemoryBuffer::getMemBuffer("abc"),
1233                        /*User=*/std::nullopt,
1234                        /*Group=*/std::nullopt,
1235                        sys::fs::file_type::regular_file);
1236   NormalizedFS.setCurrentWorkingDirectory("/a/b");
1237 
1238   // Access using InMemoryFileSystem::status.
1239   auto Stat = NormalizedFS.status("../b/c");
1240   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n"
1241                                 << NormalizedFS.toString();
1242   ASSERT_TRUE(Stat->isRegularFile());
1243   ASSERT_EQ("../b/c", Stat->getName());
1244 
1245   // Access using InMemoryFileAdaptor::status.
1246   auto File = NormalizedFS.openFileForRead("../b/c");
1247   ASSERT_FALSE(File.getError()) << File.getError() << "\n"
1248                                 << NormalizedFS.toString();
1249   Stat = (*File)->status();
1250   ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n"
1251                                 << NormalizedFS.toString();
1252   ASSERT_TRUE(Stat->isRegularFile());
1253   ASSERT_EQ("../b/c", Stat->getName());
1254 
1255   // Access using a directory iterator.
1256   std::error_code EC;
1257   llvm::vfs::directory_iterator It = NormalizedFS.dir_begin("../b", EC);
1258   // When on Windows, we end up with "../b\\c" as the name.  Convert to Posix
1259   // path for the sake of the comparison.
1260   ASSERT_EQ("../b/c", getPosixPath(std::string(It->path())));
1261 }
1262 
1263 TEST_F(InMemoryFileSystemTest, AddHardLinkToFile) {
1264   StringRef FromLink = "/path/to/FROM/link";
1265   StringRef Target = "/path/to/TO/file";
1266   FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target"));
1267   EXPECT_TRUE(FS.addHardLink(FromLink, Target));
1268   EXPECT_THAT(FromLink, IsHardLinkTo(&FS, Target));
1269   EXPECT_EQ(FS.status(FromLink)->getSize(), FS.status(Target)->getSize());
1270   EXPECT_EQ(FS.getBufferForFile(FromLink)->get()->getBuffer(),
1271             FS.getBufferForFile(Target)->get()->getBuffer());
1272 }
1273 
1274 TEST_F(InMemoryFileSystemTest, AddHardLinkInChainPattern) {
1275   StringRef Link0 = "/path/to/0/link";
1276   StringRef Link1 = "/path/to/1/link";
1277   StringRef Link2 = "/path/to/2/link";
1278   StringRef Target = "/path/to/target";
1279   FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target file"));
1280   EXPECT_TRUE(FS.addHardLink(Link2, Target));
1281   EXPECT_TRUE(FS.addHardLink(Link1, Link2));
1282   EXPECT_TRUE(FS.addHardLink(Link0, Link1));
1283   EXPECT_THAT(Link0, IsHardLinkTo(&FS, Target));
1284   EXPECT_THAT(Link1, IsHardLinkTo(&FS, Target));
1285   EXPECT_THAT(Link2, IsHardLinkTo(&FS, Target));
1286 }
1287 
1288 TEST_F(InMemoryFileSystemTest, AddHardLinkToAFileThatWasNotAddedBefore) {
1289   EXPECT_FALSE(FS.addHardLink("/path/to/link", "/path/to/target"));
1290 }
1291 
1292 TEST_F(InMemoryFileSystemTest, AddHardLinkFromAFileThatWasAddedBefore) {
1293   StringRef Link = "/path/to/link";
1294   StringRef Target = "/path/to/target";
1295   FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target"));
1296   FS.addFile(Link, 0, MemoryBuffer::getMemBuffer("content of link"));
1297   EXPECT_FALSE(FS.addHardLink(Link, Target));
1298 }
1299 
1300 TEST_F(InMemoryFileSystemTest, AddSameHardLinkMoreThanOnce) {
1301   StringRef Link = "/path/to/link";
1302   StringRef Target = "/path/to/target";
1303   FS.addFile(Target, 0, MemoryBuffer::getMemBuffer("content of target"));
1304   EXPECT_TRUE(FS.addHardLink(Link, Target));
1305   EXPECT_FALSE(FS.addHardLink(Link, Target));
1306 }
1307 
1308 TEST_F(InMemoryFileSystemTest, AddFileInPlaceOfAHardLinkWithSameContent) {
1309   StringRef Link = "/path/to/link";
1310   StringRef Target = "/path/to/target";
1311   StringRef Content = "content of target";
1312   EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content)));
1313   EXPECT_TRUE(FS.addHardLink(Link, Target));
1314   EXPECT_TRUE(FS.addFile(Link, 0, MemoryBuffer::getMemBuffer(Content)));
1315 }
1316 
1317 TEST_F(InMemoryFileSystemTest, AddFileInPlaceOfAHardLinkWithDifferentContent) {
1318   StringRef Link = "/path/to/link";
1319   StringRef Target = "/path/to/target";
1320   StringRef Content = "content of target";
1321   StringRef LinkContent = "different content of link";
1322   EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content)));
1323   EXPECT_TRUE(FS.addHardLink(Link, Target));
1324   EXPECT_FALSE(FS.addFile(Link, 0, MemoryBuffer::getMemBuffer(LinkContent)));
1325 }
1326 
1327 TEST_F(InMemoryFileSystemTest, AddHardLinkToADirectory) {
1328   StringRef Dir = "path/to/dummy/dir";
1329   StringRef Link = "/path/to/link";
1330   StringRef File = "path/to/dummy/dir/target";
1331   StringRef Content = "content of target";
1332   EXPECT_TRUE(FS.addFile(File, 0, MemoryBuffer::getMemBuffer(Content)));
1333   EXPECT_FALSE(FS.addHardLink(Link, Dir));
1334 }
1335 
1336 TEST_F(InMemoryFileSystemTest, AddHardLinkToASymlink) {
1337   EXPECT_TRUE(FS.addFile("/file", 0, MemoryBuffer::getMemBuffer("content")));
1338   EXPECT_TRUE(FS.addSymbolicLink("/symlink", "/file", 0));
1339   EXPECT_TRUE(FS.addHardLink("/hardlink", "/symlink"));
1340   EXPECT_EQ((*FS.getBufferForFile("/hardlink"))->getBuffer(), "content");
1341 }
1342 
1343 TEST_F(InMemoryFileSystemTest, AddHardLinkFromADirectory) {
1344   StringRef Dir = "path/to/dummy/dir";
1345   StringRef Target = "path/to/dummy/dir/target";
1346   StringRef Content = "content of target";
1347   EXPECT_TRUE(FS.addFile(Target, 0, MemoryBuffer::getMemBuffer(Content)));
1348   EXPECT_FALSE(FS.addHardLink(Dir, Target));
1349 }
1350 
1351 TEST_F(InMemoryFileSystemTest, AddHardLinkUnderAFile) {
1352   StringRef CommonContent = "content string";
1353   FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer(CommonContent));
1354   FS.addFile("/c/d", 0, MemoryBuffer::getMemBuffer(CommonContent));
1355   EXPECT_FALSE(FS.addHardLink("/c/d/e", "/a/b"));
1356 }
1357 
1358 TEST_F(InMemoryFileSystemTest, RecursiveIterationWithHardLink) {
1359   std::error_code EC;
1360   FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("content string"));
1361   EXPECT_TRUE(FS.addHardLink("/c/d", "/a/b"));
1362   auto I = vfs::recursive_directory_iterator(FS, "/", EC);
1363   ASSERT_FALSE(EC);
1364   std::vector<std::string> Nodes;
1365   for (auto E = vfs::recursive_directory_iterator(); !EC && I != E;
1366        I.increment(EC)) {
1367     Nodes.push_back(getPosixPath(std::string(I->path())));
1368   }
1369   EXPECT_THAT(Nodes, testing::UnorderedElementsAre("/a", "/a/b", "/c", "/c/d"));
1370 }
1371 
1372 TEST_F(InMemoryFileSystemTest, UniqueID) {
1373   ASSERT_TRUE(FS.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("text")));
1374   ASSERT_TRUE(FS.addFile("/c/d", 0, MemoryBuffer::getMemBuffer("text")));
1375   ASSERT_TRUE(FS.addHardLink("/e/f", "/a/b"));
1376 
1377   EXPECT_EQ(FS.status("/a/b")->getUniqueID(), FS.status("/a/b")->getUniqueID());
1378   EXPECT_NE(FS.status("/a/b")->getUniqueID(), FS.status("/c/d")->getUniqueID());
1379   EXPECT_EQ(FS.status("/a/b")->getUniqueID(), FS.status("/e/f")->getUniqueID());
1380   EXPECT_EQ(FS.status("/a")->getUniqueID(), FS.status("/a")->getUniqueID());
1381   EXPECT_NE(FS.status("/a")->getUniqueID(), FS.status("/c")->getUniqueID());
1382   EXPECT_NE(FS.status("/a")->getUniqueID(), FS.status("/e")->getUniqueID());
1383 
1384   // Recreating the "same" FS yields the same UniqueIDs.
1385   // Note: FS2 should match FS with respect to path normalization.
1386   vfs::InMemoryFileSystem FS2(/*UseNormalizedPath=*/false);
1387   ASSERT_TRUE(FS2.addFile("/a/b", 0, MemoryBuffer::getMemBuffer("text")));
1388   EXPECT_EQ(FS.status("/a/b")->getUniqueID(),
1389             FS2.status("/a/b")->getUniqueID());
1390   EXPECT_EQ(FS.status("/a")->getUniqueID(), FS2.status("/a")->getUniqueID());
1391 }
1392 
1393 TEST_F(InMemoryFileSystemTest, AddSymlinkToAFile) {
1394   EXPECT_TRUE(
1395       FS.addFile("/some/file", 0, MemoryBuffer::getMemBuffer("contents")));
1396   EXPECT_TRUE(FS.addSymbolicLink("/other/file/link", "/some/file", 0));
1397   ErrorOr<vfs::Status> Stat = FS.status("/some/file");
1398   EXPECT_TRUE(Stat->isRegularFile());
1399 }
1400 
1401 TEST_F(InMemoryFileSystemTest, AddSymlinkToADirectory) {
1402   EXPECT_TRUE(FS.addSymbolicLink("/link", "/target", 0));
1403   EXPECT_TRUE(
1404       FS.addFile("/target/foo.h", 0, MemoryBuffer::getMemBuffer("foo")));
1405   ErrorOr<vfs::Status> Stat = FS.status("/link/foo.h");
1406   EXPECT_TRUE(Stat);
1407   EXPECT_EQ((*Stat).getName(), "/link/foo.h");
1408   EXPECT_TRUE(Stat->isRegularFile());
1409 }
1410 
1411 TEST_F(InMemoryFileSystemTest, AddSymlinkToASymlink) {
1412   EXPECT_TRUE(FS.addSymbolicLink("/first", "/second", 0));
1413   EXPECT_TRUE(FS.addSymbolicLink("/second", "/third", 0));
1414   EXPECT_TRUE(FS.addFile("/third", 0, MemoryBuffer::getMemBuffer("")));
1415   ErrorOr<vfs::Status> Stat = FS.status("/first");
1416   EXPECT_TRUE(Stat);
1417   EXPECT_EQ((*Stat).getName(), "/first");
1418   // Follow-through symlinks by default. This matches RealFileSystem's
1419   // semantics.
1420   EXPECT_TRUE(Stat->isRegularFile());
1421   Stat = FS.status("/second");
1422   EXPECT_TRUE(Stat);
1423   EXPECT_EQ((*Stat).getName(), "/second");
1424   EXPECT_TRUE(Stat->isRegularFile());
1425   Stat = FS.status("/third");
1426   EXPECT_TRUE(Stat);
1427   EXPECT_EQ((*Stat).getName(), "/third");
1428   EXPECT_TRUE(Stat->isRegularFile());
1429 }
1430 
1431 TEST_F(InMemoryFileSystemTest, AddRecursiveSymlink) {
1432   EXPECT_TRUE(FS.addSymbolicLink("/link-a", "/link-b", 0));
1433   EXPECT_TRUE(FS.addSymbolicLink("/link-b", "/link-a", 0));
1434   ErrorOr<vfs::Status> Stat = FS.status("/link-a/foo");
1435   EXPECT_FALSE(Stat);
1436   EXPECT_EQ(Stat.getError(), errc::no_such_file_or_directory);
1437 }
1438 
1439 TEST_F(InMemoryFileSystemTest, DirectoryIteratorWithSymlinkToAFile) {
1440   std::error_code EC;
1441 
1442   EXPECT_TRUE(FS.addFile("/file", 0, MemoryBuffer::getMemBuffer("")));
1443   EXPECT_TRUE(FS.addSymbolicLink("/symlink", "/file", 0));
1444 
1445   vfs::directory_iterator I = FS.dir_begin("/", EC), E;
1446   ASSERT_FALSE(EC);
1447 
1448   std::vector<std::string> Nodes;
1449   for (; !EC && I != E; I.increment(EC))
1450     Nodes.push_back(getPosixPath(std::string(I->path())));
1451 
1452   EXPECT_THAT(Nodes, testing::UnorderedElementsAre("/file", "/file"));
1453 }
1454 
1455 TEST_F(InMemoryFileSystemTest, RecursiveDirectoryIteratorWithSymlinkToADir) {
1456   std::error_code EC;
1457 
1458   EXPECT_TRUE(FS.addFile("/dir/file", 0, MemoryBuffer::getMemBuffer("")));
1459   EXPECT_TRUE(FS.addSymbolicLink("/dir_symlink", "/dir", 0));
1460 
1461   vfs::recursive_directory_iterator I(FS, "/", EC), E;
1462   ASSERT_FALSE(EC);
1463 
1464   std::vector<std::string> Nodes;
1465   for (; !EC && I != E; I.increment(EC))
1466     Nodes.push_back(getPosixPath(std::string(I->path())));
1467 
1468   EXPECT_THAT(Nodes, testing::UnorderedElementsAre("/dir", "/dir/file", "/dir",
1469                                                    "/dir/file"));
1470 }
1471 
1472 // NOTE: in the tests below, we use '//root/' as our root directory, since it is
1473 // a legal *absolute* path on Windows as well as *nix.
1474 class VFSFromYAMLTest : public ::testing::Test {
1475 public:
1476   int NumDiagnostics;
1477 
1478   void SetUp() override { NumDiagnostics = 0; }
1479 
1480   static void CountingDiagHandler(const SMDiagnostic &, void *Context) {
1481     VFSFromYAMLTest *Test = static_cast<VFSFromYAMLTest *>(Context);
1482     ++Test->NumDiagnostics;
1483   }
1484 
1485   std::unique_ptr<vfs::FileSystem>
1486   getFromYAMLRawString(StringRef Content,
1487                        IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS,
1488                        StringRef YAMLFilePath = "") {
1489     std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Content);
1490     return getVFSFromYAML(std::move(Buffer), CountingDiagHandler, YAMLFilePath,
1491                           this, ExternalFS);
1492   }
1493 
1494   std::unique_ptr<vfs::FileSystem> getFromYAMLString(
1495       StringRef Content,
1496       IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS = new DummyFileSystem(),
1497       StringRef YAMLFilePath = "") {
1498     std::string VersionPlusContent("{\n  'version':0,\n");
1499     VersionPlusContent += Content.slice(Content.find('{') + 1, StringRef::npos);
1500     return getFromYAMLRawString(VersionPlusContent, ExternalFS, YAMLFilePath);
1501   }
1502 
1503   // This is intended as a "XFAIL" for windows hosts.
1504   bool supportsSameDirMultipleYAMLEntries() {
1505     Triple Host(Triple::normalize(sys::getProcessTriple()));
1506     return !Host.isOSWindows();
1507   }
1508 };
1509 
1510 TEST_F(VFSFromYAMLTest, BasicVFSFromYAML) {
1511   IntrusiveRefCntPtr<vfs::FileSystem> FS;
1512   FS = getFromYAMLString("");
1513   EXPECT_EQ(nullptr, FS.get());
1514   FS = getFromYAMLString("[]");
1515   EXPECT_EQ(nullptr, FS.get());
1516   FS = getFromYAMLString("'string'");
1517   EXPECT_EQ(nullptr, FS.get());
1518   EXPECT_EQ(3, NumDiagnostics);
1519 }
1520 
1521 TEST_F(VFSFromYAMLTest, MappedFiles) {
1522   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
1523   Lower->addDirectory("//root/foo/bar");
1524   Lower->addRegularFile("//root/foo/bar/a");
1525   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
1526       "{ 'roots': [\n"
1527       "{\n"
1528       "  'type': 'directory',\n"
1529       "  'name': '//root/',\n"
1530       "  'contents': [ {\n"
1531       "                  'type': 'file',\n"
1532       "                  'name': 'file1',\n"
1533       "                  'external-contents': '//root/foo/bar/a'\n"
1534       "                },\n"
1535       "                {\n"
1536       "                  'type': 'file',\n"
1537       "                  'name': 'file2',\n"
1538       "                  'external-contents': '//root/foo/b'\n"
1539       "                },\n"
1540       "                {\n"
1541       "                  'type': 'directory-remap',\n"
1542       "                  'name': 'mappeddir',\n"
1543       "                  'external-contents': '//root/foo/bar'\n"
1544       "                },\n"
1545       "                {\n"
1546       "                  'type': 'directory-remap',\n"
1547       "                  'name': 'mappeddir2',\n"
1548       "                  'use-external-name': false,\n"
1549       "                  'external-contents': '//root/foo/bar'\n"
1550       "                }\n"
1551       "              ]\n"
1552       "}\n"
1553       "]\n"
1554       "}",
1555       Lower);
1556   ASSERT_NE(FS.get(), nullptr);
1557 
1558   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
1559       new vfs::OverlayFileSystem(Lower));
1560   O->pushOverlay(FS);
1561 
1562   // file
1563   ErrorOr<vfs::Status> S = O->status("//root/file1");
1564   ASSERT_FALSE(S.getError());
1565   EXPECT_EQ("//root/foo/bar/a", S->getName());
1566   EXPECT_TRUE(S->IsVFSMapped);
1567   EXPECT_TRUE(S->ExposesExternalVFSPath);
1568 
1569   ErrorOr<vfs::Status> SLower = O->status("//root/foo/bar/a");
1570   EXPECT_EQ("//root/foo/bar/a", SLower->getName());
1571   EXPECT_TRUE(S->equivalent(*SLower));
1572   EXPECT_FALSE(SLower->IsVFSMapped);
1573   EXPECT_FALSE(SLower->ExposesExternalVFSPath);
1574 
1575   // file after opening
1576   auto OpenedF = O->openFileForRead("//root/file1");
1577   ASSERT_FALSE(OpenedF.getError());
1578   auto OpenedS = (*OpenedF)->status();
1579   ASSERT_FALSE(OpenedS.getError());
1580   EXPECT_EQ("//root/foo/bar/a", OpenedS->getName());
1581   EXPECT_TRUE(OpenedS->IsVFSMapped);
1582   EXPECT_TRUE(OpenedS->ExposesExternalVFSPath);
1583 
1584   // directory
1585   S = O->status("//root/");
1586   ASSERT_FALSE(S.getError());
1587   EXPECT_TRUE(S->isDirectory());
1588   EXPECT_TRUE(S->equivalent(*O->status("//root/"))); // non-volatile UniqueID
1589 
1590   // remapped directory
1591   S = O->status("//root/mappeddir");
1592   ASSERT_FALSE(S.getError());
1593   EXPECT_TRUE(S->isDirectory());
1594   EXPECT_TRUE(S->IsVFSMapped);
1595   EXPECT_TRUE(S->ExposesExternalVFSPath);
1596   EXPECT_TRUE(S->equivalent(*O->status("//root/foo/bar")));
1597 
1598   SLower = O->status("//root/foo/bar");
1599   EXPECT_EQ("//root/foo/bar", SLower->getName());
1600   EXPECT_TRUE(S->equivalent(*SLower));
1601   EXPECT_FALSE(SLower->IsVFSMapped);
1602   EXPECT_FALSE(SLower->ExposesExternalVFSPath);
1603 
1604   // file in remapped directory
1605   S = O->status("//root/mappeddir/a");
1606   ASSERT_FALSE(S.getError());
1607   EXPECT_FALSE(S->isDirectory());
1608   EXPECT_TRUE(S->IsVFSMapped);
1609   EXPECT_TRUE(S->ExposesExternalVFSPath);
1610   EXPECT_EQ("//root/foo/bar/a", S->getName());
1611 
1612   // file in remapped directory, with use-external-name=false
1613   S = O->status("//root/mappeddir2/a");
1614   ASSERT_FALSE(S.getError());
1615   EXPECT_FALSE(S->isDirectory());
1616   EXPECT_TRUE(S->IsVFSMapped);
1617   EXPECT_FALSE(S->ExposesExternalVFSPath);
1618   EXPECT_EQ("//root/mappeddir2/a", S->getName());
1619 
1620   // file contents in remapped directory
1621   OpenedF = O->openFileForRead("//root/mappeddir/a");
1622   ASSERT_FALSE(OpenedF.getError());
1623   OpenedS = (*OpenedF)->status();
1624   ASSERT_FALSE(OpenedS.getError());
1625   EXPECT_EQ("//root/foo/bar/a", OpenedS->getName());
1626   EXPECT_TRUE(OpenedS->IsVFSMapped);
1627   EXPECT_TRUE(OpenedS->ExposesExternalVFSPath);
1628 
1629   // file contents in remapped directory, with use-external-name=false
1630   OpenedF = O->openFileForRead("//root/mappeddir2/a");
1631   ASSERT_FALSE(OpenedF.getError());
1632   OpenedS = (*OpenedF)->status();
1633   ASSERT_FALSE(OpenedS.getError());
1634   EXPECT_EQ("//root/mappeddir2/a", OpenedS->getName());
1635   EXPECT_TRUE(OpenedS->IsVFSMapped);
1636   EXPECT_FALSE(OpenedS->ExposesExternalVFSPath);
1637 
1638   // broken mapping
1639   EXPECT_EQ(O->status("//root/file2").getError(),
1640             llvm::errc::no_such_file_or_directory);
1641   EXPECT_EQ(0, NumDiagnostics);
1642 }
1643 
1644 TEST_F(VFSFromYAMLTest, MappedRoot) {
1645   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
1646   Lower->addDirectory("//root/foo/bar");
1647   Lower->addRegularFile("//root/foo/bar/a");
1648   IntrusiveRefCntPtr<vfs::FileSystem> FS =
1649       getFromYAMLString("{ 'roots': [\n"
1650                         "{\n"
1651                         "  'type': 'directory-remap',\n"
1652                         "  'name': '//mappedroot/',\n"
1653                         "  'external-contents': '//root/foo/bar'\n"
1654                         "}\n"
1655                         "]\n"
1656                         "}",
1657                         Lower);
1658   ASSERT_NE(FS.get(), nullptr);
1659 
1660   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
1661       new vfs::OverlayFileSystem(Lower));
1662   O->pushOverlay(FS);
1663 
1664   // file
1665   ErrorOr<vfs::Status> S = O->status("//mappedroot/a");
1666   ASSERT_FALSE(S.getError());
1667   EXPECT_EQ("//root/foo/bar/a", S->getName());
1668   EXPECT_TRUE(S->IsVFSMapped);
1669   EXPECT_TRUE(S->ExposesExternalVFSPath);
1670 
1671   ErrorOr<vfs::Status> SLower = O->status("//root/foo/bar/a");
1672   EXPECT_EQ("//root/foo/bar/a", SLower->getName());
1673   EXPECT_TRUE(S->equivalent(*SLower));
1674   EXPECT_FALSE(SLower->IsVFSMapped);
1675   EXPECT_FALSE(SLower->ExposesExternalVFSPath);
1676 
1677   // file after opening
1678   auto OpenedF = O->openFileForRead("//mappedroot/a");
1679   ASSERT_FALSE(OpenedF.getError());
1680   auto OpenedS = (*OpenedF)->status();
1681   ASSERT_FALSE(OpenedS.getError());
1682   EXPECT_EQ("//root/foo/bar/a", OpenedS->getName());
1683   EXPECT_TRUE(OpenedS->IsVFSMapped);
1684   EXPECT_TRUE(OpenedS->ExposesExternalVFSPath);
1685 
1686   EXPECT_EQ(0, NumDiagnostics);
1687 }
1688 
1689 TEST_F(VFSFromYAMLTest, RemappedDirectoryOverlay) {
1690   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
1691   Lower->addDirectory("//root/foo");
1692   Lower->addRegularFile("//root/foo/a");
1693   Lower->addDirectory("//root/bar");
1694   Lower->addRegularFile("//root/bar/b");
1695   Lower->addRegularFile("//root/bar/c");
1696   IntrusiveRefCntPtr<vfs::FileSystem> FS =
1697       getFromYAMLString("{ 'roots': [\n"
1698                         "{\n"
1699                         "  'type': 'directory',\n"
1700                         "  'name': '//root/',\n"
1701                         "  'contents': [ {\n"
1702                         "                  'type': 'directory-remap',\n"
1703                         "                  'name': 'bar',\n"
1704                         "                  'external-contents': '//root/foo'\n"
1705                         "                }\n"
1706                         "              ]\n"
1707                         "}]}",
1708                         Lower);
1709   ASSERT_NE(FS.get(), nullptr);
1710 
1711   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
1712       new vfs::OverlayFileSystem(Lower));
1713   O->pushOverlay(FS);
1714 
1715   ErrorOr<vfs::Status> S = O->status("//root/foo");
1716   ASSERT_FALSE(S.getError());
1717 
1718   ErrorOr<vfs::Status> SS = O->status("//root/bar");
1719   ASSERT_FALSE(SS.getError());
1720   EXPECT_TRUE(S->equivalent(*SS));
1721 
1722   std::error_code EC;
1723   checkContents(O->dir_begin("//root/bar", EC),
1724                 {"//root/foo/a", "//root/bar/b", "//root/bar/c"});
1725 
1726   Lower->addRegularFile("//root/foo/b");
1727   checkContents(O->dir_begin("//root/bar", EC),
1728                 {"//root/foo/a", "//root/foo/b", "//root/bar/c"});
1729 
1730   EXPECT_EQ(0, NumDiagnostics);
1731 }
1732 
1733 TEST_F(VFSFromYAMLTest, RemappedDirectoryOverlayNoExternalNames) {
1734   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
1735   Lower->addDirectory("//root/foo");
1736   Lower->addRegularFile("//root/foo/a");
1737   Lower->addDirectory("//root/bar");
1738   Lower->addRegularFile("//root/bar/b");
1739   Lower->addRegularFile("//root/bar/c");
1740   IntrusiveRefCntPtr<vfs::FileSystem> FS =
1741       getFromYAMLString("{ 'use-external-names': false,\n"
1742                         "  'roots': [\n"
1743                         "{\n"
1744                         "  'type': 'directory',\n"
1745                         "  'name': '//root/',\n"
1746                         "  'contents': [ {\n"
1747                         "                  'type': 'directory-remap',\n"
1748                         "                  'name': 'bar',\n"
1749                         "                  'external-contents': '//root/foo'\n"
1750                         "                }\n"
1751                         "              ]\n"
1752                         "}]}",
1753                         Lower);
1754   ASSERT_NE(FS.get(), nullptr);
1755 
1756   ErrorOr<vfs::Status> S = FS->status("//root/foo");
1757   ASSERT_FALSE(S.getError());
1758 
1759   ErrorOr<vfs::Status> SS = FS->status("//root/bar");
1760   ASSERT_FALSE(SS.getError());
1761   EXPECT_TRUE(S->equivalent(*SS));
1762 
1763   std::error_code EC;
1764   checkContents(FS->dir_begin("//root/bar", EC),
1765                 {"//root/bar/a", "//root/bar/b", "//root/bar/c"});
1766 
1767   Lower->addRegularFile("//root/foo/b");
1768   checkContents(FS->dir_begin("//root/bar", EC),
1769                 {"//root/bar/a", "//root/bar/b", "//root/bar/c"});
1770 
1771   EXPECT_EQ(0, NumDiagnostics);
1772 }
1773 
1774 TEST_F(VFSFromYAMLTest, RemappedDirectoryOverlayNoFallthrough) {
1775   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
1776   Lower->addDirectory("//root/foo");
1777   Lower->addRegularFile("//root/foo/a");
1778   Lower->addDirectory("//root/bar");
1779   Lower->addRegularFile("//root/bar/b");
1780   Lower->addRegularFile("//root/bar/c");
1781   IntrusiveRefCntPtr<vfs::FileSystem> FS =
1782       getFromYAMLString("{ 'fallthrough': false,\n"
1783                         "  'roots': [\n"
1784                         "{\n"
1785                         "  'type': 'directory',\n"
1786                         "  'name': '//root/',\n"
1787                         "  'contents': [ {\n"
1788                         "                  'type': 'directory-remap',\n"
1789                         "                  'name': 'bar',\n"
1790                         "                  'external-contents': '//root/foo'\n"
1791                         "                }\n"
1792                         "              ]\n"
1793                         "}]}",
1794                         Lower);
1795   ASSERT_NE(FS.get(), nullptr);
1796 
1797   ErrorOr<vfs::Status> S = Lower->status("//root/foo");
1798   ASSERT_FALSE(S.getError());
1799 
1800   ErrorOr<vfs::Status> SS = FS->status("//root/bar");
1801   ASSERT_FALSE(SS.getError());
1802   EXPECT_TRUE(S->equivalent(*SS));
1803 
1804   std::error_code EC;
1805   checkContents(FS->dir_begin("//root/bar", EC), {"//root/foo/a"});
1806 
1807   Lower->addRegularFile("//root/foo/b");
1808   checkContents(FS->dir_begin("//root/bar", EC),
1809                 {"//root/foo/a", "//root/foo/b"});
1810 
1811   EXPECT_EQ(0, NumDiagnostics);
1812 }
1813 
1814 TEST_F(VFSFromYAMLTest, ReturnsRequestedPathVFSMiss) {
1815   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> BaseFS(
1816       new vfs::InMemoryFileSystem);
1817   BaseFS->addFile("//root/foo/a", 0,
1818                   MemoryBuffer::getMemBuffer("contents of a"));
1819   ASSERT_FALSE(BaseFS->setCurrentWorkingDirectory("//root/foo"));
1820   auto RemappedFS = vfs::RedirectingFileSystem::create(
1821       {}, /*UseExternalNames=*/false, *BaseFS);
1822 
1823   auto OpenedF = RemappedFS->openFileForRead("a");
1824   ASSERT_FALSE(OpenedF.getError());
1825   llvm::ErrorOr<std::string> Name = (*OpenedF)->getName();
1826   ASSERT_FALSE(Name.getError());
1827   EXPECT_EQ("a", Name.get());
1828 
1829   auto OpenedS = (*OpenedF)->status();
1830   ASSERT_FALSE(OpenedS.getError());
1831   EXPECT_EQ("a", OpenedS->getName());
1832   EXPECT_FALSE(OpenedS->IsVFSMapped);
1833   EXPECT_FALSE(OpenedS->ExposesExternalVFSPath);
1834 
1835   auto DirectS = RemappedFS->status("a");
1836   ASSERT_FALSE(DirectS.getError());
1837   EXPECT_EQ("a", DirectS->getName());
1838   EXPECT_FALSE(DirectS->IsVFSMapped);
1839   EXPECT_FALSE(DirectS->ExposesExternalVFSPath);
1840 
1841   EXPECT_EQ(0, NumDiagnostics);
1842 }
1843 
1844 TEST_F(VFSFromYAMLTest, ReturnsExternalPathVFSHit) {
1845   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> BaseFS(
1846       new vfs::InMemoryFileSystem);
1847   BaseFS->addFile("//root/foo/realname", 0,
1848                   MemoryBuffer::getMemBuffer("contents of a"));
1849   auto FS =
1850       getFromYAMLString("{ 'use-external-names': true,\n"
1851                         "  'roots': [\n"
1852                         "{\n"
1853                         "  'type': 'directory',\n"
1854                         "  'name': '//root/foo',\n"
1855                         "  'contents': [ {\n"
1856                         "                  'type': 'file',\n"
1857                         "                  'name': 'vfsname',\n"
1858                         "                  'external-contents': 'realname'\n"
1859                         "                }\n"
1860                         "              ]\n"
1861                         "}]}",
1862                         BaseFS);
1863   ASSERT_FALSE(FS->setCurrentWorkingDirectory("//root/foo"));
1864 
1865   auto OpenedF = FS->openFileForRead("vfsname");
1866   ASSERT_FALSE(OpenedF.getError());
1867   llvm::ErrorOr<std::string> Name = (*OpenedF)->getName();
1868   ASSERT_FALSE(Name.getError());
1869   EXPECT_EQ("realname", Name.get());
1870 
1871   auto OpenedS = (*OpenedF)->status();
1872   ASSERT_FALSE(OpenedS.getError());
1873   EXPECT_EQ("realname", OpenedS->getName());
1874   EXPECT_TRUE(OpenedS->IsVFSMapped);
1875   EXPECT_TRUE(OpenedS->ExposesExternalVFSPath);
1876 
1877   auto DirectS = FS->status("vfsname");
1878   ASSERT_FALSE(DirectS.getError());
1879   EXPECT_EQ("realname", DirectS->getName());
1880   EXPECT_TRUE(DirectS->IsVFSMapped);
1881   EXPECT_TRUE(DirectS->ExposesExternalVFSPath);
1882 
1883   EXPECT_EQ(0, NumDiagnostics);
1884 }
1885 
1886 TEST_F(VFSFromYAMLTest, RootRelativeTest) {
1887   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
1888   Lower->addDirectory("//root/foo/bar");
1889   Lower->addRegularFile("//root/foo/bar/a");
1890   IntrusiveRefCntPtr<vfs::FileSystem> FS =
1891       getFromYAMLString("{\n"
1892                         "  'case-sensitive': false,\n"
1893                         "  'root-relative': 'overlay-dir',\n"
1894                         "  'roots': [\n"
1895                         "    { 'name': 'b', 'type': 'file',\n"
1896                         "      'external-contents': '//root/foo/bar/a'\n"
1897                         "    }\n"
1898                         "  ]\n"
1899                         "}",
1900                         Lower, "//root/foo/bar/overlay");
1901 
1902   ASSERT_NE(FS.get(), nullptr);
1903   ErrorOr<vfs::Status> S = FS->status("//root/foo/bar/b");
1904   ASSERT_FALSE(S.getError());
1905   EXPECT_EQ("//root/foo/bar/a", S->getName());
1906 
1907   // On Windows, with overlay-relative set to true, the relative
1908   // path in external-contents field will be prepend by OverlayDir
1909   // with native path separator, regardless of the actual path separator
1910   // used in YAMLFilePath field.
1911 #ifndef _WIN32
1912   FS = getFromYAMLString("{\n"
1913                          "  'case-sensitive': false,\n"
1914                          "  'overlay-relative': true,\n"
1915                          "  'root-relative': 'overlay-dir',\n"
1916                          "  'roots': [\n"
1917                          "    { 'name': 'b', 'type': 'file',\n"
1918                          "      'external-contents': 'a'\n"
1919                          "    }\n"
1920                          "  ]\n"
1921                          "}",
1922                          Lower, "//root/foo/bar/overlay");
1923   ASSERT_NE(FS.get(), nullptr);
1924   S = FS->status("//root/foo/bar/b");
1925   ASSERT_FALSE(S.getError());
1926   EXPECT_EQ("//root/foo/bar/a", S->getName());
1927 #else
1928   IntrusiveRefCntPtr<DummyFileSystem> LowerWindows(new DummyFileSystem());
1929   LowerWindows->addDirectory("\\\\root\\foo\\bar");
1930   LowerWindows->addRegularFile("\\\\root\\foo\\bar\\a");
1931   FS = getFromYAMLString("{\n"
1932                          "  'case-sensitive': false,\n"
1933                          "  'overlay-relative': true,\n"
1934                          "  'root-relative': 'overlay-dir',\n"
1935                          "  'roots': [\n"
1936                          "    { 'name': 'b', 'type': 'file',\n"
1937                          "      'external-contents': 'a'\n"
1938                          "    }\n"
1939                          "  ]\n"
1940                          "}",
1941                          LowerWindows, "\\\\root\\foo\\bar\\overlay");
1942   ASSERT_NE(FS.get(), nullptr);
1943   S = FS->status("\\\\root\\foo\\bar\\b");
1944   ASSERT_FALSE(S.getError());
1945   EXPECT_EQ("\\\\root\\foo\\bar\\a", S->getName());
1946 #endif
1947 }
1948 
1949 TEST_F(VFSFromYAMLTest, ReturnsInternalPathVFSHit) {
1950   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> BaseFS(
1951       new vfs::InMemoryFileSystem);
1952   BaseFS->addFile("//root/foo/realname", 0,
1953                   MemoryBuffer::getMemBuffer("contents of a"));
1954   auto FS =
1955       getFromYAMLString("{ 'use-external-names': false,\n"
1956                         "  'roots': [\n"
1957                         "{\n"
1958                         "  'type': 'directory',\n"
1959                         "  'name': '//root/foo',\n"
1960                         "  'contents': [ {\n"
1961                         "                  'type': 'file',\n"
1962                         "                  'name': 'vfsname',\n"
1963                         "                  'external-contents': 'realname'\n"
1964                         "                }\n"
1965                         "              ]\n"
1966                         "}]}",
1967                         BaseFS);
1968   ASSERT_FALSE(FS->setCurrentWorkingDirectory("//root/foo"));
1969 
1970   auto OpenedF = FS->openFileForRead("vfsname");
1971   ASSERT_FALSE(OpenedF.getError());
1972   llvm::ErrorOr<std::string> Name = (*OpenedF)->getName();
1973   ASSERT_FALSE(Name.getError());
1974   EXPECT_EQ("vfsname", Name.get());
1975 
1976   auto OpenedS = (*OpenedF)->status();
1977   ASSERT_FALSE(OpenedS.getError());
1978   EXPECT_EQ("vfsname", OpenedS->getName());
1979   EXPECT_TRUE(OpenedS->IsVFSMapped);
1980   EXPECT_FALSE(OpenedS->ExposesExternalVFSPath);
1981 
1982   auto DirectS = FS->status("vfsname");
1983   ASSERT_FALSE(DirectS.getError());
1984   EXPECT_EQ("vfsname", DirectS->getName());
1985   EXPECT_TRUE(DirectS->IsVFSMapped);
1986   EXPECT_FALSE(DirectS->ExposesExternalVFSPath);
1987 
1988   EXPECT_EQ(0, NumDiagnostics);
1989 }
1990 
1991 TEST_F(VFSFromYAMLTest, CaseInsensitive) {
1992   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
1993   Lower->addRegularFile("//root/foo/bar/a");
1994   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
1995       "{ 'case-sensitive': 'false',\n"
1996       "  'roots': [\n"
1997       "{\n"
1998       "  'type': 'directory',\n"
1999       "  'name': '//root/',\n"
2000       "  'contents': [ {\n"
2001       "                  'type': 'file',\n"
2002       "                  'name': 'XX',\n"
2003       "                  'external-contents': '//root/foo/bar/a'\n"
2004       "                }\n"
2005       "              ]\n"
2006       "}]}",
2007       Lower);
2008   ASSERT_NE(FS.get(), nullptr);
2009 
2010   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
2011       new vfs::OverlayFileSystem(Lower));
2012   O->pushOverlay(FS);
2013 
2014   ErrorOr<vfs::Status> S = O->status("//root/XX");
2015   ASSERT_FALSE(S.getError());
2016 
2017   ErrorOr<vfs::Status> SS = O->status("//root/xx");
2018   ASSERT_FALSE(SS.getError());
2019   EXPECT_TRUE(S->equivalent(*SS));
2020   SS = O->status("//root/xX");
2021   EXPECT_TRUE(S->equivalent(*SS));
2022   SS = O->status("//root/Xx");
2023   EXPECT_TRUE(S->equivalent(*SS));
2024   EXPECT_EQ(0, NumDiagnostics);
2025 }
2026 
2027 TEST_F(VFSFromYAMLTest, CaseSensitive) {
2028   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2029   Lower->addRegularFile("//root/foo/bar/a");
2030   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2031       "{ 'case-sensitive': 'true',\n"
2032       "  'roots': [\n"
2033       "{\n"
2034       "  'type': 'directory',\n"
2035       "  'name': '//root/',\n"
2036       "  'contents': [ {\n"
2037       "                  'type': 'file',\n"
2038       "                  'name': 'XX',\n"
2039       "                  'external-contents': '//root/foo/bar/a'\n"
2040       "                }\n"
2041       "              ]\n"
2042       "}]}",
2043       Lower);
2044   ASSERT_NE(FS.get(), nullptr);
2045 
2046   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
2047       new vfs::OverlayFileSystem(Lower));
2048   O->pushOverlay(FS);
2049 
2050   ErrorOr<vfs::Status> SS = O->status("//root/xx");
2051   EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
2052   SS = O->status("//root/xX");
2053   EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
2054   SS = O->status("//root/Xx");
2055   EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
2056   EXPECT_EQ(0, NumDiagnostics);
2057 }
2058 
2059 TEST_F(VFSFromYAMLTest, IllegalVFSFile) {
2060   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2061 
2062   // invalid YAML at top-level
2063   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString("{]", Lower);
2064   EXPECT_EQ(nullptr, FS.get());
2065   // invalid YAML in roots
2066   FS = getFromYAMLString("{ 'roots':[}", Lower);
2067   // invalid YAML in directory
2068   FS = getFromYAMLString(
2069       "{ 'roots':[ { 'name': 'foo', 'type': 'directory', 'contents': [}",
2070       Lower);
2071   EXPECT_EQ(nullptr, FS.get());
2072 
2073   // invalid configuration
2074   FS = getFromYAMLString("{ 'knobular': 'true', 'roots':[] }", Lower);
2075   EXPECT_EQ(nullptr, FS.get());
2076   FS = getFromYAMLString("{ 'case-sensitive': 'maybe', 'roots':[] }", Lower);
2077   EXPECT_EQ(nullptr, FS.get());
2078 
2079   // invalid roots
2080   FS = getFromYAMLString("{ 'roots':'' }", Lower);
2081   EXPECT_EQ(nullptr, FS.get());
2082   FS = getFromYAMLString("{ 'roots':{} }", Lower);
2083   EXPECT_EQ(nullptr, FS.get());
2084 
2085   // invalid entries
2086   FS = getFromYAMLString(
2087       "{ 'roots':[ { 'type': 'other', 'name': 'me', 'contents': '' }", Lower);
2088   EXPECT_EQ(nullptr, FS.get());
2089   FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': [], "
2090                          "'external-contents': 'other' }",
2091                          Lower);
2092   EXPECT_EQ(nullptr, FS.get());
2093   FS = getFromYAMLString(
2094       "{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': [] }",
2095       Lower);
2096   EXPECT_EQ(nullptr, FS.get());
2097   FS = getFromYAMLString(
2098       "{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': {} }",
2099       Lower);
2100   EXPECT_EQ(nullptr, FS.get());
2101   FS = getFromYAMLString(
2102       "{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': {} }",
2103       Lower);
2104   EXPECT_EQ(nullptr, FS.get());
2105   FS = getFromYAMLString(
2106       "{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': '' }",
2107       Lower);
2108   EXPECT_EQ(nullptr, FS.get());
2109   FS = getFromYAMLString(
2110       "{ 'roots':[ { 'thingy': 'directory', 'name': 'me', 'contents': [] }",
2111       Lower);
2112   EXPECT_EQ(nullptr, FS.get());
2113 
2114   // missing mandatory fields
2115   FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': 'me' }", Lower);
2116   EXPECT_EQ(nullptr, FS.get());
2117   FS = getFromYAMLString(
2118       "{ 'roots':[ { 'type': 'file', 'external-contents': 'other' }", Lower);
2119   EXPECT_EQ(nullptr, FS.get());
2120   FS = getFromYAMLString("{ 'roots':[ { 'name': 'me', 'contents': [] }", Lower);
2121   EXPECT_EQ(nullptr, FS.get());
2122 
2123   // duplicate keys
2124   FS = getFromYAMLString("{ 'roots':[], 'roots':[] }", Lower);
2125   EXPECT_EQ(nullptr, FS.get());
2126   FS = getFromYAMLString(
2127       "{ 'case-sensitive':'true', 'case-sensitive':'true', 'roots':[] }",
2128       Lower);
2129   EXPECT_EQ(nullptr, FS.get());
2130   FS =
2131       getFromYAMLString("{ 'roots':[{'name':'me', 'name':'you', 'type':'file', "
2132                         "'external-contents':'blah' } ] }",
2133                         Lower);
2134   EXPECT_EQ(nullptr, FS.get());
2135 
2136   // missing version
2137   FS = getFromYAMLRawString("{ 'roots':[] }", Lower);
2138   EXPECT_EQ(nullptr, FS.get());
2139 
2140   // bad version number
2141   FS = getFromYAMLRawString("{ 'version':'foo', 'roots':[] }", Lower);
2142   EXPECT_EQ(nullptr, FS.get());
2143   FS = getFromYAMLRawString("{ 'version':-1, 'roots':[] }", Lower);
2144   EXPECT_EQ(nullptr, FS.get());
2145   FS = getFromYAMLRawString("{ 'version':100000, 'roots':[] }", Lower);
2146   EXPECT_EQ(nullptr, FS.get());
2147 
2148   // both 'external-contents' and 'contents' specified
2149   Lower->addDirectory("//root/external/dir");
2150   FS = getFromYAMLString(
2151       "{ 'roots':[ \n"
2152       "{ 'type': 'directory', 'name': '//root/A', 'contents': [],\n"
2153       "  'external-contents': '//root/external/dir'}]}",
2154       Lower);
2155   EXPECT_EQ(nullptr, FS.get());
2156 
2157   // 'directory-remap' with 'contents'
2158   FS = getFromYAMLString(
2159       "{ 'roots':[ \n"
2160       "{ 'type': 'directory-remap', 'name': '//root/A', 'contents': [] }]}",
2161       Lower);
2162   EXPECT_EQ(nullptr, FS.get());
2163 
2164   // invalid redirect kind
2165   FS = getFromYAMLString("{ 'redirecting-with': 'none', 'roots': [{\n"
2166                          "  'type': 'directory-remap',\n"
2167                          "  'name': '//root/A',\n"
2168                          "  'external-contents': '//root/B' }]}",
2169                          Lower);
2170   EXPECT_EQ(nullptr, FS.get());
2171 
2172   // redirect and fallthrough passed
2173   FS = getFromYAMLString("{ 'redirecting-with': 'fallthrough',\n"
2174                          "  'fallthrough': true,\n"
2175                          "  'roots': [{\n"
2176                          "    'type': 'directory-remap',\n"
2177                          "    'name': '//root/A',\n"
2178                          "    'external-contents': '//root/B' }]}",
2179                          Lower);
2180   EXPECT_EQ(nullptr, FS.get());
2181 
2182   EXPECT_EQ(28, NumDiagnostics);
2183 }
2184 
2185 TEST_F(VFSFromYAMLTest, UseExternalName) {
2186   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2187   Lower->addRegularFile("//root/external/file");
2188 
2189   IntrusiveRefCntPtr<vfs::FileSystem> FS =
2190       getFromYAMLString("{ 'roots': [\n"
2191                         "  { 'type': 'file', 'name': '//root/A',\n"
2192                         "    'external-contents': '//root/external/file'\n"
2193                         "  },\n"
2194                         "  { 'type': 'file', 'name': '//root/B',\n"
2195                         "    'use-external-name': true,\n"
2196                         "    'external-contents': '//root/external/file'\n"
2197                         "  },\n"
2198                         "  { 'type': 'file', 'name': '//root/C',\n"
2199                         "    'use-external-name': false,\n"
2200                         "    'external-contents': '//root/external/file'\n"
2201                         "  }\n"
2202                         "] }",
2203                         Lower);
2204   ASSERT_NE(nullptr, FS.get());
2205 
2206   // default true
2207   EXPECT_EQ("//root/external/file", FS->status("//root/A")->getName());
2208   // explicit
2209   EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
2210   EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
2211 
2212   // global configuration
2213   FS = getFromYAMLString("{ 'use-external-names': false,\n"
2214                          "  'roots': [\n"
2215                          "  { 'type': 'file', 'name': '//root/A',\n"
2216                          "    'external-contents': '//root/external/file'\n"
2217                          "  },\n"
2218                          "  { 'type': 'file', 'name': '//root/B',\n"
2219                          "    'use-external-name': true,\n"
2220                          "    'external-contents': '//root/external/file'\n"
2221                          "  },\n"
2222                          "  { 'type': 'file', 'name': '//root/C',\n"
2223                          "    'use-external-name': false,\n"
2224                          "    'external-contents': '//root/external/file'\n"
2225                          "  }\n"
2226                          "] }",
2227                          Lower);
2228   ASSERT_NE(nullptr, FS.get());
2229 
2230   // default
2231   EXPECT_EQ("//root/A", FS->status("//root/A")->getName());
2232   // explicit
2233   EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
2234   EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
2235 }
2236 
2237 TEST_F(VFSFromYAMLTest, MultiComponentPath) {
2238   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2239   Lower->addRegularFile("//root/other");
2240 
2241   // file in roots
2242   IntrusiveRefCntPtr<vfs::FileSystem> FS =
2243       getFromYAMLString("{ 'roots': [\n"
2244                         "  { 'type': 'file', 'name': '//root/path/to/file',\n"
2245                         "    'external-contents': '//root/other' }]\n"
2246                         "}",
2247                         Lower);
2248   ASSERT_NE(nullptr, FS.get());
2249   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
2250   EXPECT_FALSE(FS->status("//root/path/to").getError());
2251   EXPECT_FALSE(FS->status("//root/path").getError());
2252   EXPECT_FALSE(FS->status("//root/").getError());
2253 
2254   // at the start
2255   FS = getFromYAMLString(
2256       "{ 'roots': [\n"
2257       "  { 'type': 'directory', 'name': '//root/path/to',\n"
2258       "    'contents': [ { 'type': 'file', 'name': 'file',\n"
2259       "                    'external-contents': '//root/other' }]}]\n"
2260       "}",
2261       Lower);
2262   ASSERT_NE(nullptr, FS.get());
2263   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
2264   EXPECT_FALSE(FS->status("//root/path/to").getError());
2265   EXPECT_FALSE(FS->status("//root/path").getError());
2266   EXPECT_FALSE(FS->status("//root/").getError());
2267 
2268   // at the end
2269   FS = getFromYAMLString(
2270       "{ 'roots': [\n"
2271       "  { 'type': 'directory', 'name': '//root/',\n"
2272       "    'contents': [ { 'type': 'file', 'name': 'path/to/file',\n"
2273       "                    'external-contents': '//root/other' }]}]\n"
2274       "}",
2275       Lower);
2276   ASSERT_NE(nullptr, FS.get());
2277   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
2278   EXPECT_FALSE(FS->status("//root/path/to").getError());
2279   EXPECT_FALSE(FS->status("//root/path").getError());
2280   EXPECT_FALSE(FS->status("//root/").getError());
2281 }
2282 
2283 TEST_F(VFSFromYAMLTest, TrailingSlashes) {
2284   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2285   Lower->addRegularFile("//root/other");
2286 
2287   // file in roots
2288   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2289       "{ 'roots': [\n"
2290       "  { 'type': 'directory', 'name': '//root/path/to////',\n"
2291       "    'contents': [ { 'type': 'file', 'name': 'file',\n"
2292       "                    'external-contents': '//root/other' }]}]\n"
2293       "}",
2294       Lower);
2295   ASSERT_NE(nullptr, FS.get());
2296   EXPECT_FALSE(FS->status("//root/path/to/file").getError());
2297   EXPECT_FALSE(FS->status("//root/path/to").getError());
2298   EXPECT_FALSE(FS->status("//root/path").getError());
2299   EXPECT_FALSE(FS->status("//root/").getError());
2300 }
2301 
2302 TEST_F(VFSFromYAMLTest, DirectoryIteration) {
2303   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2304   Lower->addDirectory("//root/");
2305   Lower->addDirectory("//root/foo");
2306   Lower->addDirectory("//root/foo/bar");
2307   Lower->addRegularFile("//root/foo/bar/a");
2308   Lower->addRegularFile("//root/foo/bar/b");
2309   Lower->addRegularFile("//root/file3");
2310   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2311       "{ 'use-external-names': false,\n"
2312       "  'roots': [\n"
2313       "{\n"
2314       "  'type': 'directory',\n"
2315       "  'name': '//root/',\n"
2316       "  'contents': [ {\n"
2317       "                  'type': 'file',\n"
2318       "                  'name': 'file1',\n"
2319       "                  'external-contents': '//root/foo/bar/a'\n"
2320       "                },\n"
2321       "                {\n"
2322       "                  'type': 'file',\n"
2323       "                  'name': 'file2',\n"
2324       "                  'external-contents': '//root/foo/bar/b'\n"
2325       "                }\n"
2326       "              ]\n"
2327       "}\n"
2328       "]\n"
2329       "}",
2330       Lower);
2331   ASSERT_NE(FS.get(), nullptr);
2332 
2333   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
2334       new vfs::OverlayFileSystem(Lower));
2335   O->pushOverlay(FS);
2336 
2337   std::error_code EC;
2338   checkContents(O->dir_begin("//root/", EC),
2339                 {"//root/file1", "//root/file2", "//root/file3", "//root/foo"});
2340 
2341   checkContents(O->dir_begin("//root/foo/bar", EC),
2342                 {"//root/foo/bar/a", "//root/foo/bar/b"});
2343 }
2344 
2345 TEST_F(VFSFromYAMLTest, DirectoryIterationSameDirMultipleEntries) {
2346   // https://llvm.org/bugs/show_bug.cgi?id=27725
2347   if (!supportsSameDirMultipleYAMLEntries())
2348     GTEST_SKIP();
2349 
2350   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2351   Lower->addDirectory("//root/zab");
2352   Lower->addDirectory("//root/baz");
2353   Lower->addRegularFile("//root/zab/a");
2354   Lower->addRegularFile("//root/zab/b");
2355   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2356       "{ 'use-external-names': false,\n"
2357       "  'roots': [\n"
2358       "{\n"
2359       "  'type': 'directory',\n"
2360       "  'name': '//root/baz/',\n"
2361       "  'contents': [ {\n"
2362       "                  'type': 'file',\n"
2363       "                  'name': 'x',\n"
2364       "                  'external-contents': '//root/zab/a'\n"
2365       "                }\n"
2366       "              ]\n"
2367       "},\n"
2368       "{\n"
2369       "  'type': 'directory',\n"
2370       "  'name': '//root/baz/',\n"
2371       "  'contents': [ {\n"
2372       "                  'type': 'file',\n"
2373       "                  'name': 'y',\n"
2374       "                  'external-contents': '//root/zab/b'\n"
2375       "                }\n"
2376       "              ]\n"
2377       "}\n"
2378       "]\n"
2379       "}",
2380       Lower);
2381   ASSERT_NE(FS.get(), nullptr);
2382 
2383   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
2384       new vfs::OverlayFileSystem(Lower));
2385   O->pushOverlay(FS);
2386 
2387   std::error_code EC;
2388 
2389   checkContents(O->dir_begin("//root/baz/", EC),
2390                 {"//root/baz/x", "//root/baz/y"});
2391 }
2392 
2393 TEST_F(VFSFromYAMLTest, RecursiveDirectoryIterationLevel) {
2394 
2395   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2396   Lower->addDirectory("//root/a");
2397   Lower->addDirectory("//root/a/b");
2398   Lower->addDirectory("//root/a/b/c");
2399   Lower->addRegularFile("//root/a/b/c/file");
2400   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2401       "{ 'use-external-names': false,\n"
2402       "  'roots': [\n"
2403       "{\n"
2404       "  'type': 'directory',\n"
2405       "  'name': '//root/a/b/c/',\n"
2406       "  'contents': [ {\n"
2407       "                  'type': 'file',\n"
2408       "                  'name': 'file',\n"
2409       "                  'external-contents': '//root/a/b/c/file'\n"
2410       "                }\n"
2411       "              ]\n"
2412       "},\n"
2413       "]\n"
2414       "}",
2415       Lower);
2416   ASSERT_NE(FS.get(), nullptr);
2417 
2418   IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
2419       new vfs::OverlayFileSystem(Lower));
2420   O->pushOverlay(FS);
2421 
2422   std::error_code EC;
2423 
2424   // Test recursive_directory_iterator level()
2425   vfs::recursive_directory_iterator I = vfs::recursive_directory_iterator(
2426                                         *O, "//root", EC),
2427                                     E;
2428   ASSERT_FALSE(EC);
2429   for (int l = 0; I != E; I.increment(EC), ++l) {
2430     ASSERT_FALSE(EC);
2431     EXPECT_EQ(I.level(), l);
2432   }
2433   EXPECT_EQ(I, E);
2434 }
2435 
2436 TEST_F(VFSFromYAMLTest, RelativePaths) {
2437   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2438   std::error_code EC;
2439   SmallString<128> CWD;
2440   EC = llvm::sys::fs::current_path(CWD);
2441   ASSERT_FALSE(EC);
2442 
2443   // Filename at root level without a parent directory.
2444   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2445       "{ 'roots': [\n"
2446       "  { 'type': 'file', 'name': 'file-not-in-directory.h',\n"
2447       "    'external-contents': '//root/external/file'\n"
2448       "  }\n"
2449       "] }",
2450       Lower);
2451   ASSERT_TRUE(FS.get() != nullptr);
2452   SmallString<128> ExpectedPathNotInDir("file-not-in-directory.h");
2453   llvm::sys::fs::make_absolute(ExpectedPathNotInDir);
2454   checkContents(FS->dir_begin(CWD, EC), {ExpectedPathNotInDir});
2455 
2456   // Relative file path.
2457   FS = getFromYAMLString("{ 'roots': [\n"
2458                          "  { 'type': 'file', 'name': 'relative/path.h',\n"
2459                          "    'external-contents': '//root/external/file'\n"
2460                          "  }\n"
2461                          "] }",
2462                          Lower);
2463   ASSERT_TRUE(FS.get() != nullptr);
2464   SmallString<128> Parent("relative");
2465   llvm::sys::fs::make_absolute(Parent);
2466   auto I = FS->dir_begin(Parent, EC);
2467   ASSERT_FALSE(EC);
2468   // Convert to POSIX path for comparison of windows paths
2469   ASSERT_EQ("relative/path.h",
2470             getPosixPath(std::string(I->path().substr(CWD.size() + 1))));
2471 
2472   // Relative directory path.
2473   FS = getFromYAMLString(
2474       "{ 'roots': [\n"
2475       "  { 'type': 'directory', 'name': 'relative/directory/path.h',\n"
2476       "    'contents': []\n"
2477       "  }\n"
2478       "] }",
2479       Lower);
2480   ASSERT_TRUE(FS.get() != nullptr);
2481   SmallString<128> Root("relative/directory");
2482   llvm::sys::fs::make_absolute(Root);
2483   I = FS->dir_begin(Root, EC);
2484   ASSERT_FALSE(EC);
2485   ASSERT_EQ("path.h", std::string(I->path().substr(Root.size() + 1)));
2486 
2487   EXPECT_EQ(0, NumDiagnostics);
2488 }
2489 
2490 TEST_F(VFSFromYAMLTest, NonFallthroughDirectoryIteration) {
2491   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2492   Lower->addDirectory("//root/");
2493   Lower->addRegularFile("//root/a");
2494   Lower->addRegularFile("//root/b");
2495   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2496       "{ 'use-external-names': false,\n"
2497       "  'fallthrough': false,\n"
2498       "  'roots': [\n"
2499       "{\n"
2500       "  'type': 'directory',\n"
2501       "  'name': '//root/',\n"
2502       "  'contents': [ {\n"
2503       "                  'type': 'file',\n"
2504       "                  'name': 'c',\n"
2505       "                  'external-contents': '//root/a'\n"
2506       "                }\n"
2507       "              ]\n"
2508       "}\n"
2509       "]\n"
2510       "}",
2511       Lower);
2512   ASSERT_NE(FS.get(), nullptr);
2513 
2514   std::error_code EC;
2515   checkContents(FS->dir_begin("//root/", EC),
2516                 {"//root/c"});
2517 }
2518 
2519 TEST_F(VFSFromYAMLTest, DirectoryIterationWithDuplicates) {
2520   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2521   Lower->addDirectory("//root/");
2522   Lower->addRegularFile("//root/a");
2523   Lower->addRegularFile("//root/b");
2524   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2525       "{ 'use-external-names': false,\n"
2526       "  'roots': [\n"
2527       "{\n"
2528       "  'type': 'directory',\n"
2529       "  'name': '//root/',\n"
2530       "  'contents': [ {\n"
2531       "                  'type': 'file',\n"
2532       "                  'name': 'a',\n"
2533       "                  'external-contents': '//root/a'\n"
2534       "                }\n"
2535       "              ]\n"
2536       "}\n"
2537       "]\n"
2538       "}",
2539 	  Lower);
2540   ASSERT_NE(FS.get(), nullptr);
2541 
2542   std::error_code EC;
2543   checkContents(FS->dir_begin("//root/", EC),
2544                 {"//root/a", "//root/b"});
2545 }
2546 
2547 TEST_F(VFSFromYAMLTest, DirectoryIterationErrorInVFSLayer) {
2548   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2549   Lower->addDirectory("//root/");
2550   Lower->addDirectory("//root/foo");
2551   Lower->addRegularFile("//root/foo/a");
2552   Lower->addRegularFile("//root/foo/b");
2553   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2554       "{ 'use-external-names': false,\n"
2555       "  'roots': [\n"
2556       "{\n"
2557       "  'type': 'directory',\n"
2558       "  'name': '//root/',\n"
2559       "  'contents': [ {\n"
2560       "                  'type': 'file',\n"
2561       "                  'name': 'bar/a',\n"
2562       "                  'external-contents': '//root/foo/a'\n"
2563       "                }\n"
2564       "              ]\n"
2565       "}\n"
2566       "]\n"
2567       "}",
2568       Lower);
2569   ASSERT_NE(FS.get(), nullptr);
2570 
2571   std::error_code EC;
2572   checkContents(FS->dir_begin("//root/foo", EC),
2573                 {"//root/foo/a", "//root/foo/b"});
2574 }
2575 
2576 TEST_F(VFSFromYAMLTest, GetRealPath) {
2577   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2578   Lower->addDirectory("//dir/");
2579   Lower->addRegularFile("/foo");
2580   Lower->addSymlink("/link");
2581   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2582       "{ 'use-external-names': false,\n"
2583       "  'case-sensitive': false,\n"
2584       "  'roots': [\n"
2585       "{\n"
2586       "  'type': 'directory',\n"
2587       "  'name': '//root/',\n"
2588       "  'contents': [ {\n"
2589       "                  'type': 'file',\n"
2590       "                  'name': 'bar',\n"
2591       "                  'external-contents': '/link'\n"
2592       "                },\n"
2593       "                {\n"
2594       "                  'type': 'directory',\n"
2595       "                  'name': 'baz',\n"
2596       "                  'contents': []\n"
2597       "                }\n"
2598       "              ]\n"
2599       "},\n"
2600       "{\n"
2601       "  'type': 'directory',\n"
2602       "  'name': '//dir/',\n"
2603       "  'contents': []\n"
2604       "}\n"
2605       "]\n"
2606       "}",
2607       Lower);
2608   ASSERT_NE(FS.get(), nullptr);
2609 
2610   // Regular file present in underlying file system.
2611   SmallString<16> RealPath;
2612   EXPECT_FALSE(FS->getRealPath("/foo", RealPath));
2613   EXPECT_EQ(RealPath.str(), "/foo");
2614 
2615   // File present in YAML pointing to symlink in underlying file system.
2616   EXPECT_FALSE(FS->getRealPath("//root/bar", RealPath));
2617   EXPECT_EQ(RealPath.str(), "/symlink");
2618 
2619   // Directories should return the virtual path as written in the definition.
2620   EXPECT_FALSE(FS->getRealPath("//ROOT/baz", RealPath));
2621   EXPECT_EQ(RealPath.str(), "//root/baz");
2622 
2623   // Try a non-existing file.
2624   EXPECT_EQ(FS->getRealPath("/non_existing", RealPath),
2625             errc::no_such_file_or_directory);
2626 }
2627 
2628 TEST_F(VFSFromYAMLTest, WorkingDirectory) {
2629   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2630   Lower->addDirectory("//root/");
2631   Lower->addDirectory("//root/foo");
2632   Lower->addRegularFile("//root/foo/a");
2633   Lower->addRegularFile("//root/foo/b");
2634   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2635       "{ 'use-external-names': false,\n"
2636       "  'roots': [\n"
2637       "{\n"
2638       "  'type': 'directory',\n"
2639       "  'name': '//root/bar',\n"
2640       "  'contents': [ {\n"
2641       "                  'type': 'file',\n"
2642       "                  'name': 'a',\n"
2643       "                  'external-contents': '//root/foo/a'\n"
2644       "                }\n"
2645       "              ]\n"
2646       "}\n"
2647       "]\n"
2648       "}",
2649       Lower);
2650   ASSERT_NE(FS.get(), nullptr);
2651   std::error_code EC = FS->setCurrentWorkingDirectory("//root/bar");
2652   ASSERT_FALSE(EC);
2653 
2654   llvm::ErrorOr<std::string> WorkingDir = FS->getCurrentWorkingDirectory();
2655   ASSERT_TRUE(WorkingDir);
2656   EXPECT_EQ(*WorkingDir, "//root/bar");
2657 
2658   llvm::ErrorOr<vfs::Status> Status = FS->status("./a");
2659   ASSERT_FALSE(Status.getError());
2660   EXPECT_TRUE(Status->isStatusKnown());
2661   EXPECT_FALSE(Status->isDirectory());
2662   EXPECT_TRUE(Status->isRegularFile());
2663   EXPECT_FALSE(Status->isSymlink());
2664   EXPECT_FALSE(Status->isOther());
2665   EXPECT_TRUE(Status->exists());
2666 
2667   EC = FS->setCurrentWorkingDirectory("bogus");
2668   ASSERT_TRUE(EC);
2669   WorkingDir = FS->getCurrentWorkingDirectory();
2670   ASSERT_TRUE(WorkingDir);
2671   EXPECT_EQ(*WorkingDir, "//root/bar");
2672 
2673   EC = FS->setCurrentWorkingDirectory("//root/");
2674   ASSERT_FALSE(EC);
2675   WorkingDir = FS->getCurrentWorkingDirectory();
2676   ASSERT_TRUE(WorkingDir);
2677   EXPECT_EQ(*WorkingDir, "//root/");
2678 
2679   EC = FS->setCurrentWorkingDirectory("bar");
2680   ASSERT_FALSE(EC);
2681   WorkingDir = FS->getCurrentWorkingDirectory();
2682   ASSERT_TRUE(WorkingDir);
2683   EXPECT_EQ(*WorkingDir, "//root/bar");
2684 }
2685 
2686 TEST_F(VFSFromYAMLTest, WorkingDirectoryFallthrough) {
2687   IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
2688   Lower->addDirectory("//root/");
2689   Lower->addDirectory("//root/foo");
2690   Lower->addRegularFile("//root/foo/a");
2691   Lower->addRegularFile("//root/foo/b");
2692   Lower->addRegularFile("//root/c");
2693   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2694       "{ 'use-external-names': false,\n"
2695       "  'roots': [\n"
2696       "{\n"
2697       "  'type': 'directory',\n"
2698       "  'name': '//root/bar',\n"
2699       "  'contents': [ {\n"
2700       "                  'type': 'file',\n"
2701       "                  'name': 'a',\n"
2702       "                  'external-contents': '//root/foo/a'\n"
2703       "                }\n"
2704       "              ]\n"
2705       "},\n"
2706       "{\n"
2707       "  'type': 'directory',\n"
2708       "  'name': '//root/bar/baz',\n"
2709       "  'contents': [ {\n"
2710       "                  'type': 'file',\n"
2711       "                  'name': 'a',\n"
2712       "                  'external-contents': '//root/foo/a'\n"
2713       "                }\n"
2714       "              ]\n"
2715       "}\n"
2716       "]\n"
2717       "}",
2718       Lower);
2719   ASSERT_NE(FS.get(), nullptr);
2720   std::error_code EC = FS->setCurrentWorkingDirectory("//root/");
2721   ASSERT_FALSE(EC);
2722   ASSERT_NE(FS.get(), nullptr);
2723 
2724   llvm::ErrorOr<vfs::Status> Status = FS->status("bar/a");
2725   ASSERT_FALSE(Status.getError());
2726   EXPECT_TRUE(Status->exists());
2727 
2728   Status = FS->status("foo/a");
2729   ASSERT_FALSE(Status.getError());
2730   EXPECT_TRUE(Status->exists());
2731 
2732   EC = FS->setCurrentWorkingDirectory("//root/bar");
2733   ASSERT_FALSE(EC);
2734 
2735   Status = FS->status("./a");
2736   ASSERT_FALSE(Status.getError());
2737   EXPECT_TRUE(Status->exists());
2738 
2739   Status = FS->status("./b");
2740   ASSERT_TRUE(Status.getError());
2741 
2742   Status = FS->status("./c");
2743   ASSERT_TRUE(Status.getError());
2744 
2745   EC = FS->setCurrentWorkingDirectory("//root/");
2746   ASSERT_FALSE(EC);
2747 
2748   Status = FS->status("c");
2749   ASSERT_FALSE(Status.getError());
2750   EXPECT_TRUE(Status->exists());
2751 
2752   Status = FS->status("./bar/baz/a");
2753   ASSERT_FALSE(Status.getError());
2754   EXPECT_TRUE(Status->exists());
2755 
2756   EC = FS->setCurrentWorkingDirectory("//root/bar");
2757   ASSERT_FALSE(EC);
2758 
2759   Status = FS->status("./baz/a");
2760   ASSERT_FALSE(Status.getError());
2761   EXPECT_TRUE(Status->exists());
2762 
2763   Status = FS->status("../bar/baz/a");
2764   ASSERT_FALSE(Status.getError());
2765   EXPECT_TRUE(Status->exists());
2766 }
2767 
2768 TEST_F(VFSFromYAMLTest, WorkingDirectoryFallthroughInvalid) {
2769   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
2770   Lower->addDirectory("//root/");
2771   Lower->addDirectory("//root/foo");
2772   Lower->addRegularFile("//root/foo/a");
2773   Lower->addRegularFile("//root/foo/b");
2774   Lower->addRegularFile("//root/c");
2775   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2776       "{ 'use-external-names': false,\n"
2777       "  'roots': [\n"
2778       "{\n"
2779       "  'type': 'directory',\n"
2780       "  'name': '//root/bar',\n"
2781       "  'contents': [ {\n"
2782       "                  'type': 'file',\n"
2783       "                  'name': 'a',\n"
2784       "                  'external-contents': '//root/foo/a'\n"
2785       "                }\n"
2786       "              ]\n"
2787       "}\n"
2788       "]\n"
2789       "}",
2790       Lower);
2791   ASSERT_NE(FS.get(), nullptr);
2792   std::error_code EC = FS->setCurrentWorkingDirectory("//root/");
2793   ASSERT_FALSE(EC);
2794   ASSERT_NE(FS.get(), nullptr);
2795 
2796   llvm::ErrorOr<vfs::Status> Status = FS->status("bar/a");
2797   ASSERT_FALSE(Status.getError());
2798   EXPECT_TRUE(Status->exists());
2799 
2800   Status = FS->status("foo/a");
2801   ASSERT_FALSE(Status.getError());
2802   EXPECT_TRUE(Status->exists());
2803 }
2804 
2805 TEST_F(VFSFromYAMLTest, VirtualWorkingDirectory) {
2806   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
2807   Lower->addDirectory("//root/");
2808   Lower->addDirectory("//root/foo");
2809   Lower->addRegularFile("//root/foo/a");
2810   Lower->addRegularFile("//root/foo/b");
2811   Lower->addRegularFile("//root/c");
2812   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
2813       "{ 'use-external-names': false,\n"
2814       "  'roots': [\n"
2815       "{\n"
2816       "  'type': 'directory',\n"
2817       "  'name': '//root/bar',\n"
2818       "  'contents': [ {\n"
2819       "                  'type': 'file',\n"
2820       "                  'name': 'a',\n"
2821       "                  'external-contents': '//root/foo/a'\n"
2822       "                }\n"
2823       "              ]\n"
2824       "}\n"
2825       "]\n"
2826       "}",
2827       Lower);
2828   ASSERT_NE(FS.get(), nullptr);
2829   std::error_code EC = FS->setCurrentWorkingDirectory("//root/bar");
2830   ASSERT_FALSE(EC);
2831   ASSERT_NE(FS.get(), nullptr);
2832 
2833   llvm::ErrorOr<vfs::Status> Status = FS->status("a");
2834   ASSERT_FALSE(Status.getError());
2835   EXPECT_TRUE(Status->exists());
2836 }
2837 
2838 TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest) {
2839   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
2840   TempDir _a(TestDirectory.path("a"));
2841   TempFile _ab(TestDirectory.path("a, b"));
2842   TempDir _c(TestDirectory.path("c"));
2843   TempFile _cd(TestDirectory.path("c/d"));
2844   TempDir _e(TestDirectory.path("e"));
2845   TempDir _ef(TestDirectory.path("e/f"));
2846   TempFile _g(TestDirectory.path("g"));
2847   TempDir _h(TestDirectory.path("h"));
2848 
2849   vfs::YAMLVFSWriter VFSWriter;
2850   VFSWriter.addDirectoryMapping(_a.path(), "//root/a");
2851   VFSWriter.addFileMapping(_ab.path(), "//root/a/b");
2852   VFSWriter.addFileMapping(_cd.path(), "//root/c/d");
2853   VFSWriter.addDirectoryMapping(_e.path(), "//root/e");
2854   VFSWriter.addDirectoryMapping(_ef.path(), "//root/e/f");
2855   VFSWriter.addFileMapping(_g.path(), "//root/g");
2856   VFSWriter.addDirectoryMapping(_h.path(), "//root/h");
2857 
2858   std::string Buffer;
2859   raw_string_ostream OS(Buffer);
2860   VFSWriter.write(OS);
2861   OS.flush();
2862 
2863   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
2864   Lower->addDirectory("//root/");
2865   Lower->addDirectory("//root/a");
2866   Lower->addRegularFile("//root/a/b");
2867   Lower->addDirectory("//root/b");
2868   Lower->addDirectory("//root/c");
2869   Lower->addRegularFile("//root/c/d");
2870   Lower->addDirectory("//root/e");
2871   Lower->addDirectory("//root/e/f");
2872   Lower->addRegularFile("//root/g");
2873   Lower->addDirectory("//root/h");
2874 
2875   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
2876   ASSERT_NE(FS.get(), nullptr);
2877 
2878   EXPECT_TRUE(FS->exists(_a.path()));
2879   EXPECT_TRUE(FS->exists(_ab.path()));
2880   EXPECT_TRUE(FS->exists(_c.path()));
2881   EXPECT_TRUE(FS->exists(_cd.path()));
2882   EXPECT_TRUE(FS->exists(_e.path()));
2883   EXPECT_TRUE(FS->exists(_ef.path()));
2884   EXPECT_TRUE(FS->exists(_g.path()));
2885   EXPECT_TRUE(FS->exists(_h.path()));
2886 }
2887 
2888 TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest2) {
2889   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
2890   TempDir _a(TestDirectory.path("a"));
2891   TempFile _ab(TestDirectory.path("a/b"));
2892   TempDir _ac(TestDirectory.path("a/c"));
2893   TempFile _acd(TestDirectory.path("a/c/d"));
2894   TempFile _ace(TestDirectory.path("a/c/e"));
2895   TempFile _acf(TestDirectory.path("a/c/f"));
2896   TempDir _ag(TestDirectory.path("a/g"));
2897   TempFile _agh(TestDirectory.path("a/g/h"));
2898 
2899   vfs::YAMLVFSWriter VFSWriter;
2900   VFSWriter.addDirectoryMapping(_a.path(), "//root/a");
2901   VFSWriter.addFileMapping(_ab.path(), "//root/a/b");
2902   VFSWriter.addDirectoryMapping(_ac.path(), "//root/a/c");
2903   VFSWriter.addFileMapping(_acd.path(), "//root/a/c/d");
2904   VFSWriter.addFileMapping(_ace.path(), "//root/a/c/e");
2905   VFSWriter.addFileMapping(_acf.path(), "//root/a/c/f");
2906   VFSWriter.addDirectoryMapping(_ag.path(), "//root/a/g");
2907   VFSWriter.addFileMapping(_agh.path(), "//root/a/g/h");
2908 
2909   std::string Buffer;
2910   raw_string_ostream OS(Buffer);
2911   VFSWriter.write(OS);
2912   OS.flush();
2913 
2914   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
2915   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
2916   EXPECT_NE(FS.get(), nullptr);
2917 }
2918 
2919 TEST_F(VFSFromYAMLTest, YAMLVFSWriterTest3) {
2920   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
2921   TempDir _a(TestDirectory.path("a"));
2922   TempFile _ab(TestDirectory.path("a/b"));
2923   TempDir _ac(TestDirectory.path("a/c"));
2924   TempDir _acd(TestDirectory.path("a/c/d"));
2925   TempDir _acde(TestDirectory.path("a/c/d/e"));
2926   TempFile _acdef(TestDirectory.path("a/c/d/e/f"));
2927   TempFile _acdeg(TestDirectory.path("a/c/d/e/g"));
2928   TempDir _ah(TestDirectory.path("a/h"));
2929   TempFile _ahi(TestDirectory.path("a/h/i"));
2930 
2931   vfs::YAMLVFSWriter VFSWriter;
2932   VFSWriter.addDirectoryMapping(_a.path(), "//root/a");
2933   VFSWriter.addFileMapping(_ab.path(), "//root/a/b");
2934   VFSWriter.addDirectoryMapping(_ac.path(), "//root/a/c");
2935   VFSWriter.addDirectoryMapping(_acd.path(), "//root/a/c/d");
2936   VFSWriter.addDirectoryMapping(_acde.path(), "//root/a/c/d/e");
2937   VFSWriter.addFileMapping(_acdef.path(), "//root/a/c/d/e/f");
2938   VFSWriter.addFileMapping(_acdeg.path(), "//root/a/c/d/e/g");
2939   VFSWriter.addDirectoryMapping(_ahi.path(), "//root/a/h");
2940   VFSWriter.addFileMapping(_ahi.path(), "//root/a/h/i");
2941 
2942   std::string Buffer;
2943   raw_string_ostream OS(Buffer);
2944   VFSWriter.write(OS);
2945   OS.flush();
2946 
2947   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
2948   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
2949   EXPECT_NE(FS.get(), nullptr);
2950 }
2951 
2952 TEST_F(VFSFromYAMLTest, YAMLVFSWriterTestHandleDirs) {
2953   TempDir TestDirectory("virtual-file-system-test", /*Unique*/ true);
2954   TempDir _a(TestDirectory.path("a"));
2955   TempDir _b(TestDirectory.path("b"));
2956   TempDir _c(TestDirectory.path("c"));
2957 
2958   vfs::YAMLVFSWriter VFSWriter;
2959   VFSWriter.addDirectoryMapping(_a.path(), "//root/a");
2960   VFSWriter.addDirectoryMapping(_b.path(), "//root/b");
2961   VFSWriter.addDirectoryMapping(_c.path(), "//root/c");
2962 
2963   std::string Buffer;
2964   raw_string_ostream OS(Buffer);
2965   VFSWriter.write(OS);
2966   OS.flush();
2967 
2968   // We didn't add a single file - only directories.
2969   EXPECT_EQ(Buffer.find("'type': 'file'"), std::string::npos);
2970 
2971   IntrusiveRefCntPtr<ErrorDummyFileSystem> Lower(new ErrorDummyFileSystem());
2972   Lower->addDirectory("//root/a");
2973   Lower->addDirectory("//root/b");
2974   Lower->addDirectory("//root/c");
2975   // canaries
2976   Lower->addRegularFile("//root/a/a");
2977   Lower->addRegularFile("//root/b/b");
2978   Lower->addRegularFile("//root/c/c");
2979 
2980   IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLRawString(Buffer, Lower);
2981   ASSERT_NE(FS.get(), nullptr);
2982 
2983   EXPECT_FALSE(FS->exists(_a.path("a")));
2984   EXPECT_FALSE(FS->exists(_b.path("b")));
2985   EXPECT_FALSE(FS->exists(_c.path("c")));
2986 }
2987 
2988 TEST_F(VFSFromYAMLTest, RedirectingWith) {
2989   IntrusiveRefCntPtr<DummyFileSystem> Both(new DummyFileSystem());
2990   Both->addDirectory("//root/a");
2991   Both->addRegularFile("//root/a/f");
2992   Both->addDirectory("//root/b");
2993   Both->addRegularFile("//root/b/f");
2994 
2995   IntrusiveRefCntPtr<DummyFileSystem> AOnly(new DummyFileSystem());
2996   AOnly->addDirectory("//root/a");
2997   AOnly->addRegularFile("//root/a/f");
2998 
2999   IntrusiveRefCntPtr<DummyFileSystem> BOnly(new DummyFileSystem());
3000   BOnly->addDirectory("//root/b");
3001   BOnly->addRegularFile("//root/b/f");
3002 
3003   auto BaseStr = std::string("  'roots': [\n"
3004                              "    {\n"
3005                              "      'type': 'directory-remap',\n"
3006                              "      'name': '//root/a',\n"
3007                              "      'external-contents': '//root/b'\n"
3008                              "    }\n"
3009                              "  ]\n"
3010                              "}");
3011   auto FallthroughStr = "{ 'redirecting-with': 'fallthrough',\n" + BaseStr;
3012   auto FallbackStr = "{ 'redirecting-with': 'fallback',\n" + BaseStr;
3013   auto RedirectOnlyStr = "{ 'redirecting-with': 'redirect-only',\n" + BaseStr;
3014 
3015   auto ExpectPath = [&](vfs::FileSystem &FS, StringRef Expected,
3016                         StringRef Message) {
3017     auto AF = FS.openFileForRead("//root/a/f");
3018     ASSERT_FALSE(AF.getError()) << Message;
3019     auto AFName = (*AF)->getName();
3020     ASSERT_FALSE(AFName.getError()) << Message;
3021     EXPECT_EQ(Expected.str(), AFName.get()) << Message;
3022 
3023     auto AS = FS.status("//root/a/f");
3024     ASSERT_FALSE(AS.getError()) << Message;
3025     EXPECT_EQ(Expected.str(), AS->getName()) << Message;
3026   };
3027 
3028   auto ExpectFailure = [&](vfs::FileSystem &FS, StringRef Message) {
3029     EXPECT_TRUE(FS.openFileForRead("//root/a/f").getError()) << Message;
3030     EXPECT_TRUE(FS.status("//root/a/f").getError()) << Message;
3031   };
3032 
3033   {
3034     // `f` in both `a` and `b`
3035 
3036     // `fallthrough` tries `external-name` first, so should be `b`
3037     IntrusiveRefCntPtr<vfs::FileSystem> Fallthrough =
3038         getFromYAMLString(FallthroughStr, Both);
3039     ASSERT_TRUE(Fallthrough.get() != nullptr);
3040     ExpectPath(*Fallthrough, "//root/b/f", "fallthrough, both exist");
3041 
3042     // `fallback` tries the original name first, so should be `a`
3043     IntrusiveRefCntPtr<vfs::FileSystem> Fallback =
3044         getFromYAMLString(FallbackStr, Both);
3045     ASSERT_TRUE(Fallback.get() != nullptr);
3046     ExpectPath(*Fallback, "//root/a/f", "fallback, both exist");
3047 
3048     // `redirect-only` is the same as `fallthrough` but doesn't try the
3049     // original on failure, so no change here (ie. `b`)
3050     IntrusiveRefCntPtr<vfs::FileSystem> Redirect =
3051         getFromYAMLString(RedirectOnlyStr, Both);
3052     ASSERT_TRUE(Redirect.get() != nullptr);
3053     ExpectPath(*Redirect, "//root/b/f", "redirect-only, both exist");
3054   }
3055 
3056   {
3057     // `f` in `a` only
3058 
3059     // Fallthrough to the original path, `a`
3060     IntrusiveRefCntPtr<vfs::FileSystem> Fallthrough =
3061         getFromYAMLString(FallthroughStr, AOnly);
3062     ASSERT_TRUE(Fallthrough.get() != nullptr);
3063     ExpectPath(*Fallthrough, "//root/a/f", "fallthrough, a only");
3064 
3065     // Original first, so still `a`
3066     IntrusiveRefCntPtr<vfs::FileSystem> Fallback =
3067         getFromYAMLString(FallbackStr, AOnly);
3068     ASSERT_TRUE(Fallback.get() != nullptr);
3069     ExpectPath(*Fallback, "//root/a/f", "fallback, a only");
3070 
3071     // Fails since no fallthrough
3072     IntrusiveRefCntPtr<vfs::FileSystem> Redirect =
3073         getFromYAMLString(RedirectOnlyStr, AOnly);
3074     ASSERT_TRUE(Redirect.get() != nullptr);
3075     ExpectFailure(*Redirect, "redirect-only, a only");
3076   }
3077 
3078   {
3079     // `f` in `b` only
3080 
3081     // Tries `b` first (no fallthrough)
3082     IntrusiveRefCntPtr<vfs::FileSystem> Fallthrough =
3083         getFromYAMLString(FallthroughStr, BOnly);
3084     ASSERT_TRUE(Fallthrough.get() != nullptr);
3085     ExpectPath(*Fallthrough, "//root/b/f", "fallthrough, b only");
3086 
3087     // Tries original first but then fallsback to `b`
3088     IntrusiveRefCntPtr<vfs::FileSystem> Fallback =
3089         getFromYAMLString(FallbackStr, BOnly);
3090     ASSERT_TRUE(Fallback.get() != nullptr);
3091     ExpectPath(*Fallback, "//root/b/f", "fallback, b only");
3092 
3093     // Redirect exists, so uses it (`b`)
3094     IntrusiveRefCntPtr<vfs::FileSystem> Redirect =
3095         getFromYAMLString(RedirectOnlyStr, BOnly);
3096     ASSERT_TRUE(Redirect.get() != nullptr);
3097     ExpectPath(*Redirect, "//root/b/f", "redirect-only, b only");
3098   }
3099 
3100   EXPECT_EQ(0, NumDiagnostics);
3101 }
3102 
3103 TEST(VFSFromRemappedFilesTest, Basic) {
3104   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> BaseFS =
3105       new vfs::InMemoryFileSystem;
3106   BaseFS->addFile("//root/b", 0, MemoryBuffer::getMemBuffer("contents of b"));
3107   BaseFS->addFile("//root/c", 0, MemoryBuffer::getMemBuffer("contents of c"));
3108 
3109   std::vector<std::pair<std::string, std::string>> RemappedFiles = {
3110       {"//root/a/a", "//root/b"},
3111       {"//root/a/b/c", "//root/c"},
3112   };
3113   auto RemappedFS = vfs::RedirectingFileSystem::create(
3114       RemappedFiles, /*UseExternalNames=*/false, *BaseFS);
3115 
3116   auto StatA = RemappedFS->status("//root/a/a");
3117   auto StatB = RemappedFS->status("//root/a/b/c");
3118   ASSERT_TRUE(StatA);
3119   ASSERT_TRUE(StatB);
3120   EXPECT_EQ("//root/a/a", StatA->getName());
3121   EXPECT_EQ("//root/a/b/c", StatB->getName());
3122 
3123   auto BufferA = RemappedFS->getBufferForFile("//root/a/a");
3124   auto BufferB = RemappedFS->getBufferForFile("//root/a/b/c");
3125   ASSERT_TRUE(BufferA);
3126   ASSERT_TRUE(BufferB);
3127   EXPECT_EQ("contents of b", (*BufferA)->getBuffer());
3128   EXPECT_EQ("contents of c", (*BufferB)->getBuffer());
3129 }
3130 
3131 TEST(VFSFromRemappedFilesTest, UseExternalNames) {
3132   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> BaseFS =
3133       new vfs::InMemoryFileSystem;
3134   BaseFS->addFile("//root/b", 0, MemoryBuffer::getMemBuffer("contents of b"));
3135   BaseFS->addFile("//root/c", 0, MemoryBuffer::getMemBuffer("contents of c"));
3136 
3137   std::vector<std::pair<std::string, std::string>> RemappedFiles = {
3138       {"//root/a/a", "//root/b"},
3139       {"//root/a/b/c", "//root/c"},
3140   };
3141   auto RemappedFS = vfs::RedirectingFileSystem::create(
3142       RemappedFiles, /*UseExternalNames=*/true, *BaseFS);
3143 
3144   auto StatA = RemappedFS->status("//root/a/a");
3145   auto StatB = RemappedFS->status("//root/a/b/c");
3146   ASSERT_TRUE(StatA);
3147   ASSERT_TRUE(StatB);
3148   EXPECT_EQ("//root/b", StatA->getName());
3149   EXPECT_EQ("//root/c", StatB->getName());
3150 
3151   auto BufferA = RemappedFS->getBufferForFile("//root/a/a");
3152   auto BufferB = RemappedFS->getBufferForFile("//root/a/b/c");
3153   ASSERT_TRUE(BufferA);
3154   ASSERT_TRUE(BufferB);
3155   EXPECT_EQ("contents of b", (*BufferA)->getBuffer());
3156   EXPECT_EQ("contents of c", (*BufferB)->getBuffer());
3157 }
3158 
3159 TEST(VFSFromRemappedFilesTest, LastMappingWins) {
3160   IntrusiveRefCntPtr<vfs::InMemoryFileSystem> BaseFS =
3161       new vfs::InMemoryFileSystem;
3162   BaseFS->addFile("//root/b", 0, MemoryBuffer::getMemBuffer("contents of b"));
3163   BaseFS->addFile("//root/c", 0, MemoryBuffer::getMemBuffer("contents of c"));
3164 
3165   std::vector<std::pair<std::string, std::string>> RemappedFiles = {
3166       {"//root/a", "//root/b"},
3167       {"//root/a", "//root/c"},
3168   };
3169   auto RemappedFSKeepName = vfs::RedirectingFileSystem::create(
3170       RemappedFiles, /*UseExternalNames=*/false, *BaseFS);
3171   auto RemappedFSExternalName = vfs::RedirectingFileSystem::create(
3172       RemappedFiles, /*UseExternalNames=*/true, *BaseFS);
3173 
3174   auto StatKeepA = RemappedFSKeepName->status("//root/a");
3175   auto StatExternalA = RemappedFSExternalName->status("//root/a");
3176   ASSERT_TRUE(StatKeepA);
3177   ASSERT_TRUE(StatExternalA);
3178   EXPECT_EQ("//root/a", StatKeepA->getName());
3179   EXPECT_EQ("//root/c", StatExternalA->getName());
3180 
3181   auto BufferKeepA = RemappedFSKeepName->getBufferForFile("//root/a");
3182   auto BufferExternalA = RemappedFSExternalName->getBufferForFile("//root/a");
3183   ASSERT_TRUE(BufferKeepA);
3184   ASSERT_TRUE(BufferExternalA);
3185   EXPECT_EQ("contents of c", (*BufferKeepA)->getBuffer());
3186   EXPECT_EQ("contents of c", (*BufferExternalA)->getBuffer());
3187 }
3188 
3189 TEST(RedirectingFileSystemTest, PrintOutput) {
3190   auto Buffer =
3191       MemoryBuffer::getMemBuffer("{\n"
3192                                  "  'version': 0,\n"
3193                                  "  'roots': [\n"
3194                                  "    {\n"
3195                                  "      'type': 'directory-remap',\n"
3196                                  "      'name': '/dremap',\n"
3197                                  "      'external-contents': '/a',\n"
3198                                  "    },"
3199                                  "    {\n"
3200                                  "      'type': 'directory',\n"
3201                                  "      'name': '/vdir',\n"
3202                                  "      'contents': ["
3203                                  "        {\n"
3204                                  "          'type': 'directory-remap',\n"
3205                                  "          'name': 'dremap',\n"
3206                                  "          'external-contents': '/b'\n"
3207                                  "          'use-external-name': 'true'\n"
3208                                  "        },\n"
3209                                  "        {\n"
3210                                  "          'type': 'file',\n"
3211                                  "          'name': 'vfile',\n"
3212                                  "          'external-contents': '/c'\n"
3213                                  "          'use-external-name': 'false'\n"
3214                                  "        }]\n"
3215                                  "    }]\n"
3216                                  "}");
3217 
3218   auto Dummy = makeIntrusiveRefCnt<DummyFileSystem>();
3219   auto Redirecting = vfs::RedirectingFileSystem::create(
3220       std::move(Buffer), nullptr, "", nullptr, Dummy);
3221 
3222   SmallString<0> Output;
3223   raw_svector_ostream OuputStream{Output};
3224 
3225   Redirecting->print(OuputStream, vfs::FileSystem::PrintType::Summary);
3226   ASSERT_EQ("RedirectingFileSystem (UseExternalNames: true)\n", Output);
3227 
3228   Output.clear();
3229   Redirecting->print(OuputStream, vfs::FileSystem::PrintType::Contents);
3230   ASSERT_EQ("RedirectingFileSystem (UseExternalNames: true)\n"
3231             "'/'\n"
3232             "  'dremap' -> '/a'\n"
3233             "  'vdir'\n"
3234             "    'dremap' -> '/b' (UseExternalName: true)\n"
3235             "    'vfile' -> '/c' (UseExternalName: false)\n"
3236             "ExternalFS:\n"
3237             "  DummyFileSystem (Summary)\n",
3238             Output);
3239 
3240   Output.clear();
3241   Redirecting->print(OuputStream, vfs::FileSystem::PrintType::Contents, 1);
3242   ASSERT_EQ("  RedirectingFileSystem (UseExternalNames: true)\n"
3243             "  '/'\n"
3244             "    'dremap' -> '/a'\n"
3245             "    'vdir'\n"
3246             "      'dremap' -> '/b' (UseExternalName: true)\n"
3247             "      'vfile' -> '/c' (UseExternalName: false)\n"
3248             "  ExternalFS:\n"
3249             "    DummyFileSystem (Summary)\n",
3250             Output);
3251 
3252   Output.clear();
3253   Redirecting->print(OuputStream,
3254                      vfs::FileSystem::PrintType::RecursiveContents);
3255   ASSERT_EQ("RedirectingFileSystem (UseExternalNames: true)\n"
3256             "'/'\n"
3257             "  'dremap' -> '/a'\n"
3258             "  'vdir'\n"
3259             "    'dremap' -> '/b' (UseExternalName: true)\n"
3260             "    'vfile' -> '/c' (UseExternalName: false)\n"
3261             "ExternalFS:\n"
3262             "  DummyFileSystem (RecursiveContents)\n",
3263             Output);
3264 }
3265