unittests/Basic/FileManagerTest.cpp - clang - Git at Google

 //===- unittests/Basic/FileMangerTest.cpp ------------ FileManger tests ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemOptions.h"
 #include "clang/Basic/FileSystemStatCache.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/VirtualFileSystem.h"
 #include "gtest/gtest.h"

 using namespace llvm;
 using namespace clang;

 namespace {

 // Used to create a fake file system for running the tests with such
 // that the tests are not affected by the structure/contents of the
 // file system on the machine running the tests.
 class FakeStatCache : public FileSystemStatCache {
 private:
   // Maps a file/directory path to its desired stat result.  Anything
   // not in this map is considered to not exist in the file system.
   llvm::StringMap<llvm::vfs::Status, llvm::BumpPtrAllocator> StatCalls;

   void InjectFileOrDirectory(const char *Path, ino_t INode, bool IsFile) {
 #ifndef _WIN32
     SmallString<128> NormalizedPath(Path);
     llvm::sys::path::native(NormalizedPath);
     Path = NormalizedPath.c_str();
 #endif

     auto fileType = IsFile ?
       llvm::sys::fs::file_type::regular_file :
       llvm::sys::fs::file_type::directory_file;
     llvm::vfs::Status Status(Path, llvm::sys::fs::UniqueID(1, INode),
                              /*MTime*/{}, /*User*/0, /*Group*/0,
                              /*Size*/0, fileType,
                              llvm::sys::fs::perms::all_all);
     StatCalls[Path] = Status;
   }

 public:
   // Inject a file with the given inode value to the fake file system.
   void InjectFile(const char *Path, ino_t INode) {
     InjectFileOrDirectory(Path, INode, /*IsFile=*/true);
   }

   // Inject a directory with the given inode value to the fake file system.
   void InjectDirectory(const char *Path, ino_t INode) {
     InjectFileOrDirectory(Path, INode, /*IsFile=*/false);
   }

   // Implement FileSystemStatCache::getStat().
   std::error_code getStat(StringRef Path, llvm::vfs::Status &Status,
                           bool isFile,
                           std::unique_ptr<llvm::vfs::File> *F,
                           llvm::vfs::FileSystem &FS) override {
 #ifndef _WIN32
     SmallString<128> NormalizedPath(Path);
     llvm::sys::path::native(NormalizedPath);
     Path = NormalizedPath.c_str();
 #endif

     if (StatCalls.count(Path) != 0) {
       Status = StatCalls[Path];
       return std::error_code();
     }

     return std::make_error_code(std::errc::no_such_file_or_directory);
   }
 };

 // The test fixture.
 class FileManagerTest : public ::testing::Test {
  protected:
   FileManagerTest() : manager(options) {
   }

   FileSystemOptions options;
   FileManager manager;
 };

 // When a virtual file is added, its getDir() field is set correctly
 // (not NULL, correct name).
 TEST_F(FileManagerTest, getVirtualFileSetsTheDirFieldCorrectly) {
   const FileEntry *file = manager.getVirtualFile("foo.cpp", 42, 0);
   ASSERT_TRUE(file != nullptr);

   const DirectoryEntry *dir = file->getDir();
   ASSERT_TRUE(dir != nullptr);
   EXPECT_EQ(".", dir->getName());

   file = manager.getVirtualFile("x/y/z.cpp", 42, 0);
   ASSERT_TRUE(file != nullptr);

   dir = file->getDir();
   ASSERT_TRUE(dir != nullptr);
   EXPECT_EQ("x/y", dir->getName());
 }

 // Before any virtual file is added, no virtual directory exists.
 TEST_F(FileManagerTest, NoVirtualDirectoryExistsBeforeAVirtualFileIsAdded) {
   // An empty FakeStatCache causes all stat calls made by the
   // FileManager to report "file/directory doesn't exist".  This
   // avoids the possibility of the result of this test being affected
   // by what's in the real file system.
   manager.setStatCache(std::make_unique<FakeStatCache>());

   ASSERT_FALSE(manager.getDirectory("virtual/dir/foo"));
   ASSERT_FALSE(manager.getDirectory("virtual/dir"));
   ASSERT_FALSE(manager.getDirectory("virtual"));
 }

 // When a virtual file is added, all of its ancestors should be created.
 TEST_F(FileManagerTest, getVirtualFileCreatesDirectoryEntriesForAncestors) {
   // Fake an empty real file system.
   manager.setStatCache(std::make_unique<FakeStatCache>());

   manager.getVirtualFile("virtual/dir/bar.h", 100, 0);
   ASSERT_FALSE(manager.getDirectory("virtual/dir/foo"));

   auto dir = manager.getDirectory("virtual/dir");
   ASSERT_TRUE(dir);
   EXPECT_EQ("virtual/dir", (*dir)->getName());

   dir = manager.getDirectory("virtual");
   ASSERT_TRUE(dir);
   EXPECT_EQ("virtual", (*dir)->getName());
 }

 // getFile() returns non-NULL if a real file exists at the given path.
 TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingRealFile) {
   // Inject fake files into the file system.
   auto statCache = std::make_unique<FakeStatCache>();
   statCache->InjectDirectory("/tmp", 42);
   statCache->InjectFile("/tmp/test", 43);

 #ifdef _WIN32
   const char *DirName = "C:.";
   const char *FileName = "C:test";
   statCache->InjectDirectory(DirName, 44);
   statCache->InjectFile(FileName, 45);
 #endif

   manager.setStatCache(std::move(statCache));

   auto file = manager.getFile("/tmp/test");
   ASSERT_TRUE(file);
   ASSERT_TRUE((*file)->isValid());
   EXPECT_EQ("/tmp/test", (*file)->getName());

   const DirectoryEntry *dir = (*file)->getDir();
   ASSERT_TRUE(dir != nullptr);
   EXPECT_EQ("/tmp", dir->getName());

 #ifdef _WIN32
   file = manager.getFile(FileName);
   ASSERT_TRUE(file);

   dir = (*file)->getDir();
   ASSERT_TRUE(dir != NULL);
   EXPECT_EQ(DirName, dir->getName());
 #endif
 }

 // getFile() returns non-NULL if a virtual file exists at the given path.
 TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingVirtualFile) {
   // Fake an empty real file system.
   manager.setStatCache(std::make_unique<FakeStatCache>());

   manager.getVirtualFile("virtual/dir/bar.h", 100, 0);
   auto file = manager.getFile("virtual/dir/bar.h");
   ASSERT_TRUE(file);
   ASSERT_TRUE((*file)->isValid());
   EXPECT_EQ("virtual/dir/bar.h", (*file)->getName());

   const DirectoryEntry *dir = (*file)->getDir();
   ASSERT_TRUE(dir != nullptr);
   EXPECT_EQ("virtual/dir", dir->getName());
 }

 // getFile() returns different FileEntries for different paths when
 // there's no aliasing.
 TEST_F(FileManagerTest, getFileReturnsDifferentFileEntriesForDifferentFiles) {
   // Inject two fake files into the file system.  Different inodes
   // mean the files are not symlinked together.
   auto statCache = std::make_unique<FakeStatCache>();
   statCache->InjectDirectory(".", 41);
   statCache->InjectFile("foo.cpp", 42);
   statCache->InjectFile("bar.cpp", 43);
   manager.setStatCache(std::move(statCache));

   auto fileFoo = manager.getFile("foo.cpp");
   auto fileBar = manager.getFile("bar.cpp");
   ASSERT_TRUE(fileFoo);
   ASSERT_TRUE((*fileFoo)->isValid());
   ASSERT_TRUE(fileBar);
   ASSERT_TRUE((*fileBar)->isValid());
   EXPECT_NE(*fileFoo, *fileBar);
 }

 // getFile() returns an error if neither a real file nor a virtual file
 // exists at the given path.
 TEST_F(FileManagerTest, getFileReturnsErrorForNonexistentFile) {
   // Inject a fake foo.cpp into the file system.
   auto statCache = std::make_unique<FakeStatCache>();
   statCache->InjectDirectory(".", 41);
   statCache->InjectFile("foo.cpp", 42);
   statCache->InjectDirectory("MyDirectory", 49);
   manager.setStatCache(std::move(statCache));

   // Create a virtual bar.cpp file.
   manager.getVirtualFile("bar.cpp", 200, 0);

   auto file = manager.getFile("xyz.txt");
   ASSERT_FALSE(file);
   ASSERT_EQ(file.getError(), std::errc::no_such_file_or_directory);

   auto readingDirAsFile = manager.getFile("MyDirectory");
   ASSERT_FALSE(readingDirAsFile);
   ASSERT_EQ(readingDirAsFile.getError(), std::errc::is_a_directory);

   auto readingFileAsDir = manager.getDirectory("foo.cpp");
   ASSERT_FALSE(readingFileAsDir);
   ASSERT_EQ(readingFileAsDir.getError(), std::errc::not_a_directory);
 }

 // The following tests apply to Unix-like system only.

 #ifndef _WIN32

 // getFile() returns the same FileEntry for real files that are aliases.
 TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedRealFiles) {
   // Inject two real files with the same inode.
   auto statCache = std::make_unique<FakeStatCache>();
   statCache->InjectDirectory("abc", 41);
   statCache->InjectFile("abc/foo.cpp", 42);
   statCache->InjectFile("abc/bar.cpp", 42);
   manager.setStatCache(std::move(statCache));

   auto f1 = manager.getFile("abc/foo.cpp");
   auto f2 = manager.getFile("abc/bar.cpp");

   EXPECT_EQ(f1 ? *f1 : nullptr,
             f2 ? *f2 : nullptr);
 }

 // getFile() returns the same FileEntry for virtual files that have
 // corresponding real files that are aliases.
 TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedVirtualFiles) {
   // Inject two real files with the same inode.
   auto statCache = std::make_unique<FakeStatCache>();
   statCache->InjectDirectory("abc", 41);
   statCache->InjectFile("abc/foo.cpp", 42);
   statCache->InjectFile("abc/bar.cpp", 42);
   manager.setStatCache(std::move(statCache));

   ASSERT_TRUE(manager.getVirtualFile("abc/foo.cpp", 100, 0)->isValid());
   ASSERT_TRUE(manager.getVirtualFile("abc/bar.cpp", 200, 0)->isValid());

   auto f1 = manager.getFile("abc/foo.cpp");
   auto f2 = manager.getFile("abc/bar.cpp");

   EXPECT_EQ(f1 ? *f1 : nullptr,
             f2 ? *f2 : nullptr);
 }

 // getFile() Should return the same entry as getVirtualFile if the file actually
 // is a virtual file, even if the name is not exactly the same (but is after
 // normalisation done by the file system, like on Windows). This can be checked
 // here by checking the size.
 TEST_F(FileManagerTest, getVirtualFileWithDifferentName) {
   // Inject fake files into the file system.
   auto statCache = std::make_unique<FakeStatCache>();
   statCache->InjectDirectory("c:\\tmp", 42);
   statCache->InjectFile("c:\\tmp\\test", 43);

   manager.setStatCache(std::move(statCache));

   // Inject the virtual file:
   const FileEntry *file1 = manager.getVirtualFile("c:\\tmp\\test", 123, 1);
   ASSERT_TRUE(file1 != nullptr);
   ASSERT_TRUE(file1->isValid());
   EXPECT_EQ(43U, file1->getUniqueID().getFile());
   EXPECT_EQ(123, file1->getSize());

   // Lookup the virtual file with a different name:
   auto file2 = manager.getFile("c:/tmp/test", 100, 1);
   ASSERT_TRUE(file2);
   ASSERT_TRUE((*file2)->isValid());
   // Check that it's the same UFE:
   EXPECT_EQ(file1, *file2);
   EXPECT_EQ(43U, (*file2)->getUniqueID().getFile());
   // Check that the contents of the UFE are not overwritten by the entry in the
   // filesystem:
   EXPECT_EQ(123, (*file2)->getSize());
 }

 #endif  // !_WIN32

 TEST_F(FileManagerTest, makeAbsoluteUsesVFS) {
   SmallString<64> CustomWorkingDir;
 #ifdef _WIN32
   CustomWorkingDir = "C:";
 #else
   CustomWorkingDir = "/";
 #endif
   llvm::sys::path::append(CustomWorkingDir, "some", "weird", "path");

   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
       new llvm::vfs::InMemoryFileSystem);
   // setCurrentworkingdirectory must finish without error.
   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));

   FileSystemOptions Opts;
   FileManager Manager(Opts, FS);

   SmallString<64> Path("a/foo.cpp");

   SmallString<64> ExpectedResult(CustomWorkingDir);
   llvm::sys::path::append(ExpectedResult, Path);

   ASSERT_TRUE(Manager.makeAbsolutePath(Path));
   EXPECT_EQ(Path, ExpectedResult);
 }

 // getVirtualFile should always fill the real path.
 TEST_F(FileManagerTest, getVirtualFileFillsRealPathName) {
   SmallString<64> CustomWorkingDir;
 #ifdef _WIN32
   CustomWorkingDir = "C:/";
 #else
   CustomWorkingDir = "/";
 #endif

   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
       new llvm::vfs::InMemoryFileSystem);
   // setCurrentworkingdirectory must finish without error.
   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));

   FileSystemOptions Opts;
   FileManager Manager(Opts, FS);

   // Inject fake files into the file system.
   auto statCache = std::make_unique<FakeStatCache>();
   statCache->InjectDirectory("/tmp", 42);
   statCache->InjectFile("/tmp/test", 43);

   Manager.setStatCache(std::move(statCache));

   // Check for real path.
   const FileEntry *file = Manager.getVirtualFile("/tmp/test", 123, 1);
   ASSERT_TRUE(file != nullptr);
   ASSERT_TRUE(file->isValid());
   SmallString<64> ExpectedResult = CustomWorkingDir;

   llvm::sys::path::append(ExpectedResult, "tmp", "test");
   EXPECT_EQ(file->tryGetRealPathName(), ExpectedResult);
 }

 TEST_F(FileManagerTest, getFileDontOpenRealPath) {
   SmallString<64> CustomWorkingDir;
 #ifdef _WIN32
   CustomWorkingDir = "C:/";
 #else
   CustomWorkingDir = "/";
 #endif

   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
       new llvm::vfs::InMemoryFileSystem);
   // setCurrentworkingdirectory must finish without error.
   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));

   FileSystemOptions Opts;
   FileManager Manager(Opts, FS);

   // Inject fake files into the file system.
   auto statCache = std::make_unique<FakeStatCache>();
   statCache->InjectDirectory("/tmp", 42);
   statCache->InjectFile("/tmp/test", 43);

   Manager.setStatCache(std::move(statCache));

   // Check for real path.
   auto file = Manager.getFile("/tmp/test", /*OpenFile=*/false);
   ASSERT_TRUE(file);
   ASSERT_TRUE((*file)->isValid());
   SmallString<64> ExpectedResult = CustomWorkingDir;

   llvm::sys::path::append(ExpectedResult, "tmp", "test");
   EXPECT_EQ((*file)->tryGetRealPathName(), ExpectedResult);
 }

 TEST_F(FileManagerTest, getBypassFile) {
   SmallString<64> CustomWorkingDir;
 #ifdef _WIN32
   CustomWorkingDir = "C:/";
 #else
   CustomWorkingDir = "/";
 #endif

   auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
       new llvm::vfs::InMemoryFileSystem);
   // setCurrentworkingdirectory must finish without error.
   ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));

   FileSystemOptions Opts;
   FileManager Manager(Opts, FS);

   // Inject fake files into the file system.
   auto Cache = std::make_unique<FakeStatCache>();
   Cache->InjectDirectory("/tmp", 42);
   Cache->InjectFile("/tmp/test", 43);
   Manager.setStatCache(std::move(Cache));

   // Set up a virtual file with a different size than FakeStatCache uses.
   const FileEntry *File = Manager.getVirtualFile("/tmp/test", /*Size=*/10, 0);
   ASSERT_TRUE(File);
   FileEntryRef Ref("/tmp/test", *File);
   EXPECT_TRUE(Ref.isValid());
   EXPECT_EQ(Ref.getSize(), 10);

   // Calling a second time should not affect the UID or size.
   unsigned VirtualUID = Ref.getUID();
   EXPECT_EQ(*expectedToOptional(Manager.getFileRef("/tmp/test")), Ref);
   EXPECT_EQ(Ref.getUID(), VirtualUID);
   EXPECT_EQ(Ref.getSize(), 10);

   // Bypass the file.
   llvm::Optional<FileEntryRef> BypassRef = Manager.getBypassFile(Ref);
   ASSERT_TRUE(BypassRef);
   EXPECT_TRUE(BypassRef->isValid());
   EXPECT_EQ(BypassRef->getName(), Ref.getName());

   // Check that it's different in the right ways.
   EXPECT_NE(&BypassRef->getFileEntry(), File);
   EXPECT_NE(BypassRef->getUID(), VirtualUID);
   EXPECT_NE(BypassRef->getSize(), Ref.getSize());

   // The virtual file should still be returned when searching.
   EXPECT_EQ(*expectedToOptional(Manager.getFileRef("/tmp/test")), Ref);
 }

 } // anonymous namespace
	//===- unittests/Basic/FileMangerTest.cpp ------------ FileManger tests ---===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "clang/Basic/FileManager.h"
	#include "clang/Basic/FileSystemOptions.h"
	#include "clang/Basic/FileSystemStatCache.h"
	#include "llvm/ADT/STLExtras.h"
	#include "llvm/Support/Path.h"
	#include "llvm/Support/VirtualFileSystem.h"
	#include "gtest/gtest.h"

	using namespace llvm;
	using namespace clang;

	namespace {

	// Used to create a fake file system for running the tests with such
	// that the tests are not affected by the structure/contents of the
	// file system on the machine running the tests.
	class FakeStatCache : public FileSystemStatCache {
	private:
	// Maps a file/directory path to its desired stat result. Anything
	// not in this map is considered to not exist in the file system.
	llvm::StringMap<llvm::vfs::Status, llvm::BumpPtrAllocator> StatCalls;

	void InjectFileOrDirectory(const char *Path, ino_t INode, bool IsFile) {
	#ifndef _WIN32
	SmallString<128> NormalizedPath(Path);
	llvm::sys::path::native(NormalizedPath);
	Path = NormalizedPath.c_str();
	#endif

	auto fileType = IsFile ?
	llvm::sys::fs::file_type::regular_file :
	llvm::sys::fs::file_type::directory_file;
	llvm::vfs::Status Status(Path, llvm::sys::fs::UniqueID(1, INode),
	/MTime/{}, /User/0, /Group/0,
	/Size/0, fileType,
	llvm::sys::fs::perms::all_all);
	StatCalls[Path] = Status;
	}

	public:
	// Inject a file with the given inode value to the fake file system.
	void InjectFile(const char *Path, ino_t INode) {
	InjectFileOrDirectory(Path, INode, /IsFile=/true);
	}

	// Inject a directory with the given inode value to the fake file system.
	void InjectDirectory(const char *Path, ino_t INode) {
	InjectFileOrDirectory(Path, INode, /IsFile=/false);
	}

	// Implement FileSystemStatCache::getStat().
	std::error_code getStat(StringRef Path, llvm::vfs::Status &Status,
	bool isFile,
	std::unique_ptr<llvm::vfs::File> *F,
	llvm::vfs::FileSystem &FS) override {
	#ifndef _WIN32
	SmallString<128> NormalizedPath(Path);
	llvm::sys::path::native(NormalizedPath);
	Path = NormalizedPath.c_str();
	#endif

	if (StatCalls.count(Path) != 0) {
	Status = StatCalls[Path];
	return std::error_code();
	}

	return std::make_error_code(std::errc::no_such_file_or_directory);
	}
	};

	// The test fixture.
	class FileManagerTest : public ::testing::Test {
	protected:
	FileManagerTest() : manager(options) {
	}

	FileSystemOptions options;
	FileManager manager;
	};

	// When a virtual file is added, its getDir() field is set correctly
	// (not NULL, correct name).
	TEST_F(FileManagerTest, getVirtualFileSetsTheDirFieldCorrectly) {
	const FileEntry *file = manager.getVirtualFile("foo.cpp", 42, 0);
	ASSERT_TRUE(file != nullptr);

	const DirectoryEntry *dir = file->getDir();
	ASSERT_TRUE(dir != nullptr);
	EXPECT_EQ(".", dir->getName());

	file = manager.getVirtualFile("x/y/z.cpp", 42, 0);
	ASSERT_TRUE(file != nullptr);

	dir = file->getDir();
	ASSERT_TRUE(dir != nullptr);
	EXPECT_EQ("x/y", dir->getName());
	}

	// Before any virtual file is added, no virtual directory exists.
	TEST_F(FileManagerTest, NoVirtualDirectoryExistsBeforeAVirtualFileIsAdded) {
	// An empty FakeStatCache causes all stat calls made by the
	// FileManager to report "file/directory doesn't exist". This
	// avoids the possibility of the result of this test being affected
	// by what's in the real file system.
	manager.setStatCache(std::make_unique<FakeStatCache>());

	ASSERT_FALSE(manager.getDirectory("virtual/dir/foo"));
	ASSERT_FALSE(manager.getDirectory("virtual/dir"));
	ASSERT_FALSE(manager.getDirectory("virtual"));
	}

	// When a virtual file is added, all of its ancestors should be created.
	TEST_F(FileManagerTest, getVirtualFileCreatesDirectoryEntriesForAncestors) {
	// Fake an empty real file system.
	manager.setStatCache(std::make_unique<FakeStatCache>());

	manager.getVirtualFile("virtual/dir/bar.h", 100, 0);
	ASSERT_FALSE(manager.getDirectory("virtual/dir/foo"));

	auto dir = manager.getDirectory("virtual/dir");
	ASSERT_TRUE(dir);
	EXPECT_EQ("virtual/dir", (*dir)->getName());

	dir = manager.getDirectory("virtual");
	ASSERT_TRUE(dir);
	EXPECT_EQ("virtual", (*dir)->getName());
	}

	// getFile() returns non-NULL if a real file exists at the given path.
	TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingRealFile) {
	// Inject fake files into the file system.
	auto statCache = std::make_unique<FakeStatCache>();
	statCache->InjectDirectory("/tmp", 42);
	statCache->InjectFile("/tmp/test", 43);

	#ifdef _WIN32
	const char *DirName = "C:.";
	const char *FileName = "C:test";
	statCache->InjectDirectory(DirName, 44);
	statCache->InjectFile(FileName, 45);
	#endif

	manager.setStatCache(std::move(statCache));

	auto file = manager.getFile("/tmp/test");
	ASSERT_TRUE(file);
	ASSERT_TRUE((*file)->isValid());
	EXPECT_EQ("/tmp/test", (*file)->getName());

	const DirectoryEntry dir = (file)->getDir();
	ASSERT_TRUE(dir != nullptr);
	EXPECT_EQ("/tmp", dir->getName());

	#ifdef _WIN32
	file = manager.getFile(FileName);
	ASSERT_TRUE(file);

	dir = (*file)->getDir();
	ASSERT_TRUE(dir != NULL);
	EXPECT_EQ(DirName, dir->getName());
	#endif
	}

	// getFile() returns non-NULL if a virtual file exists at the given path.
	TEST_F(FileManagerTest, getFileReturnsValidFileEntryForExistingVirtualFile) {
	// Fake an empty real file system.
	manager.setStatCache(std::make_unique<FakeStatCache>());

	manager.getVirtualFile("virtual/dir/bar.h", 100, 0);
	auto file = manager.getFile("virtual/dir/bar.h");
	ASSERT_TRUE(file);
	ASSERT_TRUE((*file)->isValid());
	EXPECT_EQ("virtual/dir/bar.h", (*file)->getName());

	const DirectoryEntry dir = (file)->getDir();
	ASSERT_TRUE(dir != nullptr);
	EXPECT_EQ("virtual/dir", dir->getName());
	}

	// getFile() returns different FileEntries for different paths when
	// there's no aliasing.
	TEST_F(FileManagerTest, getFileReturnsDifferentFileEntriesForDifferentFiles) {
	// Inject two fake files into the file system. Different inodes
	// mean the files are not symlinked together.
	auto statCache = std::make_unique<FakeStatCache>();
	statCache->InjectDirectory(".", 41);
	statCache->InjectFile("foo.cpp", 42);
	statCache->InjectFile("bar.cpp", 43);
	manager.setStatCache(std::move(statCache));

	auto fileFoo = manager.getFile("foo.cpp");
	auto fileBar = manager.getFile("bar.cpp");
	ASSERT_TRUE(fileFoo);
	ASSERT_TRUE((*fileFoo)->isValid());
	ASSERT_TRUE(fileBar);
	ASSERT_TRUE((*fileBar)->isValid());
	EXPECT_NE(fileFoo, fileBar);
	}

	// getFile() returns an error if neither a real file nor a virtual file
	// exists at the given path.
	TEST_F(FileManagerTest, getFileReturnsErrorForNonexistentFile) {
	// Inject a fake foo.cpp into the file system.
	auto statCache = std::make_unique<FakeStatCache>();
	statCache->InjectDirectory(".", 41);
	statCache->InjectFile("foo.cpp", 42);
	statCache->InjectDirectory("MyDirectory", 49);
	manager.setStatCache(std::move(statCache));

	// Create a virtual bar.cpp file.
	manager.getVirtualFile("bar.cpp", 200, 0);

	auto file = manager.getFile("xyz.txt");
	ASSERT_FALSE(file);
	ASSERT_EQ(file.getError(), std::errc::no_such_file_or_directory);

	auto readingDirAsFile = manager.getFile("MyDirectory");
	ASSERT_FALSE(readingDirAsFile);
	ASSERT_EQ(readingDirAsFile.getError(), std::errc::is_a_directory);

	auto readingFileAsDir = manager.getDirectory("foo.cpp");
	ASSERT_FALSE(readingFileAsDir);
	ASSERT_EQ(readingFileAsDir.getError(), std::errc::not_a_directory);
	}

	// The following tests apply to Unix-like system only.

	#ifndef _WIN32

	// getFile() returns the same FileEntry for real files that are aliases.
	TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedRealFiles) {
	// Inject two real files with the same inode.
	auto statCache = std::make_unique<FakeStatCache>();
	statCache->InjectDirectory("abc", 41);
	statCache->InjectFile("abc/foo.cpp", 42);
	statCache->InjectFile("abc/bar.cpp", 42);
	manager.setStatCache(std::move(statCache));

	auto f1 = manager.getFile("abc/foo.cpp");
	auto f2 = manager.getFile("abc/bar.cpp");

	EXPECT_EQ(f1 ? *f1 : nullptr,
	f2 ? *f2 : nullptr);
	}

	// getFile() returns the same FileEntry for virtual files that have
	// corresponding real files that are aliases.
	TEST_F(FileManagerTest, getFileReturnsSameFileEntryForAliasedVirtualFiles) {
	// Inject two real files with the same inode.
	auto statCache = std::make_unique<FakeStatCache>();
	statCache->InjectDirectory("abc", 41);
	statCache->InjectFile("abc/foo.cpp", 42);
	statCache->InjectFile("abc/bar.cpp", 42);
	manager.setStatCache(std::move(statCache));

	ASSERT_TRUE(manager.getVirtualFile("abc/foo.cpp", 100, 0)->isValid());
	ASSERT_TRUE(manager.getVirtualFile("abc/bar.cpp", 200, 0)->isValid());

	auto f1 = manager.getFile("abc/foo.cpp");
	auto f2 = manager.getFile("abc/bar.cpp");

	EXPECT_EQ(f1 ? *f1 : nullptr,
	f2 ? *f2 : nullptr);
	}

	// getFile() Should return the same entry as getVirtualFile if the file actually
	// is a virtual file, even if the name is not exactly the same (but is after
	// normalisation done by the file system, like on Windows). This can be checked
	// here by checking the size.
	TEST_F(FileManagerTest, getVirtualFileWithDifferentName) {
	// Inject fake files into the file system.
	auto statCache = std::make_unique<FakeStatCache>();
	statCache->InjectDirectory("c:\\tmp", 42);
	statCache->InjectFile("c:\\tmp\\test", 43);

	manager.setStatCache(std::move(statCache));

	// Inject the virtual file:
	const FileEntry *file1 = manager.getVirtualFile("c:\\tmp\\test", 123, 1);
	ASSERT_TRUE(file1 != nullptr);
	ASSERT_TRUE(file1->isValid());
	EXPECT_EQ(43U, file1->getUniqueID().getFile());
	EXPECT_EQ(123, file1->getSize());

	// Lookup the virtual file with a different name:
	auto file2 = manager.getFile("c:/tmp/test", 100, 1);
	ASSERT_TRUE(file2);
	ASSERT_TRUE((*file2)->isValid());
	// Check that it's the same UFE:
	EXPECT_EQ(file1, *file2);
	EXPECT_EQ(43U, (*file2)->getUniqueID().getFile());
	// Check that the contents of the UFE are not overwritten by the entry in the
	// filesystem:
	EXPECT_EQ(123, (*file2)->getSize());
	}

	#endif // !_WIN32

	TEST_F(FileManagerTest, makeAbsoluteUsesVFS) {
	SmallString<64> CustomWorkingDir;
	#ifdef _WIN32
	CustomWorkingDir = "C:";
	#else
	CustomWorkingDir = "/";
	#endif
	llvm::sys::path::append(CustomWorkingDir, "some", "weird", "path");

	auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
	new llvm::vfs::InMemoryFileSystem);
	// setCurrentworkingdirectory must finish without error.
	ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));

	FileSystemOptions Opts;
	FileManager Manager(Opts, FS);

	SmallString<64> Path("a/foo.cpp");

	SmallString<64> ExpectedResult(CustomWorkingDir);
	llvm::sys::path::append(ExpectedResult, Path);

	ASSERT_TRUE(Manager.makeAbsolutePath(Path));
	EXPECT_EQ(Path, ExpectedResult);
	}

	// getVirtualFile should always fill the real path.
	TEST_F(FileManagerTest, getVirtualFileFillsRealPathName) {
	SmallString<64> CustomWorkingDir;
	#ifdef _WIN32
	CustomWorkingDir = "C:/";
	#else
	CustomWorkingDir = "/";
	#endif

	auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
	new llvm::vfs::InMemoryFileSystem);
	// setCurrentworkingdirectory must finish without error.
	ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));

	FileSystemOptions Opts;
	FileManager Manager(Opts, FS);

	// Inject fake files into the file system.
	auto statCache = std::make_unique<FakeStatCache>();
	statCache->InjectDirectory("/tmp", 42);
	statCache->InjectFile("/tmp/test", 43);

	Manager.setStatCache(std::move(statCache));

	// Check for real path.
	const FileEntry *file = Manager.getVirtualFile("/tmp/test", 123, 1);
	ASSERT_TRUE(file != nullptr);
	ASSERT_TRUE(file->isValid());
	SmallString<64> ExpectedResult = CustomWorkingDir;

	llvm::sys::path::append(ExpectedResult, "tmp", "test");
	EXPECT_EQ(file->tryGetRealPathName(), ExpectedResult);
	}

	TEST_F(FileManagerTest, getFileDontOpenRealPath) {
	SmallString<64> CustomWorkingDir;
	#ifdef _WIN32
	CustomWorkingDir = "C:/";
	#else
	CustomWorkingDir = "/";
	#endif

	auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
	new llvm::vfs::InMemoryFileSystem);
	// setCurrentworkingdirectory must finish without error.
	ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));

	FileSystemOptions Opts;
	FileManager Manager(Opts, FS);

	// Inject fake files into the file system.
	auto statCache = std::make_unique<FakeStatCache>();
	statCache->InjectDirectory("/tmp", 42);
	statCache->InjectFile("/tmp/test", 43);

	Manager.setStatCache(std::move(statCache));

	// Check for real path.
	auto file = Manager.getFile("/tmp/test", /OpenFile=/false);
	ASSERT_TRUE(file);
	ASSERT_TRUE((*file)->isValid());
	SmallString<64> ExpectedResult = CustomWorkingDir;

	llvm::sys::path::append(ExpectedResult, "tmp", "test");
	EXPECT_EQ((*file)->tryGetRealPathName(), ExpectedResult);
	}

	TEST_F(FileManagerTest, getBypassFile) {
	SmallString<64> CustomWorkingDir;
	#ifdef _WIN32
	CustomWorkingDir = "C:/";
	#else
	CustomWorkingDir = "/";
	#endif

	auto FS = IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem>(
	new llvm::vfs::InMemoryFileSystem);
	// setCurrentworkingdirectory must finish without error.
	ASSERT_TRUE(!FS->setCurrentWorkingDirectory(CustomWorkingDir));

	FileSystemOptions Opts;
	FileManager Manager(Opts, FS);

	// Inject fake files into the file system.
	auto Cache = std::make_unique<FakeStatCache>();
	Cache->InjectDirectory("/tmp", 42);
	Cache->InjectFile("/tmp/test", 43);
	Manager.setStatCache(std::move(Cache));

	// Set up a virtual file with a different size than FakeStatCache uses.
	const FileEntry File = Manager.getVirtualFile("/tmp/test", /Size=*/10, 0);
	ASSERT_TRUE(File);
	FileEntryRef Ref("/tmp/test", *File);
	EXPECT_TRUE(Ref.isValid());
	EXPECT_EQ(Ref.getSize(), 10);

	// Calling a second time should not affect the UID or size.
	unsigned VirtualUID = Ref.getUID();
	EXPECT_EQ(*expectedToOptional(Manager.getFileRef("/tmp/test")), Ref);
	EXPECT_EQ(Ref.getUID(), VirtualUID);
	EXPECT_EQ(Ref.getSize(), 10);

	// Bypass the file.
	llvm::Optional<FileEntryRef> BypassRef = Manager.getBypassFile(Ref);
	ASSERT_TRUE(BypassRef);
	EXPECT_TRUE(BypassRef->isValid());
	EXPECT_EQ(BypassRef->getName(), Ref.getName());

	// Check that it's different in the right ways.
	EXPECT_NE(&BypassRef->getFileEntry(), File);
	EXPECT_NE(BypassRef->getUID(), VirtualUID);
	EXPECT_NE(BypassRef->getSize(), Ref.getSize());

	// The virtual file should still be returned when searching.
	EXPECT_EQ(*expectedToOptional(Manager.getFileRef("/tmp/test")), Ref);
	}

	} // anonymous namespace