578 lines · 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-exception6//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 such24// that the tests are not affected by the structure/contents of the25// file system on the machine running the tests.26class FakeStatCache : public FileSystemStatCache {27private:28 // Maps a file/directory path to its desired stat result. Anything29 // 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 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, 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.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("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.112TEST_F(FileManagerTest, NoVirtualDirectoryExistsBeforeAVirtualFileIsAdded) {113 // An empty FakeStatCache causes all stat calls made by the114 // FileManager to report "file/directory doesn't exist". This115 // avoids the possibility of the result of this test being affected116 // by what's in the real file system.117 manager.setStatCache(std::make_unique<FakeStatCache>());118 119 ASSERT_FALSE(manager.getOptionalDirectoryRef("virtual/dir/foo"));120 ASSERT_FALSE(manager.getOptionalDirectoryRef("virtual/dir"));121 ASSERT_FALSE(manager.getOptionalDirectoryRef("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.getVirtualFileRef("virtual/dir/bar.h", 100, 0);130 131 auto dir = manager.getDirectoryRef("virtual/dir/foo");132 ASSERT_THAT_EXPECTED(dir, llvm::Failed());133 134 dir = manager.getDirectoryRef("virtual/dir");135 ASSERT_THAT_EXPECTED(dir, llvm::Succeeded());136 EXPECT_EQ("virtual/dir", dir->getName());137 138 dir = manager.getDirectoryRef("virtual");139 ASSERT_THAT_EXPECTED(dir, llvm::Succeeded());140 EXPECT_EQ("virtual", dir->getName());141}142 143// getFileRef() succeeds if a real file exists at the given path.144TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingRealFile) {145 // Inject fake files into the file system.146 auto statCache = std::make_unique<FakeStatCache>();147 statCache->InjectDirectory("/tmp", 42);148 statCache->InjectFile("/tmp/test", 43);149 150#ifdef _WIN32151 const char *DirName = "C:.";152 const char *FileName = "C:test";153 statCache->InjectDirectory(DirName, 44);154 statCache->InjectFile(FileName, 45);155#endif156 157 manager.setStatCache(std::move(statCache));158 159 auto file = manager.getFileRef("/tmp/test");160 ASSERT_THAT_EXPECTED(file, llvm::Succeeded());161 EXPECT_EQ("/tmp/test", file->getName());162 163 EXPECT_EQ("/tmp", file->getDir().getName());164 165#ifdef _WIN32166 file = manager.getFileRef(FileName);167 ASSERT_THAT_EXPECTED(file, llvm::Succeeded());168 EXPECT_EQ(DirName, file->getDir().getName());169#endif170}171 172// getFileRef() succeeds if a virtual file exists at the given path.173TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingVirtualFile) {174 // Fake an empty real file system.175 manager.setStatCache(std::make_unique<FakeStatCache>());176 177 manager.getVirtualFileRef("virtual/dir/bar.h", 100, 0);178 auto file = manager.getFileRef("virtual/dir/bar.h");179 ASSERT_THAT_EXPECTED(file, llvm::Succeeded());180 EXPECT_EQ("virtual/dir/bar.h", file->getName());181 EXPECT_EQ("virtual/dir", file->getDir().getName());182}183 184// getFile() returns different FileEntries for different paths when185// there's no aliasing.186TEST_F(FileManagerTest, getFileReturnsDifferentFileEntriesForDifferentFiles) {187 // Inject two fake files into the file system. Different inodes188 // mean the files are not symlinked together.189 auto statCache = std::make_unique<FakeStatCache>();190 statCache->InjectDirectory(".", 41);191 statCache->InjectFile("foo.cpp", 42);192 statCache->InjectFile("bar.cpp", 43);193 manager.setStatCache(std::move(statCache));194 195 auto fileFoo = manager.getOptionalFileRef("foo.cpp");196 auto fileBar = manager.getOptionalFileRef("bar.cpp");197 ASSERT_TRUE(fileFoo);198 ASSERT_TRUE(fileBar);199 EXPECT_NE(&fileFoo->getFileEntry(), &fileBar->getFileEntry());200}201 202// getFile() returns an error if neither a real file nor a virtual file203// exists at the given path.204TEST_F(FileManagerTest, getFileReturnsErrorForNonexistentFile) {205 // Inject a fake foo.cpp into the file system.206 auto statCache = std::make_unique<FakeStatCache>();207 statCache->InjectDirectory(".", 41);208 statCache->InjectFile("foo.cpp", 42);209 statCache->InjectDirectory("MyDirectory", 49);210 manager.setStatCache(std::move(statCache));211 212 // Create a virtual bar.cpp file.213 manager.getVirtualFileRef("bar.cpp", 200, 0);214 215 auto file = manager.getFileRef("xyz.txt");216 ASSERT_FALSE(file);217 ASSERT_EQ(llvm::errorToErrorCode(file.takeError()),218 std::make_error_code(std::errc::no_such_file_or_directory));219 220 auto readingDirAsFile = manager.getFileRef("MyDirectory");221 ASSERT_FALSE(readingDirAsFile);222 ASSERT_EQ(llvm::errorToErrorCode(readingDirAsFile.takeError()),223 std::make_error_code(std::errc::is_a_directory));224 225 auto readingFileAsDir = manager.getDirectoryRef("foo.cpp");226 ASSERT_FALSE(readingFileAsDir);227 ASSERT_EQ(llvm::errorToErrorCode(readingFileAsDir.takeError()),228 std::make_error_code(std::errc::not_a_directory));229}230 231// The following tests apply to Unix-like system only.232 233#ifndef _WIN32234 235// getFile() returns the same FileEntry for real files that are aliases.236TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedRealFiles) {237 // Inject two real files with the same inode.238 auto statCache = std::make_unique<FakeStatCache>();239 statCache->InjectDirectory("abc", 41);240 statCache->InjectFile("abc/foo.cpp", 42);241 statCache->InjectFile("abc/bar.cpp", 42);242 manager.setStatCache(std::move(statCache));243 244 auto f1 = manager.getOptionalFileRef("abc/foo.cpp");245 auto f2 = manager.getOptionalFileRef("abc/bar.cpp");246 247 EXPECT_EQ(f1 ? &f1->getFileEntry() : nullptr,248 f2 ? &f2->getFileEntry() : nullptr);249 250 // Check that getFileRef also does the right thing.251 auto r1 = manager.getFileRef("abc/foo.cpp");252 auto r2 = manager.getFileRef("abc/bar.cpp");253 ASSERT_FALSE(!r1);254 ASSERT_FALSE(!r2);255 256 EXPECT_EQ("abc/foo.cpp", r1->getName());257 EXPECT_EQ("abc/bar.cpp", r2->getName());258 EXPECT_EQ((f1 ? &f1->getFileEntry() : nullptr), &r1->getFileEntry());259 EXPECT_EQ((f2 ? &f2->getFileEntry() : nullptr), &r2->getFileEntry());260}261 262TEST_F(FileManagerTest, getFileRefReturnsCorrectNameForDifferentStatPath) {263 // Inject files with the same inode, but where some files have a stat that264 // gives a different name. This is adding coverage for stat behaviour265 // triggered by the RedirectingFileSystem for 'use-external-name' that266 // FileManager::getFileRef has special logic for.267 auto StatCache = std::make_unique<FakeStatCache>();268 StatCache->InjectDirectory("dir", 40);269 StatCache->InjectFile("dir/f1.cpp", 41);270 StatCache->InjectFile("dir/f1-alias.cpp", 41, "dir/f1.cpp");271 StatCache->InjectFile("dir/f2.cpp", 42);272 StatCache->InjectFile("dir/f2-alias.cpp", 42, "dir/f2.cpp");273 274 // This unintuitive rename-the-file-on-stat behaviour supports how the275 // RedirectingFileSystem VFS layer responds to stats. However, even if you276 // have two layers, you should only get a single filename back. As such the277 // following stat cache behaviour is not supported (the correct stat entry278 // for a double-redirection would be "dir/f1.cpp") and the getFileRef below279 // should assert.280 StatCache->InjectFile("dir/f1-alias-alias.cpp", 41, "dir/f1-alias.cpp");281 282 manager.setStatCache(std::move(StatCache));283 284 // With F1, test accessing the non-redirected name first.285 auto F1 = manager.getFileRef("dir/f1.cpp");286 auto F1Alias = manager.getFileRef("dir/f1-alias.cpp");287 auto F1Alias2 = manager.getFileRef("dir/f1-alias.cpp");288 ASSERT_FALSE(!F1);289 ASSERT_FALSE(!F1Alias);290 ASSERT_FALSE(!F1Alias2);291 EXPECT_EQ("dir/f1.cpp", F1->getName());292 EXPECT_EQ("dir/f1.cpp", F1Alias->getName());293 EXPECT_EQ("dir/f1.cpp", F1Alias2->getName());294 EXPECT_EQ(&F1->getFileEntry(), &F1Alias->getFileEntry());295 EXPECT_EQ(&F1->getFileEntry(), &F1Alias2->getFileEntry());296 297#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST298 EXPECT_DEATH((void)manager.getFileRef("dir/f1-alias-alias.cpp"),299 "filename redirected to a non-canonical filename?");300#endif301 302 // With F2, test accessing the redirected name first.303 auto F2Alias = manager.getFileRef("dir/f2-alias.cpp");304 auto F2 = manager.getFileRef("dir/f2.cpp");305 auto F2Alias2 = manager.getFileRef("dir/f2-alias.cpp");306 ASSERT_FALSE(!F2);307 ASSERT_FALSE(!F2Alias);308 ASSERT_FALSE(!F2Alias2);309 EXPECT_EQ("dir/f2.cpp", F2->getName());310 EXPECT_EQ("dir/f2.cpp", F2Alias->getName());311 EXPECT_EQ("dir/f2.cpp", F2Alias2->getName());312 EXPECT_EQ(&F2->getFileEntry(), &F2Alias->getFileEntry());313 EXPECT_EQ(&F2->getFileEntry(), &F2Alias2->getFileEntry());314}315 316TEST_F(FileManagerTest, getFileRefReturnsCorrectDirNameForDifferentStatPath) {317 // Inject files with the same inode into distinct directories (name & inode).318 auto StatCache = std::make_unique<FakeStatCache>();319 StatCache->InjectDirectory("dir1", 40);320 StatCache->InjectDirectory("dir2", 41);321 StatCache->InjectFile("dir1/f.cpp", 42);322 StatCache->InjectFile("dir2/f.cpp", 42, "dir1/f.cpp");323 324 manager.setStatCache(std::move(StatCache));325 auto Dir1F = manager.getFileRef("dir1/f.cpp");326 auto Dir2F = manager.getFileRef("dir2/f.cpp");327 328 ASSERT_FALSE(!Dir1F);329 ASSERT_FALSE(!Dir2F);330 EXPECT_EQ("dir1", Dir1F->getDir().getName());331 EXPECT_EQ("dir2", Dir2F->getDir().getName());332 EXPECT_EQ("dir1/f.cpp", Dir1F->getNameAsRequested());333 EXPECT_EQ("dir2/f.cpp", Dir2F->getNameAsRequested());334}335 336// getFile() returns the same FileEntry for virtual files that have337// corresponding real files that are aliases.338TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedVirtualFiles) {339 // Inject two real files with the same inode.340 auto statCache = std::make_unique<FakeStatCache>();341 statCache->InjectDirectory("abc", 41);342 statCache->InjectFile("abc/foo.cpp", 42);343 statCache->InjectFile("abc/bar.cpp", 42);344 manager.setStatCache(std::move(statCache));345 346 auto f1 = manager.getOptionalFileRef("abc/foo.cpp");347 auto f2 = manager.getOptionalFileRef("abc/bar.cpp");348 349 EXPECT_EQ(f1 ? &f1->getFileEntry() : nullptr,350 f2 ? &f2->getFileEntry() : nullptr);351}352 353TEST_F(FileManagerTest, getFileRefEquality) {354 auto StatCache = std::make_unique<FakeStatCache>();355 StatCache->InjectDirectory("dir", 40);356 StatCache->InjectFile("dir/f1.cpp", 41);357 StatCache->InjectFile("dir/f1-also.cpp", 41);358 StatCache->InjectFile("dir/f1-redirect.cpp", 41, "dir/f1.cpp");359 StatCache->InjectFile("dir/f2.cpp", 42);360 manager.setStatCache(std::move(StatCache));361 362 auto F1 = manager.getFileRef("dir/f1.cpp");363 auto F1Again = manager.getFileRef("dir/f1.cpp");364 auto F1Also = manager.getFileRef("dir/f1-also.cpp");365 auto F1Redirect = manager.getFileRef("dir/f1-redirect.cpp");366 auto F1RedirectAgain = manager.getFileRef("dir/f1-redirect.cpp");367 auto F2 = manager.getFileRef("dir/f2.cpp");368 369 // Check Expected<FileEntryRef> for error.370 ASSERT_FALSE(!F1);371 ASSERT_FALSE(!F1Also);372 ASSERT_FALSE(!F1Again);373 ASSERT_FALSE(!F1Redirect);374 ASSERT_FALSE(!F1RedirectAgain);375 ASSERT_FALSE(!F2);376 377 // Check names.378 EXPECT_EQ("dir/f1.cpp", F1->getName());379 EXPECT_EQ("dir/f1.cpp", F1Again->getName());380 EXPECT_EQ("dir/f1-also.cpp", F1Also->getName());381 EXPECT_EQ("dir/f1.cpp", F1Redirect->getName());382 EXPECT_EQ("dir/f1.cpp", F1RedirectAgain->getName());383 EXPECT_EQ("dir/f2.cpp", F2->getName());384 385 EXPECT_EQ("dir/f1.cpp", F1->getNameAsRequested());386 EXPECT_EQ("dir/f1-redirect.cpp", F1Redirect->getNameAsRequested());387 388 // Compare against FileEntry*.389 EXPECT_EQ(&F1->getFileEntry(), *F1);390 EXPECT_EQ(*F1, &F1->getFileEntry());391 EXPECT_EQ(&F1->getFileEntry(), &F1Redirect->getFileEntry());392 EXPECT_EQ(&F1->getFileEntry(), &F1RedirectAgain->getFileEntry());393 EXPECT_NE(&F2->getFileEntry(), *F1);394 EXPECT_NE(*F1, &F2->getFileEntry());395 396 // Compare using ==.397 EXPECT_EQ(*F1, *F1Also);398 EXPECT_EQ(*F1, *F1Again);399 EXPECT_EQ(*F1, *F1Redirect);400 EXPECT_EQ(*F1Also, *F1Redirect);401 EXPECT_EQ(*F1, *F1RedirectAgain);402 EXPECT_NE(*F2, *F1);403 EXPECT_NE(*F2, *F1Also);404 EXPECT_NE(*F2, *F1Again);405 EXPECT_NE(*F2, *F1Redirect);406 407 // Compare using isSameRef.408 EXPECT_TRUE(F1->isSameRef(*F1Again));409 EXPECT_FALSE(F1->isSameRef(*F1Redirect));410 EXPECT_FALSE(F1->isSameRef(*F1Also));411 EXPECT_FALSE(F1->isSameRef(*F2));412 EXPECT_TRUE(F1Redirect->isSameRef(*F1RedirectAgain));413}414 415// getFile() Should return the same entry as getVirtualFile if the file actually416// is a virtual file, even if the name is not exactly the same (but is after417// normalisation done by the file system, like on Windows). This can be checked418// here by checking the size.419TEST_F(FileManagerTest, getVirtualFileWithDifferentName) {420 // Inject fake files into the file system.421 auto statCache = std::make_unique<FakeStatCache>();422 statCache->InjectDirectory("c:\\tmp", 42);423 statCache->InjectFile("c:\\tmp\\test", 43);424 425 manager.setStatCache(std::move(statCache));426 427 // Inject the virtual file:428 FileEntryRef file1 = manager.getVirtualFileRef("c:\\tmp\\test", 123, 1);429 EXPECT_EQ(43U, file1.getUniqueID().getFile());430 EXPECT_EQ(123, file1.getSize());431 432 // Lookup the virtual file with a different name:433 auto file2 = manager.getOptionalFileRef("c:/tmp/test", 100, 1);434 ASSERT_TRUE(file2);435 // Check that it's the same UFE:436 EXPECT_EQ(file1, *file2);437 EXPECT_EQ(43U, file2->getUniqueID().getFile());438 // Check that the contents of the UFE are not overwritten by the entry in the439 // filesystem:440 EXPECT_EQ(123, file2->getSize());441}442 443#endif // !_WIN32444 445static StringRef getSystemRoot() {446 return is_style_windows(llvm::sys::path::Style::native) ? "C:\\" : "/";447}448 449TEST_F(FileManagerTest, makeAbsoluteUsesVFS) {450 // FIXME: Should this be using a root path / call getSystemRoot()? For now,451 // avoiding that and leaving the test as-is.452 SmallString<64> CustomWorkingDir =453 is_style_windows(llvm::sys::path::Style::native) ? StringRef("C:")454 : StringRef("/");455 llvm::sys::path::append(CustomWorkingDir, "some", "weird", "path");456 457 auto FS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();458 // setCurrentworkingdirectory must finish without error.459 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));460 461 FileSystemOptions Opts;462 FileManager Manager(Opts, FS);463 464 SmallString<64> Path("a/foo.cpp");465 466 SmallString<64> ExpectedResult(CustomWorkingDir);467 llvm::sys::path::append(ExpectedResult, Path);468 469 ASSERT_TRUE(Manager.makeAbsolutePath(Path));470 EXPECT_EQ(Path, ExpectedResult);471}472 473// getVirtualFile should always fill the real path.474TEST_F(FileManagerTest, getVirtualFileFillsRealPathName) {475 SmallString<64> CustomWorkingDir = getSystemRoot();476 477 auto FS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();478 // setCurrentworkingdirectory must finish without error.479 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));480 481 FileSystemOptions Opts;482 FileManager Manager(Opts, FS);483 484 // Inject fake files into the file system.485 auto statCache = std::make_unique<FakeStatCache>();486 statCache->InjectDirectory("/tmp", 42);487 statCache->InjectFile("/tmp/test", 43);488 489 Manager.setStatCache(std::move(statCache));490 491 // Check for real path.492 FileEntryRef file = Manager.getVirtualFileRef("/tmp/test", 123, 1);493 SmallString<64> ExpectedResult = CustomWorkingDir;494 495 llvm::sys::path::append(ExpectedResult, "tmp", "test");496 EXPECT_EQ(file.getFileEntry().tryGetRealPathName(), ExpectedResult);497}498 499TEST_F(FileManagerTest, getFileDontOpenRealPath) {500 SmallString<64> CustomWorkingDir = getSystemRoot();501 502 auto FS = llvm::makeIntrusiveRefCnt<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("/tmp", 42);512 statCache->InjectFile("/tmp/test", 43);513 514 Manager.setStatCache(std::move(statCache));515 516 // Check for real path.517 auto file = Manager.getOptionalFileRef("/tmp/test", /*OpenFile=*/false);518 ASSERT_TRUE(file);519 SmallString<64> ExpectedResult = CustomWorkingDir;520 521 llvm::sys::path::append(ExpectedResult, "tmp", "test");522 EXPECT_EQ(file->getFileEntry().tryGetRealPathName(), ExpectedResult);523}524 525TEST_F(FileManagerTest, getBypassFile) {526 SmallString<64> CustomWorkingDir;527#ifdef _WIN32528 CustomWorkingDir = "C:/";529#else530 CustomWorkingDir = "/";531#endif532 533 auto FS = llvm::makeIntrusiveRefCnt<llvm::vfs::InMemoryFileSystem>();534 // setCurrentworkingdirectory must finish without error.535 ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));536 537 FileSystemOptions Opts;538 FileManager Manager(Opts, FS);539 540 // Inject fake files into the file system.541 auto Cache = std::make_unique<FakeStatCache>();542 Cache->InjectDirectory("/tmp", 42);543 Cache->InjectFile("/tmp/test", 43);544 Manager.setStatCache(std::move(Cache));545 546 // Set up a virtual file with a different size than FakeStatCache uses.547 FileEntryRef File = Manager.getVirtualFileRef("/tmp/test", /*Size=*/10, 0);548 ASSERT_TRUE(File);549 const FileEntry &FE = *File;550 EXPECT_EQ(FE.getSize(), 10);551 552 // Calling a second time should not affect the UID or size.553 unsigned VirtualUID = FE.getUID();554 OptionalFileEntryRef SearchRef;555 ASSERT_THAT_ERROR(Manager.getFileRef("/tmp/test").moveInto(SearchRef),556 Succeeded());557 EXPECT_EQ(&FE, &SearchRef->getFileEntry());558 EXPECT_EQ(FE.getUID(), VirtualUID);559 EXPECT_EQ(FE.getSize(), 10);560 561 // Bypass the file.562 OptionalFileEntryRef BypassRef = Manager.getBypassFile(File);563 ASSERT_TRUE(BypassRef);564 EXPECT_EQ("/tmp/test", BypassRef->getName());565 566 // Check that it's different in the right ways.567 EXPECT_NE(&BypassRef->getFileEntry(), File);568 EXPECT_NE(BypassRef->getUID(), VirtualUID);569 EXPECT_NE(BypassRef->getSize(), FE.getSize());570 571 // The virtual file should still be returned when searching.572 ASSERT_THAT_ERROR(Manager.getFileRef("/tmp/test").moveInto(SearchRef),573 Succeeded());574 EXPECT_EQ(&FE, &SearchRef->getFileEntry());575}576 577} // anonymous namespace578