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