1 //===- unittests/Basic/FileMangerTest.cpp ------------ FileManger tests ---===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "clang/Basic/FileManager.h"
11 #include "clang/Basic/FileSystemOptions.h"
12 #include "clang/Basic/FileSystemStatCache.h"
13 #include "llvm/ADT/STLExtras.h"
14 #include "llvm/Support/Path.h"
15 #include "llvm/Support/VirtualFileSystem.h"
16 #include "gtest/gtest.h"
17 
18 using namespace llvm;
19 using namespace clang;
20 
21 namespace {
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.
26 class FakeStatCache : public FileSystemStatCache {
27 private:
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<FileData, llvm::BumpPtrAllocator> StatCalls;
31 
32   void InjectFileOrDirectory(const char *Path, ino_t INode, bool IsFile) {
33 #ifndef _WIN32
34     SmallString<128> NormalizedPath(Path);
35     llvm::sys::path::native(NormalizedPath);
36     Path = NormalizedPath.c_str();
37 #endif
38 
39     FileData Data;
40     Data.Name = Path;
41     Data.Size = 0;
42     Data.ModTime = 0;
43     Data.UniqueID = llvm::sys::fs::UniqueID(1, INode);
44     Data.IsDirectory = !IsFile;
45     Data.IsNamedPipe = false;
46     Data.InPCH = false;
47     StatCalls[Path] = Data;
48   }
49 
50 public:
51   // Inject a file with the given inode value to the fake file system.
52   void InjectFile(const char *Path, ino_t INode) {
53     InjectFileOrDirectory(Path, INode, /*IsFile=*/true);
54   }
55 
56   // Inject a directory with the given inode value to the fake file system.
57   void InjectDirectory(const char *Path, ino_t INode) {
58     InjectFileOrDirectory(Path, INode, /*IsFile=*/false);
59   }
60 
61   // Implement FileSystemStatCache::getStat().
62   LookupResult getStat(StringRef Path, FileData &Data, bool isFile,
63                        std::unique_ptr<llvm::vfs::File> *F,
64                        llvm::vfs::FileSystem &FS) override {
65 #ifndef _WIN32
66     SmallString<128> NormalizedPath(Path);
67     llvm::sys::path::native(NormalizedPath);
68     Path = NormalizedPath.c_str();
69 #endif
70 
71     if (StatCalls.count(Path) != 0) {
72       Data = StatCalls[Path];
73       return CacheExists;
74     }
75 
76     return CacheMissing;  // This means the file/directory doesn't exist.
77   }
78 };
79 
80 // The test fixture.
81 class FileManagerTest : public ::testing::Test {
82  protected:
83   FileManagerTest() : manager(options) {
84   }
85 
86   FileSystemOptions options;
87   FileManager manager;
88 };
89 
90 // When a virtual file is added, its getDir() field is set correctly
91 // (not NULL, correct name).
92 TEST_F(FileManagerTest, getVirtualFileSetsTheDirFieldCorrectly) {
93   const FileEntry *file = manager.getVirtualFile("foo.cpp", 42, 0);
94   ASSERT_TRUE(file != nullptr);
95 
96   const DirectoryEntry *dir = file->getDir();
97   ASSERT_TRUE(dir != nullptr);
98   EXPECT_EQ(".", dir->getName());
99 
100   file = manager.getVirtualFile("x/y/z.cpp", 42, 0);
101   ASSERT_TRUE(file != nullptr);
102 
103   dir = file->getDir();
104   ASSERT_TRUE(dir != nullptr);
105   EXPECT_EQ("x/y", dir->getName());
106 }
107 
108 // Before any virtual file is added, no virtual directory exists.
109 TEST_F(FileManagerTest, NoVirtualDirectoryExistsBeforeAVirtualFileIsAdded) {
110   // An empty FakeStatCache causes all stat calls made by the
111   // FileManager to report "file/directory doesn't exist".  This
112   // avoids the possibility of the result of this test being affected
113   // by what's in the real file system.
114   manager.setStatCache(llvm::make_unique<FakeStatCache>());
115 
116   EXPECT_EQ(nullptr, manager.getDirectory("virtual/dir/foo"));
117   EXPECT_EQ(nullptr, manager.getDirectory("virtual/dir"));
118   EXPECT_EQ(nullptr, manager.getDirectory("virtual"));
119 }
120 
121 // When a virtual file is added, all of its ancestors should be created.
122 TEST_F(FileManagerTest, getVirtualFileCreatesDirectoryEntriesForAncestors) {
123   // Fake an empty real file system.
124   manager.setStatCache(llvm::make_unique<FakeStatCache>());
125 
126   manager.getVirtualFile("virtual/dir/bar.h", 100, 0);
127   EXPECT_EQ(nullptr, manager.getDirectory("virtual/dir/foo"));
128 
129   const DirectoryEntry *dir = manager.getDirectory("virtual/dir");
130   ASSERT_TRUE(dir != nullptr);
131   EXPECT_EQ("virtual/dir", dir->getName());
132 
133   dir = manager.getDirectory("virtual");
134   ASSERT_TRUE(dir != nullptr);
135   EXPECT_EQ("virtual", dir->getName());
136 }
137 
138 // getFile() returns non-NULL if a real file exists at the given path.
139 TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingRealFile) {
140   // Inject fake files into the file system.
141   auto statCache = llvm::make_unique<FakeStatCache>();
142   statCache->InjectDirectory("/tmp", 42);
143   statCache->InjectFile("/tmp/test", 43);
144 
145 #ifdef _WIN32
146   const char *DirName = "C:.";
147   const char *FileName = "C:test";
148   statCache->InjectDirectory(DirName, 44);
149   statCache->InjectFile(FileName, 45);
150 #endif
151 
152   manager.setStatCache(std::move(statCache));
153 
154   const FileEntry *file = manager.getFile("/tmp/test");
155   ASSERT_TRUE(file != nullptr);
156   ASSERT_TRUE(file->isValid());
157   EXPECT_EQ("/tmp/test", file->getName());
158 
159   const DirectoryEntry *dir = file->getDir();
160   ASSERT_TRUE(dir != nullptr);
161   EXPECT_EQ("/tmp", dir->getName());
162 
163 #ifdef _WIN32
164   file = manager.getFile(FileName);
165   ASSERT_TRUE(file != NULL);
166 
167   dir = file->getDir();
168   ASSERT_TRUE(dir != NULL);
169   EXPECT_EQ(DirName, dir->getName());
170 #endif
171 }
172 
173 // getFile() returns non-NULL if a virtual file exists at the given path.
174 TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingVirtualFile) {
175   // Fake an empty real file system.
176   manager.setStatCache(llvm::make_unique<FakeStatCache>());
177 
178   manager.getVirtualFile("virtual/dir/bar.h", 100, 0);
179   const FileEntry *file = manager.getFile("virtual/dir/bar.h");
180   ASSERT_TRUE(file != nullptr);
181   ASSERT_TRUE(file->isValid());
182   EXPECT_EQ("virtual/dir/bar.h", file->getName());
183 
184   const DirectoryEntry *dir = file->getDir();
185   ASSERT_TRUE(dir != nullptr);
186   EXPECT_EQ("virtual/dir", dir->getName());
187 }
188 
189 // getFile() returns different FileEntries for different paths when
190 // there's no aliasing.
191 TEST_F(FileManagerTest, getFileReturnsDifferentFileEntriesForDifferentFiles) {
192   // Inject two fake files into the file system.  Different inodes
193   // mean the files are not symlinked together.
194   auto statCache = llvm::make_unique<FakeStatCache>();
195   statCache->InjectDirectory(".", 41);
196   statCache->InjectFile("foo.cpp", 42);
197   statCache->InjectFile("bar.cpp", 43);
198   manager.setStatCache(std::move(statCache));
199 
200   const FileEntry *fileFoo = manager.getFile("foo.cpp");
201   const FileEntry *fileBar = manager.getFile("bar.cpp");
202   ASSERT_TRUE(fileFoo != nullptr);
203   ASSERT_TRUE(fileFoo->isValid());
204   ASSERT_TRUE(fileBar != nullptr);
205   ASSERT_TRUE(fileBar->isValid());
206   EXPECT_NE(fileFoo, fileBar);
207 }
208 
209 // getFile() returns NULL if neither a real file nor a virtual file
210 // exists at the given path.
211 TEST_F(FileManagerTest, getFileReturnsNULLForNonexistentFile) {
212   // Inject a fake foo.cpp into the file system.
213   auto statCache = llvm::make_unique<FakeStatCache>();
214   statCache->InjectDirectory(".", 41);
215   statCache->InjectFile("foo.cpp", 42);
216   manager.setStatCache(std::move(statCache));
217 
218   // Create a virtual bar.cpp file.
219   manager.getVirtualFile("bar.cpp", 200, 0);
220 
221   const FileEntry *file = manager.getFile("xyz.txt");
222   EXPECT_EQ(nullptr, file);
223 }
224 
225 // When calling getFile(OpenFile=false); getFile(OpenFile=true) the file is
226 // opened for the second call.
227 TEST_F(FileManagerTest, getFileDefersOpen) {
228   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> FS(
229       new llvm::vfs::InMemoryFileSystem());
230   FS->addFile("/tmp/test", 0, llvm::MemoryBuffer::getMemBufferCopy("test"));
231   FS->addFile("/tmp/testv", 0, llvm::MemoryBuffer::getMemBufferCopy("testv"));
232   FileManager manager(options, FS);
233 
234   const FileEntry *file = manager.getFile("/tmp/test", /*OpenFile=*/false);
235   ASSERT_TRUE(file != nullptr);
236   ASSERT_TRUE(file->isValid());
237   // "real path name" reveals whether the file was actually opened.
238   EXPECT_FALSE(file->isOpenForTests());
239 
240   file = manager.getFile("/tmp/test", /*OpenFile=*/true);
241   ASSERT_TRUE(file != nullptr);
242   ASSERT_TRUE(file->isValid());
243   EXPECT_TRUE(file->isOpenForTests());
244 
245   // However we should never try to open a file previously opened as virtual.
246   ASSERT_TRUE(manager.getVirtualFile("/tmp/testv", 5, 0));
247   ASSERT_TRUE(manager.getFile("/tmp/testv", /*OpenFile=*/false));
248   file = manager.getFile("/tmp/testv", /*OpenFile=*/true);
249   EXPECT_FALSE(file->isOpenForTests());
250 }
251 
252 // The following tests apply to Unix-like system only.
253 
254 #ifndef _WIN32
255 
256 // getFile() returns the same FileEntry for real files that are aliases.
257 TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedRealFiles) {
258   // Inject two real files with the same inode.
259   auto statCache = llvm::make_unique<FakeStatCache>();
260   statCache->InjectDirectory("abc", 41);
261   statCache->InjectFile("abc/foo.cpp", 42);
262   statCache->InjectFile("abc/bar.cpp", 42);
263   manager.setStatCache(std::move(statCache));
264 
265   EXPECT_EQ(manager.getFile("abc/foo.cpp"), manager.getFile("abc/bar.cpp"));
266 }
267 
268 // getFile() returns the same FileEntry for virtual files that have
269 // corresponding real files that are aliases.
270 TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedVirtualFiles) {
271   // Inject two real files with the same inode.
272   auto statCache = llvm::make_unique<FakeStatCache>();
273   statCache->InjectDirectory("abc", 41);
274   statCache->InjectFile("abc/foo.cpp", 42);
275   statCache->InjectFile("abc/bar.cpp", 42);
276   manager.setStatCache(std::move(statCache));
277 
278   ASSERT_TRUE(manager.getVirtualFile("abc/foo.cpp", 100, 0)->isValid());
279   ASSERT_TRUE(manager.getVirtualFile("abc/bar.cpp", 200, 0)->isValid());
280 
281   EXPECT_EQ(manager.getFile("abc/foo.cpp"), manager.getFile("abc/bar.cpp"));
282 }
283 
284 // getFile() Should return the same entry as getVirtualFile if the file actually
285 // is a virtual file, even if the name is not exactly the same (but is after
286 // normalisation done by the file system, like on Windows). This can be checked
287 // here by checking the size.
288 TEST_F(FileManagerTest, getVirtualFileWithDifferentName) {
289   // Inject fake files into the file system.
290   auto statCache = llvm::make_unique<FakeStatCache>();
291   statCache->InjectDirectory("c:\\tmp", 42);
292   statCache->InjectFile("c:\\tmp\\test", 43);
293 
294   manager.setStatCache(std::move(statCache));
295 
296   // Inject the virtual file:
297   const FileEntry *file1 = manager.getVirtualFile("c:\\tmp\\test", 123, 1);
298   ASSERT_TRUE(file1 != nullptr);
299   ASSERT_TRUE(file1->isValid());
300   EXPECT_EQ(43U, file1->getUniqueID().getFile());
301   EXPECT_EQ(123, file1->getSize());
302 
303   // Lookup the virtual file with a different name:
304   const FileEntry *file2 = manager.getFile("c:/tmp/test", 100, 1);
305   ASSERT_TRUE(file2 != nullptr);
306   ASSERT_TRUE(file2->isValid());
307   // Check that it's the same UFE:
308   EXPECT_EQ(file1, file2);
309   EXPECT_EQ(43U, file2->getUniqueID().getFile());
310   // Check that the contents of the UFE are not overwritten by the entry in the
311   // filesystem:
312   EXPECT_EQ(123, file2->getSize());
313 }
314 
315 #endif  // !_WIN32
316 
317 TEST_F(FileManagerTest, makeAbsoluteUsesVFS) {
318   SmallString<64> CustomWorkingDir;
319 #ifdef _WIN32
320   CustomWorkingDir = "C:";
321 #else
322   CustomWorkingDir = "/";
323 #endif
324   llvm::sys::path::append(CustomWorkingDir, "some", "weird", "path");
325 
326   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
327       new llvm::vfs::InMemoryFileSystem);
328   // setCurrentworkingdirectory must finish without error.
329   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
330 
331   FileSystemOptions Opts;
332   FileManager Manager(Opts, FS);
333 
334   SmallString<64> Path("a/foo.cpp");
335 
336   SmallString<64> ExpectedResult(CustomWorkingDir);
337   llvm::sys::path::append(ExpectedResult, Path);
338 
339   ASSERT_TRUE(Manager.makeAbsolutePath(Path));
340   EXPECT_EQ(Path, ExpectedResult);
341 }
342 
343 // getVirtualFile should always fill the real path.
344 TEST_F(FileManagerTest, getVirtualFileFillsRealPathName) {
345   SmallString<64> CustomWorkingDir;
346 #ifdef _WIN32
347   CustomWorkingDir = "C:/";
348 #else
349   CustomWorkingDir = "/";
350 #endif
351 
352   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
353       new llvm::vfs::InMemoryFileSystem);
354   // setCurrentworkingdirectory must finish without error.
355   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
356 
357   FileSystemOptions Opts;
358   FileManager Manager(Opts, FS);
359 
360   // Inject fake files into the file system.
361   auto statCache = llvm::make_unique<FakeStatCache>();
362   statCache->InjectDirectory("/tmp", 42);
363   statCache->InjectFile("/tmp/test", 43);
364 
365   Manager.setStatCache(std::move(statCache));
366 
367   // Check for real path.
368   const FileEntry *file = Manager.getVirtualFile("/tmp/test", 123, 1);
369   ASSERT_TRUE(file != nullptr);
370   ASSERT_TRUE(file->isValid());
371   SmallString<64> ExpectedResult = CustomWorkingDir;
372 
373   llvm::sys::path::append(ExpectedResult, "tmp", "test");
374   EXPECT_EQ(file->tryGetRealPathName(), ExpectedResult);
375 }
376 
377 } // anonymous namespace
378