clang/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 "llvm/Testing/Support/Error.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<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(llvm::sys::path::Style::native)) {
  37       llvm::sys::path::native(NormalizedPath);
  38       Path = NormalizedPath.c_str();
  39
  40       if (StatPath) {
  41         NormalizedStatPath = StatPath;
  42         llvm::sys::path::native(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
  60 public:
  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, 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(llvm::sys::path::Style::native)) {
  79       llvm::sys::path::native(NormalizedPath);
  80       Path = NormalizedPath.c_str();
  81     }
  82
  83     if (StatCalls.count(Path) != 0) {
  84       Status = StatCalls[Path];
  85       return std::error_code();
  86     }
  87
  88     return std::make_error_code(std::errc::no_such_file_or_directory);
  89   }
  90 };
  91
  92 // The test fixture.
  93 class 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.
 103 TEST_F(FileManagerTest, getVirtualFileSetsTheDirFieldCorrectly) {
 104   FileEntryRef file = manager.getVirtualFileRef("foo.cpp", 42, 0);
 105   EXPECT_EQ(".", file.getDir().getName());
 106
 107   file = manager.getVirtualFileRef("x/y/z.cpp", 42, 0);
 108   EXPECT_EQ("x/y", file.getDir().getName());
 109 }
 110
 111 // Before any virtual file is added, no virtual directory exists.
 112 TEST_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.
 125 TEST_F(FileManagerTest, getVirtualFileCreatesDirectoryEntriesForAncestors) {
 126   // Fake an empty real file system.
 127   manager.setStatCache(std::make_unique<FakeStatCache>());
 128
 129   manager.getVirtualFile("virtual/dir/bar.h", 100, 0);
 130   ASSERT_FALSE(manager.getDirectory("virtual/dir/foo"));
 131
 132   auto dir = manager.getDirectoryRef("virtual/dir");
 133   ASSERT_THAT_EXPECTED(dir, llvm::Succeeded());
 134   EXPECT_EQ("virtual/dir", dir->getName());
 135
 136   dir = manager.getDirectoryRef("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.
 142 TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingRealFile) {
 143   // Inject fake files into the file system.
 144   auto statCache = std::make_unique<FakeStatCache>();
 145   statCache->InjectDirectory("/tmp", 42);
 146   statCache->InjectFile("/tmp/test", 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("/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.
 171 TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingVirtualFile) {
 172   // Fake an empty real file system.
 173   manager.setStatCache(std::make_unique<FakeStatCache>());
 174
 175   manager.getVirtualFile("virtual/dir/bar.h", 100, 0);
 176   auto file = manager.getFileRef("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.
 184 TEST_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(".", 41);
 189   statCache->InjectFile("foo.cpp", 42);
 190   statCache->InjectFile("bar.cpp", 43);
 191   manager.setStatCache(std::move(statCache));
 192
 193   auto fileFoo = manager.getFile("foo.cpp");
 194   auto fileBar = manager.getFile("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.
 202 TEST_F(FileManagerTest, getFileReturnsErrorForNonexistentFile) {
 203   // Inject a fake foo.cpp into the file system.
 204   auto statCache = std::make_unique<FakeStatCache>();
 205   statCache->InjectDirectory(".", 41);
 206   statCache->InjectFile("foo.cpp", 42);
 207   statCache->InjectDirectory("MyDirectory", 49);
 208   manager.setStatCache(std::move(statCache));
 209
 210   // Create a virtual bar.cpp file.
 211   manager.getVirtualFile("bar.cpp", 200, 0);
 212
 213   auto file = manager.getFile("xyz.txt");
 214   ASSERT_FALSE(file);
 215   ASSERT_EQ(file.getError(), std::errc::no_such_file_or_directory);
 216
 217   auto readingDirAsFile = manager.getFile("MyDirectory");
 218   ASSERT_FALSE(readingDirAsFile);
 219   ASSERT_EQ(readingDirAsFile.getError(), std::errc::is_a_directory);
 220
 221   auto readingFileAsDir = manager.getDirectory("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.
 231 TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedRealFiles) {
 232   // Inject two real files with the same inode.
 233   auto statCache = std::make_unique<FakeStatCache>();
 234   statCache->InjectDirectory("abc", 41);
 235   statCache->InjectFile("abc/foo.cpp", 42);
 236   statCache->InjectFile("abc/bar.cpp", 42);
 237   manager.setStatCache(std::move(statCache));
 238
 239   auto f1 = manager.getFile("abc/foo.cpp");
 240   auto f2 = manager.getFile("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("abc/foo.cpp");
 247   auto r2 = manager.getFileRef("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
 257 TEST_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("dir", 40);
 264   StatCache->InjectFile("dir/f1.cpp", 41);
 265   StatCache->InjectFile("dir/f1-alias.cpp", 41, "dir/f1.cpp");
 266   StatCache->InjectFile("dir/f2.cpp", 42);
 267   StatCache->InjectFile("dir/f2-alias.cpp", 42, "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("dir/f1-alias-alias.cpp", 41, "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("dir/f1.cpp");
 281   auto F1Alias = manager.getFileRef("dir/f1-alias.cpp");
 282   auto F1Alias2 = manager.getFileRef("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   LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH
 288   EXPECT_EQ("dir/f1.cpp", F1->getFileEntry().getName());
 289   LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_POP
 290   EXPECT_EQ("dir/f1.cpp", F1Alias->getName());
 291   EXPECT_EQ("dir/f1.cpp", F1Alias2->getName());
 292   EXPECT_EQ(&F1->getFileEntry(), &F1Alias->getFileEntry());
 293   EXPECT_EQ(&F1->getFileEntry(), &F1Alias2->getFileEntry());
 294
 295 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
 296   EXPECT_DEATH((void)manager.getFileRef("dir/f1-alias-alias.cpp"),
 297                "filename redirected to a non-canonical filename?");
 298 #endif
 299
 300   // With F2, test accessing the redirected name first.
 301   auto F2Alias = manager.getFileRef("dir/f2-alias.cpp");
 302   auto F2 = manager.getFileRef("dir/f2.cpp");
 303   auto F2Alias2 = manager.getFileRef("dir/f2-alias.cpp");
 304   ASSERT_FALSE(!F2);
 305   ASSERT_FALSE(!F2Alias);
 306   ASSERT_FALSE(!F2Alias2);
 307   EXPECT_EQ("dir/f2.cpp", F2->getName());
 308   LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_PUSH
 309   EXPECT_EQ("dir/f2.cpp", F2->getFileEntry().getName());
 310   LLVM_SUPPRESS_DEPRECATED_DECLARATIONS_POP
 311   EXPECT_EQ("dir/f2.cpp", F2Alias->getName());
 312   EXPECT_EQ("dir/f2.cpp", F2Alias2->getName());
 313   EXPECT_EQ(&F2->getFileEntry(), &F2Alias->getFileEntry());
 314   EXPECT_EQ(&F2->getFileEntry(), &F2Alias2->getFileEntry());
 315 }
 316
 317 TEST_F(FileManagerTest, getFileRefReturnsCorrectDirNameForDifferentStatPath) {
 318   // Inject files with the same inode into distinct directories (name & inode).
 319   auto StatCache = std::make_unique<FakeStatCache>();
 320   StatCache->InjectDirectory("dir1", 40);
 321   StatCache->InjectDirectory("dir2", 41);
 322   StatCache->InjectFile("dir1/f.cpp", 42);
 323   StatCache->InjectFile("dir2/f.cpp", 42, "dir1/f.cpp");
 324
 325   manager.setStatCache(std::move(StatCache));
 326   auto Dir1F = manager.getFileRef("dir1/f.cpp");
 327   auto Dir2F = manager.getFileRef("dir2/f.cpp");
 328
 329   ASSERT_FALSE(!Dir1F);
 330   ASSERT_FALSE(!Dir2F);
 331   EXPECT_EQ("dir1", Dir1F->getDir().getName());
 332   EXPECT_EQ("dir2", Dir2F->getDir().getName());
 333   EXPECT_EQ("dir1/f.cpp", Dir1F->getNameAsRequested());
 334   EXPECT_EQ("dir2/f.cpp", Dir2F->getNameAsRequested());
 335 }
 336
 337 // getFile() returns the same FileEntry for virtual files that have
 338 // corresponding real files that are aliases.
 339 TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedVirtualFiles) {
 340   // Inject two real files with the same inode.
 341   auto statCache = std::make_unique<FakeStatCache>();
 342   statCache->InjectDirectory("abc", 41);
 343   statCache->InjectFile("abc/foo.cpp", 42);
 344   statCache->InjectFile("abc/bar.cpp", 42);
 345   manager.setStatCache(std::move(statCache));
 346
 347   auto f1 = manager.getFile("abc/foo.cpp");
 348   auto f2 = manager.getFile("abc/bar.cpp");
 349
 350   EXPECT_EQ(f1 ? *f1 : nullptr,
 351             f2 ? *f2 : nullptr);
 352 }
 353
 354 TEST_F(FileManagerTest, getFileRefEquality) {
 355   auto StatCache = std::make_unique<FakeStatCache>();
 356   StatCache->InjectDirectory("dir", 40);
 357   StatCache->InjectFile("dir/f1.cpp", 41);
 358   StatCache->InjectFile("dir/f1-also.cpp", 41);
 359   StatCache->InjectFile("dir/f1-redirect.cpp", 41, "dir/f1.cpp");
 360   StatCache->InjectFile("dir/f2.cpp", 42);
 361   manager.setStatCache(std::move(StatCache));
 362
 363   auto F1 = manager.getFileRef("dir/f1.cpp");
 364   auto F1Again = manager.getFileRef("dir/f1.cpp");
 365   auto F1Also = manager.getFileRef("dir/f1-also.cpp");
 366   auto F1Redirect = manager.getFileRef("dir/f1-redirect.cpp");
 367   auto F1RedirectAgain = manager.getFileRef("dir/f1-redirect.cpp");
 368   auto F2 = manager.getFileRef("dir/f2.cpp");
 369
 370   // Check Expected<FileEntryRef> for error.
 371   ASSERT_FALSE(!F1);
 372   ASSERT_FALSE(!F1Also);
 373   ASSERT_FALSE(!F1Again);
 374   ASSERT_FALSE(!F1Redirect);
 375   ASSERT_FALSE(!F1RedirectAgain);
 376   ASSERT_FALSE(!F2);
 377
 378   // Check names.
 379   EXPECT_EQ("dir/f1.cpp", F1->getName());
 380   EXPECT_EQ("dir/f1.cpp", F1Again->getName());
 381   EXPECT_EQ("dir/f1-also.cpp", F1Also->getName());
 382   EXPECT_EQ("dir/f1.cpp", F1Redirect->getName());
 383   EXPECT_EQ("dir/f1.cpp", F1RedirectAgain->getName());
 384   EXPECT_EQ("dir/f2.cpp", F2->getName());
 385
 386   EXPECT_EQ("dir/f1.cpp", F1->getNameAsRequested());
 387   EXPECT_EQ("dir/f1-redirect.cpp", F1Redirect->getNameAsRequested());
 388
 389   // Compare against FileEntry*.
 390   EXPECT_EQ(&F1->getFileEntry(), *F1);
 391   EXPECT_EQ(*F1, &F1->getFileEntry());
 392   EXPECT_EQ(&F1->getFileEntry(), &F1Redirect->getFileEntry());
 393   EXPECT_EQ(&F1->getFileEntry(), &F1RedirectAgain->getFileEntry());
 394   EXPECT_NE(&F2->getFileEntry(), *F1);
 395   EXPECT_NE(*F1, &F2->getFileEntry());
 396
 397   // Compare using ==.
 398   EXPECT_EQ(*F1, *F1Also);
 399   EXPECT_EQ(*F1, *F1Again);
 400   EXPECT_EQ(*F1, *F1Redirect);
 401   EXPECT_EQ(*F1Also, *F1Redirect);
 402   EXPECT_EQ(*F1, *F1RedirectAgain);
 403   EXPECT_NE(*F2, *F1);
 404   EXPECT_NE(*F2, *F1Also);
 405   EXPECT_NE(*F2, *F1Again);
 406   EXPECT_NE(*F2, *F1Redirect);
 407
 408   // Compare using isSameRef.
 409   EXPECT_TRUE(F1->isSameRef(*F1Again));
 410   EXPECT_FALSE(F1->isSameRef(*F1Redirect));
 411   EXPECT_FALSE(F1->isSameRef(*F1Also));
 412   EXPECT_FALSE(F1->isSameRef(*F2));
 413   EXPECT_TRUE(F1Redirect->isSameRef(*F1RedirectAgain));
 414 }
 415
 416 // getFile() Should return the same entry as getVirtualFile if the file actually
 417 // is a virtual file, even if the name is not exactly the same (but is after
 418 // normalisation done by the file system, like on Windows). This can be checked
 419 // here by checking the size.
 420 TEST_F(FileManagerTest, getVirtualFileWithDifferentName) {
 421   // Inject fake files into the file system.
 422   auto statCache = std::make_unique<FakeStatCache>();
 423   statCache->InjectDirectory("c:\\tmp", 42);
 424   statCache->InjectFile("c:\\tmp\\test", 43);
 425
 426   manager.setStatCache(std::move(statCache));
 427
 428   // Inject the virtual file:
 429   const FileEntry *file1 = manager.getVirtualFile("c:\\tmp\\test", 123, 1);
 430   ASSERT_TRUE(file1 != nullptr);
 431   EXPECT_EQ(43U, file1->getUniqueID().getFile());
 432   EXPECT_EQ(123, file1->getSize());
 433
 434   // Lookup the virtual file with a different name:
 435   auto file2 = manager.getFile("c:/tmp/test", 100, 1);
 436   ASSERT_TRUE(file2);
 437   // Check that it's the same UFE:
 438   EXPECT_EQ(file1, *file2);
 439   EXPECT_EQ(43U, (*file2)->getUniqueID().getFile());
 440   // Check that the contents of the UFE are not overwritten by the entry in the
 441   // filesystem:
 442   EXPECT_EQ(123, (*file2)->getSize());
 443 }
 444
 445 #endif  // !_WIN32
 446
 447 static StringRef getSystemRoot() {
 448   return is_style_windows(llvm::sys::path::Style::native) ? "C:\\" : "/";
 449 }
 450
 451 TEST_F(FileManagerTest, makeAbsoluteUsesVFS) {
 452   // FIXME: Should this be using a root path / call getSystemRoot()? For now,
 453   // avoiding that and leaving the test as-is.
 454   SmallString<64> CustomWorkingDir =
 455       is_style_windows(llvm::sys::path::Style::native) ? StringRef("C:")
 456                                                        : StringRef("/");
 457   llvm::sys::path::append(CustomWorkingDir, "some", "weird", "path");
 458
 459   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
 460       new llvm::vfs::InMemoryFileSystem);
 461   // setCurrentworkingdirectory must finish without error.
 462   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
 463
 464   FileSystemOptions Opts;
 465   FileManager Manager(Opts, FS);
 466
 467   SmallString<64> Path("a/foo.cpp");
 468
 469   SmallString<64> ExpectedResult(CustomWorkingDir);
 470   llvm::sys::path::append(ExpectedResult, Path);
 471
 472   ASSERT_TRUE(Manager.makeAbsolutePath(Path));
 473   EXPECT_EQ(Path, ExpectedResult);
 474 }
 475
 476 // getVirtualFile should always fill the real path.
 477 TEST_F(FileManagerTest, getVirtualFileFillsRealPathName) {
 478   SmallString<64> CustomWorkingDir = getSystemRoot();
 479
 480   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
 481       new llvm::vfs::InMemoryFileSystem);
 482   // setCurrentworkingdirectory must finish without error.
 483   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
 484
 485   FileSystemOptions Opts;
 486   FileManager Manager(Opts, FS);
 487
 488   // Inject fake files into the file system.
 489   auto statCache = std::make_unique<FakeStatCache>();
 490   statCache->InjectDirectory("/tmp", 42);
 491   statCache->InjectFile("/tmp/test", 43);
 492
 493   Manager.setStatCache(std::move(statCache));
 494
 495   // Check for real path.
 496   const FileEntry *file = Manager.getVirtualFile("/tmp/test", 123, 1);
 497   ASSERT_TRUE(file != nullptr);
 498   SmallString<64> ExpectedResult = CustomWorkingDir;
 499
 500   llvm::sys::path::append(ExpectedResult, "tmp", "test");
 501   EXPECT_EQ(file->tryGetRealPathName(), ExpectedResult);
 502 }
 503
 504 TEST_F(FileManagerTest, getFileDontOpenRealPath) {
 505   SmallString<64> CustomWorkingDir = getSystemRoot();
 506
 507   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
 508       new llvm::vfs::InMemoryFileSystem);
 509   // setCurrentworkingdirectory must finish without error.
 510   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
 511
 512   FileSystemOptions Opts;
 513   FileManager Manager(Opts, FS);
 514
 515   // Inject fake files into the file system.
 516   auto statCache = std::make_unique<FakeStatCache>();
 517   statCache->InjectDirectory("/tmp", 42);
 518   statCache->InjectFile("/tmp/test", 43);
 519
 520   Manager.setStatCache(std::move(statCache));
 521
 522   // Check for real path.
 523   auto file = Manager.getFile("/tmp/test", /*OpenFile=*/false);
 524   ASSERT_TRUE(file);
 525   SmallString<64> ExpectedResult = CustomWorkingDir;
 526
 527   llvm::sys::path::append(ExpectedResult, "tmp", "test");
 528   EXPECT_EQ((*file)->tryGetRealPathName(), ExpectedResult);
 529 }
 530
 531 TEST_F(FileManagerTest, getBypassFile) {
 532   SmallString<64> CustomWorkingDir;
 533 #ifdef _WIN32
 534   CustomWorkingDir = "C:/";
 535 #else
 536   CustomWorkingDir = "/";
 537 #endif
 538
 539   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
 540       new llvm::vfs::InMemoryFileSystem);
 541   // setCurrentworkingdirectory must finish without error.
 542   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));
 543
 544   FileSystemOptions Opts;
 545   FileManager Manager(Opts, FS);
 546
 547   // Inject fake files into the file system.
 548   auto Cache = std::make_unique<FakeStatCache>();
 549   Cache->InjectDirectory("/tmp", 42);
 550   Cache->InjectFile("/tmp/test", 43);
 551   Manager.setStatCache(std::move(Cache));
 552
 553   // Set up a virtual file with a different size than FakeStatCache uses.
 554   FileEntryRef File = Manager.getVirtualFileRef("/tmp/test", /*Size=*/10, 0);
 555   ASSERT_TRUE(File);
 556   const FileEntry &FE = *File;
 557   EXPECT_EQ(FE.getSize(), 10);
 558
 559   // Calling a second time should not affect the UID or size.
 560   unsigned VirtualUID = FE.getUID();
 561   OptionalFileEntryRef SearchRef;
 562   ASSERT_THAT_ERROR(Manager.getFileRef("/tmp/test").moveInto(SearchRef),
 563                     Succeeded());
 564   EXPECT_EQ(&FE, &SearchRef->getFileEntry());
 565   EXPECT_EQ(FE.getUID(), VirtualUID);
 566   EXPECT_EQ(FE.getSize(), 10);
 567
 568   // Bypass the file.
 569   OptionalFileEntryRef BypassRef = Manager.getBypassFile(File);
 570   ASSERT_TRUE(BypassRef);
 571   EXPECT_EQ("/tmp/test", BypassRef->getName());
 572
 573   // Check that it's different in the right ways.
 574   EXPECT_NE(&BypassRef->getFileEntry(), File);
 575   EXPECT_NE(BypassRef->getUID(), VirtualUID);
 576   EXPECT_NE(BypassRef->getSize(), FE.getSize());
 577
 578   // The virtual file should still be returned when searching.
 579   ASSERT_THAT_ERROR(Manager.getFileRef("/tmp/test").moveInto(SearchRef),
 580                     Succeeded());
 581   EXPECT_EQ(&FE, &SearchRef->getFileEntry());
 582 }
 583
 584 } // anonymous namespace