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