Clang Project

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