1//===- unittests/Basic/FileMangerTest.cpp ------------ FileManger 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 "clang/Basic/FileManager.h"
10#include "clang/Basic/FileSystemOptions.h"
11#include "clang/Basic/FileSystemStatCache.h"
12#include "llvm/ADT/STLExtras.h"
13#include "llvm/Support/Path.h"
14#include "llvm/Support/VirtualFileSystem.h"
15#include "llvm/Testing/Support/Error.h"
16#include "gtest/gtest.h"
17
18using namespace llvm;
19using namespace clang;
20
21namespace {
22
23// Used to create a fake file system for running the tests with such
24// that the tests are not affected by the structure/contents of the
25// file system on the machine running the tests.
26class FakeStatCache : public FileSystemStatCache {
27private:
28 // Maps a file/directory path to its desired stat result. Anything
29 // not in this map is considered to not exist in the file system.
30 llvm::StringMap<llvm::vfs::Status, llvm::BumpPtrAllocator> StatCalls;
31
32 void InjectFileOrDirectory(const char *Path, ino_t INode, bool IsFile,
33 const char *StatPath) {
34 SmallString<128> NormalizedPath(Path);
35 SmallString<128> NormalizedStatPath;
36 if (is_style_posix(S: llvm::sys::path::Style::native)) {
37 llvm::sys::path::native(path&: NormalizedPath);
38 Path = NormalizedPath.c_str();
39
40 if (StatPath) {
41 NormalizedStatPath = StatPath;
42 llvm::sys::path::native(path&: NormalizedStatPath);
43 StatPath = NormalizedStatPath.c_str();
44 }
45 }
46
47 auto fileType = IsFile ?
48 llvm::sys::fs::file_type::regular_file :
49 llvm::sys::fs::file_type::directory_file;
50 llvm::vfs::Status Status(StatPath ? StatPath : Path,
51 llvm::sys::fs::UniqueID(1, INode),
52 /*MTime*/{}, /*User*/0, /*Group*/0,
53 /*Size*/0, fileType,
54 llvm::sys::fs::perms::all_all);
55 if (StatPath)
56 Status.ExposesExternalVFSPath = true;
57 StatCalls[Path] = Status;
58 }
59
60public:
61 // Inject a file with the given inode value to the fake file system.
62 void InjectFile(const char *Path, ino_t INode,
63 const char *StatPath = nullptr) {
64 InjectFileOrDirectory(Path, INode, /*IsFile=*/true, StatPath);
65 }
66
67 // Inject a directory with the given inode value to the fake file system.
68 void InjectDirectory(const char *Path, ino_t INode) {
69 InjectFileOrDirectory(Path, INode, /*IsFile=*/false, StatPath: nullptr);
70 }
71
72 // Implement FileSystemStatCache::getStat().
73 std::error_code getStat(StringRef Path, llvm::vfs::Status &Status,
74 bool isFile,
75 std::unique_ptr<llvm::vfs::File> *F,
76 llvm::vfs::FileSystem &FS) override {
77 SmallString<128> NormalizedPath(Path);
78 if (is_style_posix(S: llvm::sys::path::Style::native)) {
79 llvm::sys::path::native(path&: NormalizedPath);
80 Path = NormalizedPath.c_str();
81 }
82
83 if (StatCalls.count(Key: Path) != 0) {
84 Status = StatCalls[Path];
85 return std::error_code();
86 }
87
88 return std::make_error_code(e: std::errc::no_such_file_or_directory);
89 }
90};
91
92// The test fixture.
93class FileManagerTest : public ::testing::Test {
94 protected:
95 FileManagerTest() : manager(options) {
96 }
97
98 FileSystemOptions options;
99 FileManager manager;
100};
101
102// When a virtual file is added, its getDir() field has correct name.
103TEST_F(FileManagerTest, getVirtualFileSetsTheDirFieldCorrectly) {
104 FileEntryRef file = manager.getVirtualFileRef(Filename: "foo.cpp", Size: 42, ModificationTime: 0);
105 EXPECT_EQ(".", file.getDir().getName());
106
107 file = manager.getVirtualFileRef(Filename: "x/y/z.cpp", Size: 42, ModificationTime: 0);
108 EXPECT_EQ("x/y", file.getDir().getName());
109}
110
111// Before any virtual file is added, no virtual directory exists.
112TEST_F(FileManagerTest, NoVirtualDirectoryExistsBeforeAVirtualFileIsAdded) {
113 // An empty FakeStatCache causes all stat calls made by the
114 // FileManager to report "file/directory doesn't exist". This
115 // avoids the possibility of the result of this test being affected
116 // by what's in the real file system.
117 manager.setStatCache(std::make_unique<FakeStatCache>());
118
119 ASSERT_FALSE(manager.getDirectory("virtual/dir/foo"));
120 ASSERT_FALSE(manager.getDirectory("virtual/dir"));
121 ASSERT_FALSE(manager.getDirectory("virtual"));
122}
123
124// When a virtual file is added, all of its ancestors should be created.
125TEST_F(FileManagerTest, getVirtualFileCreatesDirectoryEntriesForAncestors) {
126 // Fake an empty real file system.
127 manager.setStatCache(std::make_unique<FakeStatCache>());
128
129 manager.getVirtualFile(Filename: "virtual/dir/bar.h", Size: 100, ModificationTime: 0);
130 ASSERT_FALSE(manager.getDirectory("virtual/dir/foo"));
131
132 auto dir = manager.getDirectoryRef(DirName: "virtual/dir");
133 ASSERT_THAT_EXPECTED(dir, llvm::Succeeded());
134 EXPECT_EQ("virtual/dir", dir->getName());
135
136 dir = manager.getDirectoryRef(DirName: "virtual");
137 ASSERT_THAT_EXPECTED(dir, llvm::Succeeded());
138 EXPECT_EQ("virtual", dir->getName());
139}
140
141// getFileRef() succeeds if a real file exists at the given path.
142TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingRealFile) {
143 // Inject fake files into the file system.
144 auto statCache = std::make_unique<FakeStatCache>();
145 statCache->InjectDirectory(Path: "/tmp", INode: 42);
146 statCache->InjectFile(Path: "/tmp/test", INode: 43);
147
148#ifdef _WIN32
149 const char *DirName = "C:.";
150 const char *FileName = "C:test";
151 statCache->InjectDirectory(DirName, 44);
152 statCache->InjectFile(FileName, 45);
153#endif
154
155 manager.setStatCache(std::move(statCache));
156
157 auto file = manager.getFileRef(Filename: "/tmp/test");
158 ASSERT_THAT_EXPECTED(file, llvm::Succeeded());
159 EXPECT_EQ("/tmp/test", file->getName());
160
161 EXPECT_EQ("/tmp", file->getDir().getName());
162
163#ifdef _WIN32
164 file = manager.getFileRef(FileName);
165 ASSERT_THAT_EXPECTED(file, llvm::Succeeded());
166 EXPECT_EQ(DirName, file->getDir().getName());
167#endif
168}
169
170// getFileRef() succeeds if a virtual file exists at the given path.
171TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingVirtualFile) {
172 // Fake an empty real file system.
173 manager.setStatCache(std::make_unique<FakeStatCache>());
174
175 manager.getVirtualFile(Filename: "virtual/dir/bar.h", Size: 100, ModificationTime: 0);
176 auto file = manager.getFileRef(Filename: "virtual/dir/bar.h");
177 ASSERT_THAT_EXPECTED(file, llvm::Succeeded());
178 EXPECT_EQ("virtual/dir/bar.h", file->getName());
179 EXPECT_EQ("virtual/dir", file->getDir().getName());
180}
181
182// getFile() returns different FileEntries for different paths when
183// there's no aliasing.
184TEST_F(FileManagerTest, getFileReturnsDifferentFileEntriesForDifferentFiles) {
185 // Inject two fake files into the file system. Different inodes
186 // mean the files are not symlinked together.
187 auto statCache = std::make_unique<FakeStatCache>();
188 statCache->InjectDirectory(Path: ".", INode: 41);
189 statCache->InjectFile(Path: "foo.cpp", INode: 42);
190 statCache->InjectFile(Path: "bar.cpp", INode: 43);
191 manager.setStatCache(std::move(statCache));
192
193 auto fileFoo = manager.getFile(Filename: "foo.cpp");
194 auto fileBar = manager.getFile(Filename: "bar.cpp");
195 ASSERT_TRUE(fileFoo);
196 ASSERT_TRUE(fileBar);
197 EXPECT_NE(*fileFoo, *fileBar);
198}
199
200// getFile() returns an error if neither a real file nor a virtual file
201// exists at the given path.
202TEST_F(FileManagerTest, getFileReturnsErrorForNonexistentFile) {
203 // Inject a fake foo.cpp into the file system.
204 auto statCache = std::make_unique<FakeStatCache>();
205 statCache->InjectDirectory(Path: ".", INode: 41);
206 statCache->InjectFile(Path: "foo.cpp", INode: 42);
207 statCache->InjectDirectory(Path: "MyDirectory", INode: 49);
208 manager.setStatCache(std::move(statCache));
209
210 // Create a virtual bar.cpp file.
211 manager.getVirtualFile(Filename: "bar.cpp", Size: 200, ModificationTime: 0);
212
213 auto file = manager.getFile(Filename: "xyz.txt");
214 ASSERT_FALSE(file);
215 ASSERT_EQ(file.getError(), std::errc::no_such_file_or_directory);
216
217 auto readingDirAsFile = manager.getFile(Filename: "MyDirectory");
218 ASSERT_FALSE(readingDirAsFile);
219 ASSERT_EQ(readingDirAsFile.getError(), std::errc::is_a_directory);
220
221 auto readingFileAsDir = manager.getDirectory(DirName: "foo.cpp");
222 ASSERT_FALSE(readingFileAsDir);
223 ASSERT_EQ(readingFileAsDir.getError(), std::errc::not_a_directory);
224}
225
226// The following tests apply to Unix-like system only.
227
228#ifndef _WIN32
229
230// getFile() returns the same FileEntry for real files that are aliases.
231TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedRealFiles) {
232 // Inject two real files with the same inode.
233 auto statCache = std::make_unique<FakeStatCache>();
234 statCache->InjectDirectory(Path: "abc", INode: 41);
235 statCache->InjectFile(Path: "abc/foo.cpp", INode: 42);
236 statCache->InjectFile(Path: "abc/bar.cpp", INode: 42);
237 manager.setStatCache(std::move(statCache));
238
239 auto f1 = manager.getFile(Filename: "abc/foo.cpp");
240 auto f2 = manager.getFile(Filename: "abc/bar.cpp");
241
242 EXPECT_EQ(f1 ? *f1 : nullptr,
243 f2 ? *f2 : nullptr);
244
245 // Check that getFileRef also does the right thing.
246 auto r1 = manager.getFileRef(Filename: "abc/foo.cpp");
247 auto r2 = manager.getFileRef(Filename: "abc/bar.cpp");
248 ASSERT_FALSE(!r1);
249 ASSERT_FALSE(!r2);
250
251 EXPECT_EQ("abc/foo.cpp", r1->getName());
252 EXPECT_EQ("abc/bar.cpp", r2->getName());
253 EXPECT_EQ((f1 ? *f1 : nullptr), &r1->getFileEntry());
254 EXPECT_EQ((f2 ? *f2 : nullptr), &r2->getFileEntry());
255}
256
257TEST_F(FileManagerTest, getFileRefReturnsCorrectNameForDifferentStatPath) {
258 // Inject files with the same inode, but where some files have a stat that
259 // gives a different name. This is adding coverage for stat behaviour
260 // triggered by the RedirectingFileSystem for 'use-external-name' that
261 // FileManager::getFileRef has special logic for.
262 auto StatCache = std::make_unique<FakeStatCache>();
263 StatCache->InjectDirectory(Path: "dir", INode: 40);
264 StatCache->InjectFile(Path: "dir/f1.cpp", INode: 41);
265 StatCache->InjectFile(Path: "dir/f1-alias.cpp", INode: 41, StatPath: "dir/f1.cpp");
266 StatCache->InjectFile(Path: "dir/f2.cpp", INode: 42);
267 StatCache->InjectFile(Path: "dir/f2-alias.cpp", INode: 42, StatPath: "dir/f2.cpp");
268
269 // This unintuitive rename-the-file-on-stat behaviour supports how the
270 // RedirectingFileSystem VFS layer responds to stats. However, even if you
271 // have two layers, you should only get a single filename back. As such the
272 // following stat cache behaviour is not supported (the correct stat entry
273 // for a double-redirection would be "dir/f1.cpp") and the getFileRef below
274 // should assert.
275 StatCache->InjectFile(Path: "dir/f1-alias-alias.cpp", INode: 41, StatPath: "dir/f1-alias.cpp");
276
277 manager.setStatCache(std::move(StatCache));
278
279 // With F1, test accessing the non-redirected name first.
280 auto F1 = manager.getFileRef(Filename: "dir/f1.cpp");
281 auto F1Alias = manager.getFileRef(Filename: "dir/f1-alias.cpp");
282 auto F1Alias2 = manager.getFileRef(Filename: "dir/f1-alias.cpp");
283 ASSERT_FALSE(!F1);
284 ASSERT_FALSE(!F1Alias);
285 ASSERT_FALSE(!F1Alias2);
286 EXPECT_EQ("dir/f1.cpp", F1->getName());
287 EXPECT_EQ("dir/f1.cpp", F1Alias->getName());
288 EXPECT_EQ("dir/f1.cpp", F1Alias2->getName());
289 EXPECT_EQ(&F1->getFileEntry(), &F1Alias->getFileEntry());
290 EXPECT_EQ(&F1->getFileEntry(), &F1Alias2->getFileEntry());
291
292#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
293 EXPECT_DEATH((void)manager.getFileRef("dir/f1-alias-alias.cpp"),
294 "filename redirected to a non-canonical filename?");
295#endif
296
297 // With F2, test accessing the redirected name first.
298 auto F2Alias = manager.getFileRef(Filename: "dir/f2-alias.cpp");
299 auto F2 = manager.getFileRef(Filename: "dir/f2.cpp");
300 auto F2Alias2 = manager.getFileRef(Filename: "dir/f2-alias.cpp");
301 ASSERT_FALSE(!F2);
302 ASSERT_FALSE(!F2Alias);
303 ASSERT_FALSE(!F2Alias2);
304 EXPECT_EQ("dir/f2.cpp", F2->getName());
305 EXPECT_EQ("dir/f2.cpp", F2Alias->getName());
306 EXPECT_EQ("dir/f2.cpp", F2Alias2->getName());
307 EXPECT_EQ(&F2->getFileEntry(), &F2Alias->getFileEntry());
308 EXPECT_EQ(&F2->getFileEntry(), &F2Alias2->getFileEntry());
309}
310
311TEST_F(FileManagerTest, getFileRefReturnsCorrectDirNameForDifferentStatPath) {
312 // Inject files with the same inode into distinct directories (name & inode).
313 auto StatCache = std::make_unique<FakeStatCache>();
314 StatCache->InjectDirectory(Path: "dir1", INode: 40);
315 StatCache->InjectDirectory(Path: "dir2", INode: 41);
316 StatCache->InjectFile(Path: "dir1/f.cpp", INode: 42);
317 StatCache->InjectFile(Path: "dir2/f.cpp", INode: 42, StatPath: "dir1/f.cpp");
318
319 manager.setStatCache(std::move(StatCache));
320 auto Dir1F = manager.getFileRef(Filename: "dir1/f.cpp");
321 auto Dir2F = manager.getFileRef(Filename: "dir2/f.cpp");
322
323 ASSERT_FALSE(!Dir1F);
324 ASSERT_FALSE(!Dir2F);
325 EXPECT_EQ("dir1", Dir1F->getDir().getName());
326 EXPECT_EQ("dir2", Dir2F->getDir().getName());
327 EXPECT_EQ("dir1/f.cpp", Dir1F->getNameAsRequested());
328 EXPECT_EQ("dir2/f.cpp", Dir2F->getNameAsRequested());
329}
330
331// getFile() returns the same FileEntry for virtual files that have
332// corresponding real files that are aliases.
333TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedVirtualFiles) {
334 // Inject two real files with the same inode.
335 auto statCache = std::make_unique<FakeStatCache>();
336 statCache->InjectDirectory(Path: "abc", INode: 41);
337 statCache->InjectFile(Path: "abc/foo.cpp", INode: 42);
338 statCache->InjectFile(Path: "abc/bar.cpp", INode: 42);
339 manager.setStatCache(std::move(statCache));
340
341 auto f1 = manager.getFile(Filename: "abc/foo.cpp");
342 auto f2 = manager.getFile(Filename: "abc/bar.cpp");
343
344 EXPECT_EQ(f1 ? *f1 : nullptr,
345 f2 ? *f2 : nullptr);
346}
347
348TEST_F(FileManagerTest, getFileRefEquality) {
349 auto StatCache = std::make_unique<FakeStatCache>();
350 StatCache->InjectDirectory(Path: "dir", INode: 40);
351 StatCache->InjectFile(Path: "dir/f1.cpp", INode: 41);
352 StatCache->InjectFile(Path: "dir/f1-also.cpp", INode: 41);
353 StatCache->InjectFile(Path: "dir/f1-redirect.cpp", INode: 41, StatPath: "dir/f1.cpp");
354 StatCache->InjectFile(Path: "dir/f2.cpp", INode: 42);
355 manager.setStatCache(std::move(StatCache));
356
357 auto F1 = manager.getFileRef(Filename: "dir/f1.cpp");
358 auto F1Again = manager.getFileRef(Filename: "dir/f1.cpp");
359 auto F1Also = manager.getFileRef(Filename: "dir/f1-also.cpp");
360 auto F1Redirect = manager.getFileRef(Filename: "dir/f1-redirect.cpp");
361 auto F1RedirectAgain = manager.getFileRef(Filename: "dir/f1-redirect.cpp");
362 auto F2 = manager.getFileRef(Filename: "dir/f2.cpp");
363
364 // Check Expected<FileEntryRef> for error.
365 ASSERT_FALSE(!F1);
366 ASSERT_FALSE(!F1Also);
367 ASSERT_FALSE(!F1Again);
368 ASSERT_FALSE(!F1Redirect);
369 ASSERT_FALSE(!F1RedirectAgain);
370 ASSERT_FALSE(!F2);
371
372 // Check names.
373 EXPECT_EQ("dir/f1.cpp", F1->getName());
374 EXPECT_EQ("dir/f1.cpp", F1Again->getName());
375 EXPECT_EQ("dir/f1-also.cpp", F1Also->getName());
376 EXPECT_EQ("dir/f1.cpp", F1Redirect->getName());
377 EXPECT_EQ("dir/f1.cpp", F1RedirectAgain->getName());
378 EXPECT_EQ("dir/f2.cpp", F2->getName());
379
380 EXPECT_EQ("dir/f1.cpp", F1->getNameAsRequested());
381 EXPECT_EQ("dir/f1-redirect.cpp", F1Redirect->getNameAsRequested());
382
383 // Compare against FileEntry*.
384 EXPECT_EQ(&F1->getFileEntry(), *F1);
385 EXPECT_EQ(*F1, &F1->getFileEntry());
386 EXPECT_EQ(&F1->getFileEntry(), &F1Redirect->getFileEntry());
387 EXPECT_EQ(&F1->getFileEntry(), &F1RedirectAgain->getFileEntry());
388 EXPECT_NE(&F2->getFileEntry(), *F1);
389 EXPECT_NE(*F1, &F2->getFileEntry());
390
391 // Compare using ==.
392 EXPECT_EQ(*F1, *F1Also);
393 EXPECT_EQ(*F1, *F1Again);
394 EXPECT_EQ(*F1, *F1Redirect);
395 EXPECT_EQ(*F1Also, *F1Redirect);
396 EXPECT_EQ(*F1, *F1RedirectAgain);
397 EXPECT_NE(*F2, *F1);
398 EXPECT_NE(*F2, *F1Also);
399 EXPECT_NE(*F2, *F1Again);
400 EXPECT_NE(*F2, *F1Redirect);
401
402 // Compare using isSameRef.
403 EXPECT_TRUE(F1->isSameRef(*F1Again));
404 EXPECT_FALSE(F1->isSameRef(*F1Redirect));
405 EXPECT_FALSE(F1->isSameRef(*F1Also));
406 EXPECT_FALSE(F1->isSameRef(*F2));
407 EXPECT_TRUE(F1Redirect->isSameRef(*F1RedirectAgain));
408}
409
410// getFile() Should return the same entry as getVirtualFile if the file actually
411// is a virtual file, even if the name is not exactly the same (but is after
412// normalisation done by the file system, like on Windows). This can be checked
413// here by checking the size.
414TEST_F(FileManagerTest, getVirtualFileWithDifferentName) {
415 // Inject fake files into the file system.
416 auto statCache = std::make_unique<FakeStatCache>();
417 statCache->InjectDirectory(Path: "c:\\tmp", INode: 42);
418 statCache->InjectFile(Path: "c:\\tmp\\test", INode: 43);
419
420 manager.setStatCache(std::move(statCache));
421
422 // Inject the virtual file:
423 const FileEntry *file1 = manager.getVirtualFile(Filename: "c:\\tmp\\test", Size: 123, ModificationTime: 1);
424 ASSERT_TRUE(file1 != nullptr);
425 EXPECT_EQ(43U, file1->getUniqueID().getFile());
426 EXPECT_EQ(123, file1->getSize());
427
428 // Lookup the virtual file with a different name:
429 auto file2 = manager.getFile(Filename: "c:/tmp/test", OpenFile: 100, CacheFailure: 1);
430 ASSERT_TRUE(file2);
431 // Check that it's the same UFE:
432 EXPECT_EQ(file1, *file2);
433 EXPECT_EQ(43U, (*file2)->getUniqueID().getFile());
434 // Check that the contents of the UFE are not overwritten by the entry in the
435 // filesystem:
436 EXPECT_EQ(123, (*file2)->getSize());
437}
438
439#endif // !_WIN32
440
441static StringRef getSystemRoot() {
442 return is_style_windows(S: llvm::sys::path::Style::native) ? "C:\\" : "/";
443}
444
445TEST_F(FileManagerTest, makeAbsoluteUsesVFS) {
446 // FIXME: Should this be using a root path / call getSystemRoot()? For now,
447 // avoiding that and leaving the test as-is.
448 SmallString<64> CustomWorkingDir =
449 is_style_windows(S: llvm::sys::path::Style::native) ? StringRef("C:")
450 : StringRef("/");
451 llvm::sys::path::append(path&: CustomWorkingDir, a: "some", b: "weird", c: "path");
452
453 auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
454 new llvm::vfs::InMemoryFileSystem);
455 // setCurrentworkingdirectory must finish without error.
456 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
457
458 FileSystemOptions Opts;
459 FileManager Manager(Opts, FS);
460
461 SmallString<64> Path("a/foo.cpp");
462
463 SmallString<64> ExpectedResult(CustomWorkingDir);
464 llvm::sys::path::append(path&: ExpectedResult, a: Path);
465
466 ASSERT_TRUE(Manager.makeAbsolutePath(Path));
467 EXPECT_EQ(Path, ExpectedResult);
468}
469
470// getVirtualFile should always fill the real path.
471TEST_F(FileManagerTest, getVirtualFileFillsRealPathName) {
472 SmallString<64> CustomWorkingDir = getSystemRoot();
473
474 auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
475 new llvm::vfs::InMemoryFileSystem);
476 // setCurrentworkingdirectory must finish without error.
477 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
478
479 FileSystemOptions Opts;
480 FileManager Manager(Opts, FS);
481
482 // Inject fake files into the file system.
483 auto statCache = std::make_unique<FakeStatCache>();
484 statCache->InjectDirectory(Path: "/tmp", INode: 42);
485 statCache->InjectFile(Path: "/tmp/test", INode: 43);
486
487 Manager.setStatCache(std::move(statCache));
488
489 // Check for real path.
490 const FileEntry *file = Manager.getVirtualFile(Filename: "/tmp/test", Size: 123, ModificationTime: 1);
491 ASSERT_TRUE(file != nullptr);
492 SmallString<64> ExpectedResult = CustomWorkingDir;
493
494 llvm::sys::path::append(path&: ExpectedResult, a: "tmp", b: "test");
495 EXPECT_EQ(file->tryGetRealPathName(), ExpectedResult);
496}
497
498TEST_F(FileManagerTest, getFileDontOpenRealPath) {
499 SmallString<64> CustomWorkingDir = getSystemRoot();
500
501 auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
502 new llvm::vfs::InMemoryFileSystem);
503 // setCurrentworkingdirectory must finish without error.
504 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
505
506 FileSystemOptions Opts;
507 FileManager Manager(Opts, FS);
508
509 // Inject fake files into the file system.
510 auto statCache = std::make_unique<FakeStatCache>();
511 statCache->InjectDirectory(Path: "/tmp", INode: 42);
512 statCache->InjectFile(Path: "/tmp/test", INode: 43);
513
514 Manager.setStatCache(std::move(statCache));
515
516 // Check for real path.
517 auto file = Manager.getFile(Filename: "/tmp/test", /*OpenFile=*/false);
518 ASSERT_TRUE(file);
519 SmallString<64> ExpectedResult = CustomWorkingDir;
520
521 llvm::sys::path::append(path&: ExpectedResult, a: "tmp", b: "test");
522 EXPECT_EQ((*file)->tryGetRealPathName(), ExpectedResult);
523}
524
525TEST_F(FileManagerTest, getBypassFile) {
526 SmallString<64> CustomWorkingDir;
527#ifdef _WIN32
528 CustomWorkingDir = "C:/";
529#else
530 CustomWorkingDir = "/";
531#endif
532
533 auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
534 new llvm::vfs::InMemoryFileSystem);
535 // setCurrentworkingdirectory must finish without error.
536 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
537
538 FileSystemOptions Opts;
539 FileManager Manager(Opts, FS);
540
541 // Inject fake files into the file system.
542 auto Cache = std::make_unique<FakeStatCache>();
543 Cache->InjectDirectory(Path: "/tmp", INode: 42);
544 Cache->InjectFile(Path: "/tmp/test", INode: 43);
545 Manager.setStatCache(std::move(Cache));
546
547 // Set up a virtual file with a different size than FakeStatCache uses.
548 FileEntryRef File = Manager.getVirtualFileRef(Filename: "/tmp/test", /*Size=*/10, ModificationTime: 0);
549 ASSERT_TRUE(File);
550 const FileEntry &FE = *File;
551 EXPECT_EQ(FE.getSize(), 10);
552
553 // Calling a second time should not affect the UID or size.
554 unsigned VirtualUID = FE.getUID();
555 OptionalFileEntryRef SearchRef;
556 ASSERT_THAT_ERROR(Manager.getFileRef("/tmp/test").moveInto(SearchRef),
557 Succeeded());
558 EXPECT_EQ(&FE, &SearchRef->getFileEntry());
559 EXPECT_EQ(FE.getUID(), VirtualUID);
560 EXPECT_EQ(FE.getSize(), 10);
561
562 // Bypass the file.
563 OptionalFileEntryRef BypassRef = Manager.getBypassFile(VFE: File);
564 ASSERT_TRUE(BypassRef);
565 EXPECT_EQ("/tmp/test", BypassRef->getName());
566
567 // Check that it's different in the right ways.
568 EXPECT_NE(&BypassRef->getFileEntry(), File);
569 EXPECT_NE(BypassRef->getUID(), VirtualUID);
570 EXPECT_NE(BypassRef->getSize(), FE.getSize());
571
572 // The virtual file should still be returned when searching.
573 ASSERT_THAT_ERROR(Manager.getFileRef("/tmp/test").moveInto(SearchRef),
574 Succeeded());
575 EXPECT_EQ(&FE, &SearchRef->getFileEntry());
576}
577
578} // anonymous namespace
579

source code of clang/unittests/Basic/FileManagerTest.cpp