blob: bd75ad0112a103e57e0a4f92e2eddccf8e6b6b18 [file] [log] [blame]
Ben Langmuirc8130a72014-02-20 21:59:23 +00001//===- unittests/Basic/VirtualFileSystem.cpp ---------------- VFS tests ---===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "clang/Basic/VirtualFileSystem.h"
Rafael Espindola71de0b62014-06-13 17:20:50 +000011#include "llvm/Support/Errc.h"
Ben Langmuird51ba0b2014-02-21 23:39:37 +000012#include "llvm/Support/MemoryBuffer.h"
Ben Langmuirc8130a72014-02-20 21:59:23 +000013#include "llvm/Support/Path.h"
Ben Langmuird51ba0b2014-02-21 23:39:37 +000014#include "llvm/Support/SourceMgr.h"
Ben Langmuirc8130a72014-02-20 21:59:23 +000015#include "gtest/gtest.h"
16#include <map>
Hans Wennborgdcfba332015-10-06 23:40:43 +000017
Ben Langmuirc8130a72014-02-20 21:59:23 +000018using namespace clang;
19using namespace llvm;
20using llvm::sys::fs::UniqueID;
21
22namespace {
23class DummyFileSystem : public vfs::FileSystem {
24 int FSID; // used to produce UniqueIDs
25 int FileID; // used to produce UniqueIDs
26 std::map<std::string, vfs::Status> FilesAndDirs;
27
28 static int getNextFSID() {
29 static int Count = 0;
30 return Count++;
31 }
32
33public:
34 DummyFileSystem() : FSID(getNextFSID()), FileID(0) {}
35
Fariborz Jahanian5afc8692014-10-01 16:56:40 +000036 ErrorOr<vfs::Status> status(const Twine &Path) override {
Ben Langmuirc8130a72014-02-20 21:59:23 +000037 std::map<std::string, vfs::Status>::iterator I =
Ben Langmuird51ba0b2014-02-21 23:39:37 +000038 FilesAndDirs.find(Path.str());
Ben Langmuirc8130a72014-02-20 21:59:23 +000039 if (I == FilesAndDirs.end())
Rafael Espindola71de0b62014-06-13 17:20:50 +000040 return make_error_code(llvm::errc::no_such_file_or_directory);
Ben Langmuirc8130a72014-02-20 21:59:23 +000041 return I->second;
42 }
Benjamin Kramera8857962014-10-26 22:44:13 +000043 ErrorOr<std::unique_ptr<vfs::File>>
44 openFileForRead(const Twine &Path) override {
Ben Langmuirc8130a72014-02-20 21:59:23 +000045 llvm_unreachable("unimplemented");
46 }
Benjamin Kramer7708b2a2015-10-05 13:55:20 +000047 llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override {
48 return std::string();
49 }
50 std::error_code setCurrentWorkingDirectory(const Twine &Path) override {
51 return std::error_code();
52 }
Ben Langmuirc8130a72014-02-20 21:59:23 +000053
Ben Langmuir740812b2014-06-24 19:37:16 +000054 struct DirIterImpl : public clang::vfs::detail::DirIterImpl {
55 std::map<std::string, vfs::Status> &FilesAndDirs;
56 std::map<std::string, vfs::Status>::iterator I;
57 std::string Path;
Ben Langmuir7c9f6c82014-06-25 20:25:40 +000058 bool isInPath(StringRef S) {
59 if (Path.size() < S.size() && S.find(Path) == 0) {
60 auto LastSep = S.find_last_of('/');
61 if (LastSep == Path.size() || LastSep == Path.size()-1)
62 return true;
63 }
64 return false;
65 }
Ben Langmuir740812b2014-06-24 19:37:16 +000066 DirIterImpl(std::map<std::string, vfs::Status> &FilesAndDirs,
67 const Twine &_Path)
68 : FilesAndDirs(FilesAndDirs), I(FilesAndDirs.begin()),
69 Path(_Path.str()) {
70 for ( ; I != FilesAndDirs.end(); ++I) {
Ben Langmuir7c9f6c82014-06-25 20:25:40 +000071 if (isInPath(I->first)) {
Ben Langmuir740812b2014-06-24 19:37:16 +000072 CurrentEntry = I->second;
73 break;
74 }
75 }
76 }
77 std::error_code increment() override {
78 ++I;
79 for ( ; I != FilesAndDirs.end(); ++I) {
Ben Langmuir7c9f6c82014-06-25 20:25:40 +000080 if (isInPath(I->first)) {
Ben Langmuir740812b2014-06-24 19:37:16 +000081 CurrentEntry = I->second;
82 break;
83 }
84 }
85 if (I == FilesAndDirs.end())
86 CurrentEntry = vfs::Status();
87 return std::error_code();
88 }
89 };
90
91 vfs::directory_iterator dir_begin(const Twine &Dir,
92 std::error_code &EC) override {
93 return vfs::directory_iterator(
94 std::make_shared<DirIterImpl>(FilesAndDirs, Dir));
95 }
96
Ben Langmuirc8130a72014-02-20 21:59:23 +000097 void addEntry(StringRef Path, const vfs::Status &Status) {
98 FilesAndDirs[Path] = Status;
99 }
100
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000101 void addRegularFile(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
Benjamin Kramer268b51a2015-10-05 13:15:33 +0000102 vfs::Status S(Path, UniqueID(FSID, FileID++), sys::TimeValue::now(), 0, 0,
103 1024, sys::fs::file_type::regular_file, Perms);
Ben Langmuirc8130a72014-02-20 21:59:23 +0000104 addEntry(Path, S);
105 }
106
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000107 void addDirectory(StringRef Path, sys::fs::perms Perms = sys::fs::all_all) {
Benjamin Kramer268b51a2015-10-05 13:15:33 +0000108 vfs::Status S(Path, UniqueID(FSID, FileID++), sys::TimeValue::now(), 0, 0,
109 0, sys::fs::file_type::directory_file, Perms);
Ben Langmuirc8130a72014-02-20 21:59:23 +0000110 addEntry(Path, S);
111 }
112
113 void addSymlink(StringRef Path) {
Benjamin Kramer268b51a2015-10-05 13:15:33 +0000114 vfs::Status S(Path, UniqueID(FSID, FileID++), sys::TimeValue::now(), 0, 0,
115 0, sys::fs::file_type::symlink_file, sys::fs::all_all);
Ben Langmuirc8130a72014-02-20 21:59:23 +0000116 addEntry(Path, S);
117 }
118};
119} // end anonymous namespace
120
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000121TEST(VirtualFileSystemTest, StatusQueries) {
Ben Langmuirc8130a72014-02-20 21:59:23 +0000122 IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
Rafael Espindola8e650d72014-06-12 20:37:59 +0000123 ErrorOr<vfs::Status> Status((std::error_code()));
Ben Langmuirc8130a72014-02-20 21:59:23 +0000124
125 D->addRegularFile("/foo");
126 Status = D->status("/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000127 ASSERT_FALSE(Status.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000128 EXPECT_TRUE(Status->isStatusKnown());
129 EXPECT_FALSE(Status->isDirectory());
130 EXPECT_TRUE(Status->isRegularFile());
131 EXPECT_FALSE(Status->isSymlink());
132 EXPECT_FALSE(Status->isOther());
133 EXPECT_TRUE(Status->exists());
134
135 D->addDirectory("/bar");
136 Status = D->status("/bar");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000137 ASSERT_FALSE(Status.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000138 EXPECT_TRUE(Status->isStatusKnown());
139 EXPECT_TRUE(Status->isDirectory());
140 EXPECT_FALSE(Status->isRegularFile());
141 EXPECT_FALSE(Status->isSymlink());
142 EXPECT_FALSE(Status->isOther());
143 EXPECT_TRUE(Status->exists());
144
145 D->addSymlink("/baz");
146 Status = D->status("/baz");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000147 ASSERT_FALSE(Status.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000148 EXPECT_TRUE(Status->isStatusKnown());
149 EXPECT_FALSE(Status->isDirectory());
150 EXPECT_FALSE(Status->isRegularFile());
151 EXPECT_TRUE(Status->isSymlink());
152 EXPECT_FALSE(Status->isOther());
153 EXPECT_TRUE(Status->exists());
154
155 EXPECT_TRUE(Status->equivalent(*Status));
156 ErrorOr<vfs::Status> Status2 = D->status("/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000157 ASSERT_FALSE(Status2.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000158 EXPECT_FALSE(Status->equivalent(*Status2));
159}
160
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000161TEST(VirtualFileSystemTest, BaseOnlyOverlay) {
Ben Langmuirc8130a72014-02-20 21:59:23 +0000162 IntrusiveRefCntPtr<DummyFileSystem> D(new DummyFileSystem());
Rafael Espindola8e650d72014-06-12 20:37:59 +0000163 ErrorOr<vfs::Status> Status((std::error_code()));
Ben Langmuirc8130a72014-02-20 21:59:23 +0000164 EXPECT_FALSE(Status = D->status("/foo"));
165
166 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(new vfs::OverlayFileSystem(D));
167 EXPECT_FALSE(Status = O->status("/foo"));
168
169 D->addRegularFile("/foo");
170 Status = D->status("/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000171 EXPECT_FALSE(Status.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000172
Rafael Espindola8e650d72014-06-12 20:37:59 +0000173 ErrorOr<vfs::Status> Status2((std::error_code()));
Ben Langmuirc8130a72014-02-20 21:59:23 +0000174 Status2 = O->status("/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000175 EXPECT_FALSE(Status2.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000176 EXPECT_TRUE(Status->equivalent(*Status2));
177}
178
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000179TEST(VirtualFileSystemTest, OverlayFiles) {
Ben Langmuirc8130a72014-02-20 21:59:23 +0000180 IntrusiveRefCntPtr<DummyFileSystem> Base(new DummyFileSystem());
181 IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
182 IntrusiveRefCntPtr<DummyFileSystem> Top(new DummyFileSystem());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000183 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
184 new vfs::OverlayFileSystem(Base));
Ben Langmuirc8130a72014-02-20 21:59:23 +0000185 O->pushOverlay(Middle);
186 O->pushOverlay(Top);
187
Rafael Espindola8e650d72014-06-12 20:37:59 +0000188 ErrorOr<vfs::Status> Status1((std::error_code())),
189 Status2((std::error_code())), Status3((std::error_code())),
190 StatusB((std::error_code())), StatusM((std::error_code())),
191 StatusT((std::error_code()));
Ben Langmuirc8130a72014-02-20 21:59:23 +0000192
193 Base->addRegularFile("/foo");
194 StatusB = Base->status("/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000195 ASSERT_FALSE(StatusB.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000196 Status1 = O->status("/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000197 ASSERT_FALSE(Status1.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000198 Middle->addRegularFile("/foo");
199 StatusM = Middle->status("/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000200 ASSERT_FALSE(StatusM.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000201 Status2 = O->status("/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000202 ASSERT_FALSE(Status2.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000203 Top->addRegularFile("/foo");
204 StatusT = Top->status("/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000205 ASSERT_FALSE(StatusT.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000206 Status3 = O->status("/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000207 ASSERT_FALSE(Status3.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000208
209 EXPECT_TRUE(Status1->equivalent(*StatusB));
210 EXPECT_TRUE(Status2->equivalent(*StatusM));
211 EXPECT_TRUE(Status3->equivalent(*StatusT));
212
213 EXPECT_FALSE(Status1->equivalent(*Status2));
214 EXPECT_FALSE(Status2->equivalent(*Status3));
215 EXPECT_FALSE(Status1->equivalent(*Status3));
216}
217
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000218TEST(VirtualFileSystemTest, OverlayDirsNonMerged) {
Ben Langmuirc8130a72014-02-20 21:59:23 +0000219 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
220 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000221 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
222 new vfs::OverlayFileSystem(Lower));
Ben Langmuirc8130a72014-02-20 21:59:23 +0000223 O->pushOverlay(Upper);
224
225 Lower->addDirectory("/lower-only");
226 Upper->addDirectory("/upper-only");
227
228 // non-merged paths should be the same
229 ErrorOr<vfs::Status> Status1 = Lower->status("/lower-only");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000230 ASSERT_FALSE(Status1.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000231 ErrorOr<vfs::Status> Status2 = O->status("/lower-only");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000232 ASSERT_FALSE(Status2.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000233 EXPECT_TRUE(Status1->equivalent(*Status2));
234
235 Status1 = Upper->status("/upper-only");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000236 ASSERT_FALSE(Status1.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000237 Status2 = O->status("/upper-only");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000238 ASSERT_FALSE(Status2.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000239 EXPECT_TRUE(Status1->equivalent(*Status2));
240}
241
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000242TEST(VirtualFileSystemTest, MergedDirPermissions) {
Ben Langmuirc8130a72014-02-20 21:59:23 +0000243 // merged directories get the permissions of the upper dir
244 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
245 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000246 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
247 new vfs::OverlayFileSystem(Lower));
Ben Langmuirc8130a72014-02-20 21:59:23 +0000248 O->pushOverlay(Upper);
249
Rafael Espindola8e650d72014-06-12 20:37:59 +0000250 ErrorOr<vfs::Status> Status((std::error_code()));
Ben Langmuirc8130a72014-02-20 21:59:23 +0000251 Lower->addDirectory("/both", sys::fs::owner_read);
252 Upper->addDirectory("/both", sys::fs::owner_all | sys::fs::group_read);
253 Status = O->status("/both");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000254 ASSERT_FALSE(Status.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000255 EXPECT_EQ(0740, Status->getPermissions());
256
257 // permissions (as usual) are not recursively applied
258 Lower->addRegularFile("/both/foo", sys::fs::owner_read);
259 Upper->addRegularFile("/both/bar", sys::fs::owner_write);
260 Status = O->status("/both/foo");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000261 ASSERT_FALSE( Status.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000262 EXPECT_EQ(0400, Status->getPermissions());
263 Status = O->status("/both/bar");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000264 ASSERT_FALSE(Status.getError());
Ben Langmuirc8130a72014-02-20 21:59:23 +0000265 EXPECT_EQ(0200, Status->getPermissions());
266}
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000267
Ben Langmuir740812b2014-06-24 19:37:16 +0000268namespace {
269struct ScopedDir {
270 SmallString<128> Path;
271 ScopedDir(const Twine &Name, bool Unique=false) {
272 std::error_code EC;
273 if (Unique) {
274 EC = llvm::sys::fs::createUniqueDirectory(Name, Path);
275 } else {
276 Path = Name.str();
277 EC = llvm::sys::fs::create_directory(Twine(Path));
278 }
279 if (EC)
280 Path = "";
281 EXPECT_FALSE(EC);
282 }
283 ~ScopedDir() {
284 if (Path != "")
285 EXPECT_FALSE(llvm::sys::fs::remove(Path.str()));
286 }
287 operator StringRef() { return Path.str(); }
288};
Hans Wennborgdcfba332015-10-06 23:40:43 +0000289} // end anonymous namespace
Ben Langmuir740812b2014-06-24 19:37:16 +0000290
291TEST(VirtualFileSystemTest, BasicRealFSIteration) {
292 ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/true);
293 IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
294
295 std::error_code EC;
296 vfs::directory_iterator I = FS->dir_begin(Twine(TestDirectory), EC);
297 ASSERT_FALSE(EC);
298 EXPECT_EQ(vfs::directory_iterator(), I); // empty directory is empty
299
300 ScopedDir _a(TestDirectory+"/a");
301 ScopedDir _ab(TestDirectory+"/a/b");
302 ScopedDir _c(TestDirectory+"/c");
303 ScopedDir _cd(TestDirectory+"/c/d");
304
305 I = FS->dir_begin(Twine(TestDirectory), EC);
306 ASSERT_FALSE(EC);
307 ASSERT_NE(vfs::directory_iterator(), I);
Ben Langmuirefb8b602014-06-24 21:08:13 +0000308 // Check either a or c, since we can't rely on the iteration order.
309 EXPECT_TRUE(I->getName().endswith("a") || I->getName().endswith("c"));
Ben Langmuir740812b2014-06-24 19:37:16 +0000310 I.increment(EC);
311 ASSERT_FALSE(EC);
312 ASSERT_NE(vfs::directory_iterator(), I);
Ben Langmuirefb8b602014-06-24 21:08:13 +0000313 EXPECT_TRUE(I->getName().endswith("a") || I->getName().endswith("c"));
Ben Langmuir740812b2014-06-24 19:37:16 +0000314 I.increment(EC);
315 EXPECT_EQ(vfs::directory_iterator(), I);
316}
317
Ben Langmuir7c9f6c82014-06-25 20:25:40 +0000318TEST(VirtualFileSystemTest, BasicRealFSRecursiveIteration) {
319 ScopedDir TestDirectory("virtual-file-system-test", /*Unique*/true);
320 IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getRealFileSystem();
321
322 std::error_code EC;
323 auto I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC);
324 ASSERT_FALSE(EC);
325 EXPECT_EQ(vfs::recursive_directory_iterator(), I); // empty directory is empty
326
327 ScopedDir _a(TestDirectory+"/a");
328 ScopedDir _ab(TestDirectory+"/a/b");
329 ScopedDir _c(TestDirectory+"/c");
330 ScopedDir _cd(TestDirectory+"/c/d");
331
332 I = vfs::recursive_directory_iterator(*FS, Twine(TestDirectory), EC);
333 ASSERT_FALSE(EC);
334 ASSERT_NE(vfs::recursive_directory_iterator(), I);
335
336
337 std::vector<std::string> Contents;
338 for (auto E = vfs::recursive_directory_iterator(); !EC && I != E;
339 I.increment(EC)) {
340 Contents.push_back(I->getName());
341 }
342
343 // Check contents, which may be in any order
344 EXPECT_EQ(4U, Contents.size());
345 int Counts[4] = { 0, 0, 0, 0 };
346 for (const std::string &Name : Contents) {
347 ASSERT_FALSE(Name.empty());
348 int Index = Name[Name.size()-1] - 'a';
349 ASSERT_TRUE(Index >= 0 && Index < 4);
350 Counts[Index]++;
351 }
352 EXPECT_EQ(1, Counts[0]); // a
353 EXPECT_EQ(1, Counts[1]); // b
354 EXPECT_EQ(1, Counts[2]); // c
355 EXPECT_EQ(1, Counts[3]); // d
356}
357
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +0000358template <typename T, size_t N>
359std::vector<StringRef> makeStringRefVector(const T (&Arr)[N]) {
360 std::vector<StringRef> Vec;
361 for (size_t i = 0; i != N; ++i)
362 Vec.push_back(Arr[i]);
363 return Vec;
364}
365
Ben Langmuir7c9f6c82014-06-25 20:25:40 +0000366template <typename DirIter>
367static void checkContents(DirIter I, ArrayRef<StringRef> Expected) {
Ben Langmuir740812b2014-06-24 19:37:16 +0000368 std::error_code EC;
369 auto ExpectedIter = Expected.begin(), ExpectedEnd = Expected.end();
Ben Langmuir7c9f6c82014-06-25 20:25:40 +0000370 for (DirIter E;
Ben Langmuir740812b2014-06-24 19:37:16 +0000371 !EC && I != E && ExpectedIter != ExpectedEnd;
372 I.increment(EC), ++ExpectedIter)
373 EXPECT_EQ(*ExpectedIter, I->getName());
374
375 EXPECT_EQ(ExpectedEnd, ExpectedIter);
Ben Langmuir7c9f6c82014-06-25 20:25:40 +0000376 EXPECT_EQ(DirIter(), I);
Ben Langmuir740812b2014-06-24 19:37:16 +0000377}
378
379TEST(VirtualFileSystemTest, OverlayIteration) {
380 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
381 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
382 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
383 new vfs::OverlayFileSystem(Lower));
384 O->pushOverlay(Upper);
385
386 std::error_code EC;
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +0000387 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>());
Ben Langmuir740812b2014-06-24 19:37:16 +0000388
389 Lower->addRegularFile("/file1");
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +0000390 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file1"));
Ben Langmuir740812b2014-06-24 19:37:16 +0000391
392 Upper->addRegularFile("/file2");
393 {
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +0000394 const char *Contents[] = {"/file2", "/file1"};
395 checkContents(O->dir_begin("/", EC), makeStringRefVector(Contents));
Ben Langmuir740812b2014-06-24 19:37:16 +0000396 }
397
398 Lower->addDirectory("/dir1");
399 Lower->addRegularFile("/dir1/foo");
400 Upper->addDirectory("/dir2");
401 Upper->addRegularFile("/dir2/foo");
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +0000402 checkContents(O->dir_begin("/dir2", EC), ArrayRef<StringRef>("/dir2/foo"));
Ben Langmuir740812b2014-06-24 19:37:16 +0000403 {
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +0000404 const char *Contents[] = {"/dir2", "/file2", "/dir1", "/file1"};
405 checkContents(O->dir_begin("/", EC), makeStringRefVector(Contents));
Ben Langmuir740812b2014-06-24 19:37:16 +0000406 }
407}
408
Ben Langmuir7c9f6c82014-06-25 20:25:40 +0000409TEST(VirtualFileSystemTest, OverlayRecursiveIteration) {
410 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
411 IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
412 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
413 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
414 new vfs::OverlayFileSystem(Lower));
415 O->pushOverlay(Middle);
416 O->pushOverlay(Upper);
417
418 std::error_code EC;
419 checkContents(vfs::recursive_directory_iterator(*O, "/", EC),
420 ArrayRef<StringRef>());
421
422 Lower->addRegularFile("/file1");
423 checkContents(vfs::recursive_directory_iterator(*O, "/", EC),
424 ArrayRef<StringRef>("/file1"));
425
426 Upper->addDirectory("/dir");
427 Upper->addRegularFile("/dir/file2");
428 {
429 const char *Contents[] = {"/dir", "/dir/file2", "/file1"};
430 checkContents(vfs::recursive_directory_iterator(*O, "/", EC),
431 makeStringRefVector(Contents));
432 }
433
434 Lower->addDirectory("/dir1");
435 Lower->addRegularFile("/dir1/foo");
436 Lower->addDirectory("/dir1/a");
437 Lower->addRegularFile("/dir1/a/b");
438 Middle->addDirectory("/a");
439 Middle->addDirectory("/a/b");
440 Middle->addDirectory("/a/b/c");
441 Middle->addRegularFile("/a/b/c/d");
442 Middle->addRegularFile("/hiddenByUp");
443 Upper->addDirectory("/dir2");
444 Upper->addRegularFile("/dir2/foo");
445 Upper->addRegularFile("/hiddenByUp");
446 checkContents(vfs::recursive_directory_iterator(*O, "/dir2", EC),
447 ArrayRef<StringRef>("/dir2/foo"));
448 {
449 const char *Contents[] = { "/dir", "/dir/file2", "/dir2", "/dir2/foo",
450 "/hiddenByUp", "/a", "/a/b", "/a/b/c", "/a/b/c/d", "/dir1", "/dir1/a",
451 "/dir1/a/b", "/dir1/foo", "/file1" };
452 checkContents(vfs::recursive_directory_iterator(*O, "/", EC),
453 makeStringRefVector(Contents));
454 }
455}
456
Ben Langmuir740812b2014-06-24 19:37:16 +0000457TEST(VirtualFileSystemTest, ThreeLevelIteration) {
458 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
459 IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
460 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
461 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
462 new vfs::OverlayFileSystem(Lower));
463 O->pushOverlay(Middle);
464 O->pushOverlay(Upper);
465
466 std::error_code EC;
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +0000467 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>());
Ben Langmuir740812b2014-06-24 19:37:16 +0000468
469 Middle->addRegularFile("/file2");
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +0000470 checkContents(O->dir_begin("/", EC), ArrayRef<StringRef>("/file2"));
Ben Langmuir740812b2014-06-24 19:37:16 +0000471
472 Lower->addRegularFile("/file1");
473 Upper->addRegularFile("/file3");
474 {
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +0000475 const char *Contents[] = {"/file3", "/file2", "/file1"};
476 checkContents(O->dir_begin("/", EC), makeStringRefVector(Contents));
Ben Langmuir740812b2014-06-24 19:37:16 +0000477 }
478}
479
480TEST(VirtualFileSystemTest, HiddenInIteration) {
481 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
482 IntrusiveRefCntPtr<DummyFileSystem> Middle(new DummyFileSystem());
483 IntrusiveRefCntPtr<DummyFileSystem> Upper(new DummyFileSystem());
484 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
485 new vfs::OverlayFileSystem(Lower));
486 O->pushOverlay(Middle);
487 O->pushOverlay(Upper);
488
489 std::error_code EC;
490 Lower->addRegularFile("/onlyInLow", sys::fs::owner_read);
491 Lower->addRegularFile("/hiddenByMid", sys::fs::owner_read);
492 Lower->addRegularFile("/hiddenByUp", sys::fs::owner_read);
493 Middle->addRegularFile("/onlyInMid", sys::fs::owner_write);
494 Middle->addRegularFile("/hiddenByMid", sys::fs::owner_write);
495 Middle->addRegularFile("/hiddenByUp", sys::fs::owner_write);
496 Upper->addRegularFile("/onlyInUp", sys::fs::owner_all);
497 Upper->addRegularFile("/hiddenByUp", sys::fs::owner_all);
498 {
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +0000499 const char *Contents[] = {"/hiddenByUp", "/onlyInUp", "/hiddenByMid",
500 "/onlyInMid", "/onlyInLow"};
501 checkContents(O->dir_begin("/", EC), makeStringRefVector(Contents));
Ben Langmuir740812b2014-06-24 19:37:16 +0000502 }
503
504 // Make sure we get the top-most entry
Ben Langmuirefb8b602014-06-24 21:08:13 +0000505 {
506 std::error_code EC;
507 vfs::directory_iterator I = O->dir_begin("/", EC), E;
508 for ( ; !EC && I != E; I.increment(EC))
509 if (I->getName() == "/hiddenByUp")
510 break;
511 ASSERT_NE(E, I);
512 EXPECT_EQ(sys::fs::owner_all, I->getPermissions());
513 }
514 {
515 std::error_code EC;
516 vfs::directory_iterator I = O->dir_begin("/", EC), E;
517 for ( ; !EC && I != E; I.increment(EC))
518 if (I->getName() == "/hiddenByMid")
519 break;
520 ASSERT_NE(E, I);
521 EXPECT_EQ(sys::fs::owner_write, I->getPermissions());
522 }
Ben Langmuir740812b2014-06-24 19:37:16 +0000523}
524
Benjamin Kramera25dcfd2015-10-05 13:55:14 +0000525class InMemoryFileSystemTest : public ::testing::Test {
526protected:
527 clang::vfs::InMemoryFileSystem FS;
528};
529
530TEST_F(InMemoryFileSystemTest, IsEmpty) {
531 auto Stat = FS.status("/a");
Rafael Espindolab7ab1872015-10-05 20:20:50 +0000532 ASSERT_EQ(Stat.getError(),errc::no_such_file_or_directory) << FS.toString();
Benjamin Kramera25dcfd2015-10-05 13:55:14 +0000533 Stat = FS.status("/");
Rafael Espindolab7ab1872015-10-05 20:20:50 +0000534 ASSERT_EQ(Stat.getError(), errc::no_such_file_or_directory) << FS.toString();
Benjamin Kramera25dcfd2015-10-05 13:55:14 +0000535}
536
537TEST_F(InMemoryFileSystemTest, WindowsPath) {
538 FS.addFile("c:/windows/system128/foo.cpp", 0, MemoryBuffer::getMemBuffer(""));
539 auto Stat = FS.status("c:");
NAKAMURA Takumi4c33a1a2015-10-06 12:16:27 +0000540#if !defined(_WIN32)
Benjamin Kramera25dcfd2015-10-05 13:55:14 +0000541 ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString();
NAKAMURA Takumi4c33a1a2015-10-06 12:16:27 +0000542#endif
Benjamin Kramera25dcfd2015-10-05 13:55:14 +0000543 Stat = FS.status("c:/windows/system128/foo.cpp");
544 ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString();
545 FS.addFile("d:/windows/foo.cpp", 0, MemoryBuffer::getMemBuffer(""));
546 Stat = FS.status("d:/windows/foo.cpp");
547 ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString();
548}
549
550TEST_F(InMemoryFileSystemTest, OverlayFile) {
551 FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a"));
552 auto Stat = FS.status("/");
553 ASSERT_FALSE(Stat.getError()) << Stat.getError() << FS.toString();
554 Stat = FS.status("/a");
555 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
556 ASSERT_EQ("/a", Stat->getName());
557}
558
Benjamin Kramer2e2351a2015-10-06 10:04:08 +0000559TEST_F(InMemoryFileSystemTest, OverlayFileNoOwn) {
560 auto Buf = MemoryBuffer::getMemBuffer("a");
561 FS.addFileNoOwn("/a", 0, Buf.get());
562 auto Stat = FS.status("/a");
563 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
564 ASSERT_EQ("/a", Stat->getName());
565}
566
Benjamin Kramera25dcfd2015-10-05 13:55:14 +0000567TEST_F(InMemoryFileSystemTest, OpenFileForRead) {
568 FS.addFile("/a", 0, MemoryBuffer::getMemBuffer("a"));
Benjamin Kramer4ad1c432015-10-12 13:30:38 +0000569 FS.addFile("./c", 0, MemoryBuffer::getMemBuffer("c"));
Benjamin Kramera25dcfd2015-10-05 13:55:14 +0000570 auto File = FS.openFileForRead("/a");
571 ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer());
572 File = FS.openFileForRead("/a"); // Open again.
573 ASSERT_EQ("a", (*(*File)->getBuffer("ignored"))->getBuffer());
574 File = FS.openFileForRead("/");
Rafael Espindolab7ab1872015-10-05 20:20:50 +0000575 ASSERT_EQ(File.getError(), errc::invalid_argument) << FS.toString();
Benjamin Kramera25dcfd2015-10-05 13:55:14 +0000576 File = FS.openFileForRead("/b");
Rafael Espindolab7ab1872015-10-05 20:20:50 +0000577 ASSERT_EQ(File.getError(), errc::no_such_file_or_directory) << FS.toString();
Benjamin Kramer4ad1c432015-10-12 13:30:38 +0000578 File = FS.openFileForRead("c");
Benjamin Kramerd5e0b582015-10-07 08:32:50 +0000579 ASSERT_EQ("c", (*(*File)->getBuffer("ignored"))->getBuffer());
Benjamin Kramera25dcfd2015-10-05 13:55:14 +0000580}
581
582TEST_F(InMemoryFileSystemTest, DirectoryIteration) {
583 FS.addFile("/a", 0, MemoryBuffer::getMemBuffer(""));
584 FS.addFile("/b/c", 0, MemoryBuffer::getMemBuffer(""));
585
586 std::error_code EC;
587 vfs::directory_iterator I = FS.dir_begin("/", EC);
588 ASSERT_FALSE(EC);
589 ASSERT_EQ("/a", I->getName());
590 I.increment(EC);
591 ASSERT_FALSE(EC);
592 ASSERT_EQ("/b", I->getName());
593 I.increment(EC);
594 ASSERT_FALSE(EC);
595 ASSERT_EQ(vfs::directory_iterator(), I);
596
597 I = FS.dir_begin("/b", EC);
598 ASSERT_FALSE(EC);
599 ASSERT_EQ("/b/c", I->getName());
600 I.increment(EC);
601 ASSERT_FALSE(EC);
602 ASSERT_EQ(vfs::directory_iterator(), I);
603}
604
Benjamin Kramer1b8dbe32015-10-06 14:45:16 +0000605TEST_F(InMemoryFileSystemTest, WorkingDirectory) {
606 FS.setCurrentWorkingDirectory("/b");
607 FS.addFile("c", 0, MemoryBuffer::getMemBuffer(""));
608
609 auto Stat = FS.status("/b/c");
610 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
611 ASSERT_EQ("c", Stat->getName());
612 ASSERT_EQ("/b", *FS.getCurrentWorkingDirectory());
613
614 Stat = FS.status("c");
615 ASSERT_FALSE(Stat.getError()) << Stat.getError() << "\n" << FS.toString();
616}
617
Ben Langmuir93853232014-03-05 21:32:20 +0000618// NOTE: in the tests below, we use '//root/' as our root directory, since it is
619// a legal *absolute* path on Windows as well as *nix.
Ben Langmuir97882e72014-02-24 20:56:37 +0000620class VFSFromYAMLTest : public ::testing::Test {
621public:
622 int NumDiagnostics;
Ben Langmuir93853232014-03-05 21:32:20 +0000623
Alexander Kornienko34eb2072015-04-11 02:00:23 +0000624 void SetUp() override { NumDiagnostics = 0; }
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000625
Ben Langmuir97882e72014-02-24 20:56:37 +0000626 static void CountingDiagHandler(const SMDiagnostic &, void *Context) {
627 VFSFromYAMLTest *Test = static_cast<VFSFromYAMLTest *>(Context);
628 ++Test->NumDiagnostics;
629 }
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000630
Ben Langmuir97882e72014-02-24 20:56:37 +0000631 IntrusiveRefCntPtr<vfs::FileSystem>
632 getFromYAMLRawString(StringRef Content,
633 IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS) {
Rafael Espindolad87f8d72014-08-27 20:03:29 +0000634 std::unique_ptr<MemoryBuffer> Buffer = MemoryBuffer::getMemBuffer(Content);
Rafael Espindola91ac8df2014-08-17 23:27:13 +0000635 return getVFSFromYAML(std::move(Buffer), CountingDiagHandler, this,
636 ExternalFS);
Ben Langmuir97882e72014-02-24 20:56:37 +0000637 }
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000638
Ben Langmuir97882e72014-02-24 20:56:37 +0000639 IntrusiveRefCntPtr<vfs::FileSystem> getFromYAMLString(
640 StringRef Content,
641 IntrusiveRefCntPtr<vfs::FileSystem> ExternalFS = new DummyFileSystem()) {
642 std::string VersionPlusContent("{\n 'version':0,\n");
643 VersionPlusContent += Content.slice(Content.find('{') + 1, StringRef::npos);
644 return getFromYAMLRawString(VersionPlusContent, ExternalFS);
645 }
Ben Langmuir97882e72014-02-24 20:56:37 +0000646};
647
648TEST_F(VFSFromYAMLTest, BasicVFSFromYAML) {
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000649 IntrusiveRefCntPtr<vfs::FileSystem> FS;
650 FS = getFromYAMLString("");
Alp Tokerf994cef2014-07-05 03:08:06 +0000651 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000652 FS = getFromYAMLString("[]");
Alp Tokerf994cef2014-07-05 03:08:06 +0000653 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000654 FS = getFromYAMLString("'string'");
Alp Tokerf994cef2014-07-05 03:08:06 +0000655 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000656 EXPECT_EQ(3, NumDiagnostics);
657}
658
Ben Langmuir97882e72014-02-24 20:56:37 +0000659TEST_F(VFSFromYAMLTest, MappedFiles) {
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000660 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
Ben Langmuir93853232014-03-05 21:32:20 +0000661 Lower->addRegularFile("//root/foo/bar/a");
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000662 IntrusiveRefCntPtr<vfs::FileSystem> FS =
663 getFromYAMLString("{ 'roots': [\n"
664 "{\n"
665 " 'type': 'directory',\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000666 " 'name': '//root/',\n"
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000667 " 'contents': [ {\n"
668 " 'type': 'file',\n"
669 " 'name': 'file1',\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000670 " 'external-contents': '//root/foo/bar/a'\n"
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000671 " },\n"
672 " {\n"
673 " 'type': 'file',\n"
674 " 'name': 'file2',\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000675 " 'external-contents': '//root/foo/b'\n"
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000676 " }\n"
677 " ]\n"
678 "}\n"
679 "]\n"
680 "}",
681 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000682 ASSERT_TRUE(FS.get() != nullptr);
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000683
684 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
685 new vfs::OverlayFileSystem(Lower));
686 O->pushOverlay(FS);
687
688 // file
Ben Langmuir93853232014-03-05 21:32:20 +0000689 ErrorOr<vfs::Status> S = O->status("//root/file1");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000690 ASSERT_FALSE(S.getError());
Ben Langmuir93853232014-03-05 21:32:20 +0000691 EXPECT_EQ("//root/foo/bar/a", S->getName());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000692
Ben Langmuir93853232014-03-05 21:32:20 +0000693 ErrorOr<vfs::Status> SLower = O->status("//root/foo/bar/a");
694 EXPECT_EQ("//root/foo/bar/a", SLower->getName());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000695 EXPECT_TRUE(S->equivalent(*SLower));
696
697 // directory
Ben Langmuir93853232014-03-05 21:32:20 +0000698 S = O->status("//root/");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000699 ASSERT_FALSE(S.getError());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000700 EXPECT_TRUE(S->isDirectory());
Ben Langmuir93853232014-03-05 21:32:20 +0000701 EXPECT_TRUE(S->equivalent(*O->status("//root/"))); // non-volatile UniqueID
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000702
703 // broken mapping
Rafael Espindola71de0b62014-06-13 17:20:50 +0000704 EXPECT_EQ(O->status("//root/file2").getError(),
705 llvm::errc::no_such_file_or_directory);
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000706 EXPECT_EQ(0, NumDiagnostics);
707}
708
Ben Langmuir97882e72014-02-24 20:56:37 +0000709TEST_F(VFSFromYAMLTest, CaseInsensitive) {
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000710 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
Ben Langmuir93853232014-03-05 21:32:20 +0000711 Lower->addRegularFile("//root/foo/bar/a");
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000712 IntrusiveRefCntPtr<vfs::FileSystem> FS =
713 getFromYAMLString("{ 'case-sensitive': 'false',\n"
714 " 'roots': [\n"
715 "{\n"
716 " 'type': 'directory',\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000717 " 'name': '//root/',\n"
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000718 " 'contents': [ {\n"
719 " 'type': 'file',\n"
720 " 'name': 'XX',\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000721 " 'external-contents': '//root/foo/bar/a'\n"
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000722 " }\n"
723 " ]\n"
724 "}]}",
725 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000726 ASSERT_TRUE(FS.get() != nullptr);
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000727
728 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
729 new vfs::OverlayFileSystem(Lower));
730 O->pushOverlay(FS);
731
Ben Langmuir93853232014-03-05 21:32:20 +0000732 ErrorOr<vfs::Status> S = O->status("//root/XX");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000733 ASSERT_FALSE(S.getError());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000734
Ben Langmuir93853232014-03-05 21:32:20 +0000735 ErrorOr<vfs::Status> SS = O->status("//root/xx");
Rafael Espindola3ae06202014-05-31 03:20:52 +0000736 ASSERT_FALSE(SS.getError());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000737 EXPECT_TRUE(S->equivalent(*SS));
Ben Langmuir93853232014-03-05 21:32:20 +0000738 SS = O->status("//root/xX");
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000739 EXPECT_TRUE(S->equivalent(*SS));
Ben Langmuir93853232014-03-05 21:32:20 +0000740 SS = O->status("//root/Xx");
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000741 EXPECT_TRUE(S->equivalent(*SS));
742 EXPECT_EQ(0, NumDiagnostics);
743}
744
Ben Langmuir97882e72014-02-24 20:56:37 +0000745TEST_F(VFSFromYAMLTest, CaseSensitive) {
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000746 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
Ben Langmuir93853232014-03-05 21:32:20 +0000747 Lower->addRegularFile("//root/foo/bar/a");
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000748 IntrusiveRefCntPtr<vfs::FileSystem> FS =
749 getFromYAMLString("{ 'case-sensitive': 'true',\n"
750 " 'roots': [\n"
751 "{\n"
752 " 'type': 'directory',\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000753 " 'name': '//root/',\n"
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000754 " 'contents': [ {\n"
755 " 'type': 'file',\n"
756 " 'name': 'XX',\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000757 " 'external-contents': '//root/foo/bar/a'\n"
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000758 " }\n"
759 " ]\n"
760 "}]}",
761 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000762 ASSERT_TRUE(FS.get() != nullptr);
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000763
764 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
765 new vfs::OverlayFileSystem(Lower));
766 O->pushOverlay(FS);
767
Ben Langmuir93853232014-03-05 21:32:20 +0000768 ErrorOr<vfs::Status> SS = O->status("//root/xx");
Rafael Espindola71de0b62014-06-13 17:20:50 +0000769 EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
Ben Langmuir93853232014-03-05 21:32:20 +0000770 SS = O->status("//root/xX");
Rafael Espindola71de0b62014-06-13 17:20:50 +0000771 EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
Ben Langmuir93853232014-03-05 21:32:20 +0000772 SS = O->status("//root/Xx");
Rafael Espindola71de0b62014-06-13 17:20:50 +0000773 EXPECT_EQ(SS.getError(), llvm::errc::no_such_file_or_directory);
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000774 EXPECT_EQ(0, NumDiagnostics);
775}
776
Ben Langmuir97882e72014-02-24 20:56:37 +0000777TEST_F(VFSFromYAMLTest, IllegalVFSFile) {
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000778 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
779
780 // invalid YAML at top-level
781 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString("{]", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000782 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000783 // invalid YAML in roots
784 FS = getFromYAMLString("{ 'roots':[}", Lower);
785 // invalid YAML in directory
786 FS = getFromYAMLString(
787 "{ 'roots':[ { 'name': 'foo', 'type': 'directory', 'contents': [}",
788 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000789 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000790
791 // invalid configuration
792 FS = getFromYAMLString("{ 'knobular': 'true', 'roots':[] }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000793 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000794 FS = getFromYAMLString("{ 'case-sensitive': 'maybe', 'roots':[] }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000795 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000796
797 // invalid roots
798 FS = getFromYAMLString("{ 'roots':'' }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000799 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000800 FS = getFromYAMLString("{ 'roots':{} }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000801 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000802
803 // invalid entries
804 FS = getFromYAMLString(
805 "{ 'roots':[ { 'type': 'other', 'name': 'me', 'contents': '' }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000806 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000807 FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': [], "
808 "'external-contents': 'other' }",
809 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000810 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000811 FS = getFromYAMLString(
812 "{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': [] }",
813 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000814 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000815 FS = getFromYAMLString(
816 "{ 'roots':[ { 'type': 'file', 'name': 'me', 'external-contents': {} }",
817 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000818 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000819 FS = getFromYAMLString(
820 "{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': {} }",
821 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000822 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000823 FS = getFromYAMLString(
824 "{ 'roots':[ { 'type': 'directory', 'name': 'me', 'contents': '' }",
825 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000826 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000827 FS = getFromYAMLString(
828 "{ 'roots':[ { 'thingy': 'directory', 'name': 'me', 'contents': [] }",
829 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000830 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000831
832 // missing mandatory fields
833 FS = getFromYAMLString("{ 'roots':[ { 'type': 'file', 'name': 'me' }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000834 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000835 FS = getFromYAMLString(
836 "{ 'roots':[ { 'type': 'file', 'external-contents': 'other' }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000837 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000838 FS = getFromYAMLString("{ 'roots':[ { 'name': 'me', 'contents': [] }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000839 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000840
841 // duplicate keys
842 FS = getFromYAMLString("{ 'roots':[], 'roots':[] }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000843 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000844 FS = getFromYAMLString(
845 "{ 'case-sensitive':'true', 'case-sensitive':'true', 'roots':[] }",
846 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000847 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000848 FS =
849 getFromYAMLString("{ 'roots':[{'name':'me', 'name':'you', 'type':'file', "
850 "'external-contents':'blah' } ] }",
851 Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000852 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000853
854 // missing version
855 FS = getFromYAMLRawString("{ 'roots':[] }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000856 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000857
858 // bad version number
859 FS = getFromYAMLRawString("{ 'version':'foo', 'roots':[] }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000860 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000861 FS = getFromYAMLRawString("{ 'version':-1, 'roots':[] }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000862 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000863 FS = getFromYAMLRawString("{ 'version':100000, 'roots':[] }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000864 EXPECT_EQ(nullptr, FS.get());
Ben Langmuird51ba0b2014-02-21 23:39:37 +0000865 EXPECT_EQ(24, NumDiagnostics);
866}
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000867
Ben Langmuirb59cf672014-02-27 00:25:12 +0000868TEST_F(VFSFromYAMLTest, UseExternalName) {
869 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
Ben Langmuir93853232014-03-05 21:32:20 +0000870 Lower->addRegularFile("//root/external/file");
Ben Langmuirb59cf672014-02-27 00:25:12 +0000871
872 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
873 "{ 'roots': [\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000874 " { 'type': 'file', 'name': '//root/A',\n"
875 " 'external-contents': '//root/external/file'\n"
Ben Langmuirb59cf672014-02-27 00:25:12 +0000876 " },\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000877 " { 'type': 'file', 'name': '//root/B',\n"
Ben Langmuirb59cf672014-02-27 00:25:12 +0000878 " 'use-external-name': true,\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000879 " 'external-contents': '//root/external/file'\n"
Ben Langmuirb59cf672014-02-27 00:25:12 +0000880 " },\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000881 " { 'type': 'file', 'name': '//root/C',\n"
Ben Langmuirb59cf672014-02-27 00:25:12 +0000882 " 'use-external-name': false,\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000883 " 'external-contents': '//root/external/file'\n"
Ben Langmuirb59cf672014-02-27 00:25:12 +0000884 " }\n"
885 "] }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000886 ASSERT_TRUE(nullptr != FS.get());
Ben Langmuirb59cf672014-02-27 00:25:12 +0000887
888 // default true
Ben Langmuir93853232014-03-05 21:32:20 +0000889 EXPECT_EQ("//root/external/file", FS->status("//root/A")->getName());
Ben Langmuirb59cf672014-02-27 00:25:12 +0000890 // explicit
Ben Langmuir93853232014-03-05 21:32:20 +0000891 EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
892 EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
Ben Langmuirb59cf672014-02-27 00:25:12 +0000893
894 // global configuration
895 FS = getFromYAMLString(
896 "{ 'use-external-names': false,\n"
897 " 'roots': [\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000898 " { 'type': 'file', 'name': '//root/A',\n"
899 " 'external-contents': '//root/external/file'\n"
Ben Langmuirb59cf672014-02-27 00:25:12 +0000900 " },\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000901 " { 'type': 'file', 'name': '//root/B',\n"
Ben Langmuirb59cf672014-02-27 00:25:12 +0000902 " 'use-external-name': true,\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000903 " 'external-contents': '//root/external/file'\n"
Ben Langmuirb59cf672014-02-27 00:25:12 +0000904 " },\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000905 " { 'type': 'file', 'name': '//root/C',\n"
Ben Langmuirb59cf672014-02-27 00:25:12 +0000906 " 'use-external-name': false,\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000907 " 'external-contents': '//root/external/file'\n"
Ben Langmuirb59cf672014-02-27 00:25:12 +0000908 " }\n"
909 "] }", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000910 ASSERT_TRUE(nullptr != FS.get());
Ben Langmuirb59cf672014-02-27 00:25:12 +0000911
912 // default
Ben Langmuir93853232014-03-05 21:32:20 +0000913 EXPECT_EQ("//root/A", FS->status("//root/A")->getName());
Ben Langmuirb59cf672014-02-27 00:25:12 +0000914 // explicit
Ben Langmuir93853232014-03-05 21:32:20 +0000915 EXPECT_EQ("//root/external/file", FS->status("//root/B")->getName());
916 EXPECT_EQ("//root/C", FS->status("//root/C")->getName());
Ben Langmuirb59cf672014-02-27 00:25:12 +0000917}
918
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000919TEST_F(VFSFromYAMLTest, MultiComponentPath) {
920 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
Ben Langmuir93853232014-03-05 21:32:20 +0000921 Lower->addRegularFile("//root/other");
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000922
923 // file in roots
924 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
925 "{ 'roots': [\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000926 " { 'type': 'file', 'name': '//root/path/to/file',\n"
927 " 'external-contents': '//root/other' }]\n"
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000928 "}", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000929 ASSERT_TRUE(nullptr != FS.get());
Rafael Espindola3ae06202014-05-31 03:20:52 +0000930 EXPECT_FALSE(FS->status("//root/path/to/file").getError());
931 EXPECT_FALSE(FS->status("//root/path/to").getError());
932 EXPECT_FALSE(FS->status("//root/path").getError());
933 EXPECT_FALSE(FS->status("//root/").getError());
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000934
935 // at the start
936 FS = getFromYAMLString(
937 "{ 'roots': [\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000938 " { 'type': 'directory', 'name': '//root/path/to',\n"
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000939 " 'contents': [ { 'type': 'file', 'name': 'file',\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000940 " 'external-contents': '//root/other' }]}]\n"
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000941 "}", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000942 ASSERT_TRUE(nullptr != FS.get());
Rafael Espindola3ae06202014-05-31 03:20:52 +0000943 EXPECT_FALSE(FS->status("//root/path/to/file").getError());
944 EXPECT_FALSE(FS->status("//root/path/to").getError());
945 EXPECT_FALSE(FS->status("//root/path").getError());
946 EXPECT_FALSE(FS->status("//root/").getError());
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000947
948 // at the end
949 FS = getFromYAMLString(
950 "{ 'roots': [\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000951 " { 'type': 'directory', 'name': '//root/',\n"
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000952 " 'contents': [ { 'type': 'file', 'name': 'path/to/file',\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000953 " 'external-contents': '//root/other' }]}]\n"
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000954 "}", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000955 ASSERT_TRUE(nullptr != FS.get());
Rafael Espindola3ae06202014-05-31 03:20:52 +0000956 EXPECT_FALSE(FS->status("//root/path/to/file").getError());
957 EXPECT_FALSE(FS->status("//root/path/to").getError());
958 EXPECT_FALSE(FS->status("//root/path").getError());
959 EXPECT_FALSE(FS->status("//root/").getError());
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000960}
961
962TEST_F(VFSFromYAMLTest, TrailingSlashes) {
963 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
Ben Langmuir93853232014-03-05 21:32:20 +0000964 Lower->addRegularFile("//root/other");
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000965
966 // file in roots
967 IntrusiveRefCntPtr<vfs::FileSystem> FS = getFromYAMLString(
968 "{ 'roots': [\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000969 " { 'type': 'directory', 'name': '//root/path/to////',\n"
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000970 " 'contents': [ { 'type': 'file', 'name': 'file',\n"
Ben Langmuir93853232014-03-05 21:32:20 +0000971 " 'external-contents': '//root/other' }]}]\n"
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000972 "}", Lower);
Alp Tokerf994cef2014-07-05 03:08:06 +0000973 ASSERT_TRUE(nullptr != FS.get());
Rafael Espindola3ae06202014-05-31 03:20:52 +0000974 EXPECT_FALSE(FS->status("//root/path/to/file").getError());
975 EXPECT_FALSE(FS->status("//root/path/to").getError());
976 EXPECT_FALSE(FS->status("//root/path").getError());
977 EXPECT_FALSE(FS->status("//root/").getError());
Ben Langmuir47ff9ab2014-02-25 04:34:14 +0000978}
Ben Langmuir740812b2014-06-24 19:37:16 +0000979
980TEST_F(VFSFromYAMLTest, DirectoryIteration) {
981 IntrusiveRefCntPtr<DummyFileSystem> Lower(new DummyFileSystem());
982 Lower->addDirectory("//root/");
983 Lower->addDirectory("//root/foo");
984 Lower->addDirectory("//root/foo/bar");
985 Lower->addRegularFile("//root/foo/bar/a");
986 Lower->addRegularFile("//root/foo/bar/b");
987 Lower->addRegularFile("//root/file3");
988 IntrusiveRefCntPtr<vfs::FileSystem> FS =
989 getFromYAMLString("{ 'use-external-names': false,\n"
990 " 'roots': [\n"
991 "{\n"
992 " 'type': 'directory',\n"
993 " 'name': '//root/',\n"
994 " 'contents': [ {\n"
995 " 'type': 'file',\n"
996 " 'name': 'file1',\n"
997 " 'external-contents': '//root/foo/bar/a'\n"
998 " },\n"
999 " {\n"
1000 " 'type': 'file',\n"
1001 " 'name': 'file2',\n"
1002 " 'external-contents': '//root/foo/bar/b'\n"
1003 " }\n"
1004 " ]\n"
1005 "}\n"
1006 "]\n"
1007 "}",
1008 Lower);
Hans Wennborgdcfba332015-10-06 23:40:43 +00001009 ASSERT_TRUE(FS.get() != nullptr);
Ben Langmuir740812b2014-06-24 19:37:16 +00001010
1011 IntrusiveRefCntPtr<vfs::OverlayFileSystem> O(
1012 new vfs::OverlayFileSystem(Lower));
1013 O->pushOverlay(FS);
1014
1015 std::error_code EC;
1016 {
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +00001017 const char *Contents[] = {"//root/file1", "//root/file2", "//root/file3",
1018 "//root/foo"};
1019 checkContents(O->dir_begin("//root/", EC), makeStringRefVector(Contents));
Ben Langmuir740812b2014-06-24 19:37:16 +00001020 }
1021
1022 {
NAKAMURA Takumi4669bd42014-06-25 04:34:10 +00001023 const char *Contents[] = {"//root/foo/bar/a", "//root/foo/bar/b"};
1024 checkContents(O->dir_begin("//root/foo/bar", EC),
1025 makeStringRefVector(Contents));
Ben Langmuir740812b2014-06-24 19:37:16 +00001026 }
1027}