This is an archive of the discontinued LLVM Phabricator instance.

[clangd] Split code-completion tests out of ClangdTests. NFC.
ClosedPublic

Authored by sammccall on Dec 4 2017, 6:34 AM.

Download Raw Diff

Details

Reviewers

Commits

rG9aad25f193b3: [clangd] Split code-completion tests out of ClangdTests. NFC.
rCTE319741: [clangd] Split code-completion tests out of ClangdTests. NFC.
rL319741: [clangd] Split code-completion tests out of ClangdTests. NFC.

Summary

Common parts are mostly FS related, so pulled out TestFS.h for the common stuff.
Deliberately resisted cleaning up much here, so this is pretty mechanical.

Diff Detail

Repository: rL LLVM

Event Timeline

sammccall created this revision.Dec 4 2017, 6:34 AM

Herald added subscribers: cfe-commits, ilya-biryukov, mgorny, klimek. · View Herald TranscriptDec 4 2017, 6:34 AM

Harbormaster completed remote builds in B12718: Diff 125329.Dec 4 2017, 6:34 AM

LGTM.

unittests/clangd/CMakeLists.txt
16 ↗	(On Diff #125329)	nit: maybe name it FSTests.cpp? to be consistent with other test file names.

This revision is now accepted and ready to land.Dec 4 2017, 6:45 AM

sammccall added inline comments.Dec 4 2017, 11:20 PM

unittests/clangd/CMakeLists.txt
16 ↗	(On Diff #125329)	Ah, this is deliberately inconsistent, though :-) This isn't a test file, it's a library that's used by tests.

Closed by commit rL319741: [clangd] Split code-completion tests out of ClangdTests. NFC. (authored by sammccall). · Explain WhyDec 4 2017, 11:21 PM

This revision was automatically updated to reflect the committed changes.

Revision Contents

Path

Size

clang-tools-extra/

trunk/

clangd/

CodeComplete.cpp

11 lines

unittests/

clangd/

CMakeLists.txt

2 lines

ClangdTests.cpp

553 lines

CodeCompleteTests.cpp

400 lines

TestFS.h

57 lines

TestFS.cpp

176 lines

Diff 125474

clang-tools-extra/trunk/clangd/CodeComplete.cpp

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Lines	for (const auto &Chunk : CCS) {
default:		default:
Result += Chunk.Text;		Result += Chunk.Text;
break;		break;
}		}
}		}
return Result;		return Result;
}		}


/// A scored code completion result.		/// A scored code completion result.
/// It may be promoted to a CompletionItem if it's among the top-ranked results.		/// It may be promoted to a CompletionItem if it's among the top-ranked results.
struct CompletionCandidate {		struct CompletionCandidate {
CompletionCandidate(CodeCompletionResult &Result)		CompletionCandidate(CodeCompletionResult &Result)
: Result(&Result), Score(score(Result)) {}		: Result(&Result), Score(score(Result)) {}

CodeCompletionResult *Result;		CodeCompletionResult *Result;
float Score; // 0 to 1, higher is better.		float Score; // 0 to 1, higher is better.
▲ Show 20 Lines • Show All 169 Lines • ▼ Show 20 Lines	bool isInformativeQualifierChunk(CodeCompletionString::Chunk const &Chunk) {
return Chunk.Kind == CodeCompletionString::CK_Informative &&		return Chunk.Kind == CodeCompletionString::CK_Informative &&
StringRef(Chunk.Text).endswith("::");		StringRef(Chunk.Text).endswith("::");
}		}

class PlainTextCompletionItemsCollector final		class PlainTextCompletionItemsCollector final
: public CompletionItemsCollector {		: public CompletionItemsCollector {

public:		public:
PlainTextCompletionItemsCollector(		PlainTextCompletionItemsCollector(const CodeCompleteOptions &CodeCompleteOpts,
const CodeCompleteOptions &CodeCompleteOpts,
CompletionList &Items)		CompletionList &Items)
: CompletionItemsCollector(CodeCompleteOpts, Items) {}		: CompletionItemsCollector(CodeCompleteOpts, Items) {}

private:		private:
void ProcessChunks(const CodeCompletionString &CCS,		void ProcessChunks(const CodeCompletionString &CCS,
CompletionItem &Item) const override {		CompletionItem &Item) const override {
for (const auto &Chunk : CCS) {		for (const auto &Chunk : CCS) {
// Informative qualifier chunks only clutter completion results, skip		// Informative qualifier chunks only clutter completion results, skip
// them.		// them.
Show All 18 Lines	for (const auto &Chunk : CCS) {
}		}
}		}
}		}
}; // PlainTextCompletionItemsCollector		}; // PlainTextCompletionItemsCollector

class SnippetCompletionItemsCollector final : public CompletionItemsCollector {		class SnippetCompletionItemsCollector final : public CompletionItemsCollector {

public:		public:
SnippetCompletionItemsCollector(		SnippetCompletionItemsCollector(const CodeCompleteOptions &CodeCompleteOpts,
const CodeCompleteOptions &CodeCompleteOpts,
CompletionList &Items)		CompletionList &Items)
: CompletionItemsCollector(CodeCompleteOpts, Items) {}		: CompletionItemsCollector(CodeCompleteOpts, Items) {}

private:		private:
void ProcessChunks(const CodeCompletionString &CCS,		void ProcessChunks(const CodeCompletionString &CCS,
CompletionItem &Item) const override {		CompletionItem &Item) const override {
unsigned ArgCount = 0;		unsigned ArgCount = 0;
for (const auto &Chunk : CCS) {		for (const auto &Chunk : CCS) {
// Informative qualifier chunks only clutter completion results, skip		// Informative qualifier chunks only clutter completion results, skip
▲ Show 20 Lines • Show All 307 Lines • Show Last 20 Lines

clang-tools-extra/trunk/unittests/clangd/CMakeLists.txt

	set(LLVM_LINK_COMPONENTS			set(LLVM_LINK_COMPONENTS
	support			support
	)			)

	get_filename_component(CLANGD_SOURCE_DIR			get_filename_component(CLANGD_SOURCE_DIR
	${CMAKE_CURRENT_SOURCE_DIR}/../../clangd REALPATH)			${CMAKE_CURRENT_SOURCE_DIR}/../../clangd REALPATH)
	include_directories(			include_directories(
	${CLANGD_SOURCE_DIR}			${CLANGD_SOURCE_DIR}
	)			)

	add_extra_unittest(ClangdTests			add_extra_unittest(ClangdTests
	ClangdTests.cpp			ClangdTests.cpp
				CodeCompleteTests.cpp
	FuzzyMatchTests.cpp			FuzzyMatchTests.cpp
	JSONExprTests.cpp			JSONExprTests.cpp
				TestFS.cpp
	TraceTests.cpp			TraceTests.cpp
	)			)

	target_link_libraries(ClangdTests			target_link_libraries(ClangdTests
	clangBasic			clangBasic
	clangDaemon			clangDaemon
	clangFormat			clangFormat
	clangFrontend			clangFrontend
	clangSema			clangSema
	clangTooling			clangTooling
	clangToolingCore			clangToolingCore
	LLVMSupport			LLVMSupport
	)			)

clang-tools-extra/trunk/unittests/clangd/ClangdTests.cpp

//===-- ClangdTests.cpp - Clangd unit tests ---------------------- C++ --===//		//===-- ClangdTests.cpp - Clangd unit tests ---------------------- C++ --===//
//		//
// The LLVM Compiler Infrastructure		// The LLVM Compiler Infrastructure
//		//
// This file is distributed under the University of Illinois Open Source		// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.		// License. See LICENSE.TXT for details.
//		//
//===----------------------------------------------------------------------===//		//===----------------------------------------------------------------------===//

#include "ClangdLSPServer.h"		#include "ClangdLSPServer.h"
#include "ClangdServer.h"		#include "ClangdServer.h"
#include "Logger.h"		#include "Logger.h"
#include "clang/Basic/VirtualFileSystem.h"		#include "TestFS.h"
#include "clang/Config/config.h"		#include "clang/Config/config.h"
#include "llvm/ADT/SmallVector.h"		#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"		#include "llvm/ADT/StringMap.h"
#include "llvm/Support/Errc.h"		#include "llvm/Support/Errc.h"
#include "llvm/Support/Path.h"		#include "llvm/Support/Path.h"
#include "llvm/Support/Regex.h"		#include "llvm/Support/Regex.h"
#include "gtest/gtest.h"		#include "gtest/gtest.h"
#include <algorithm>		#include <algorithm>
#include <chrono>		#include <chrono>
#include <iostream>		#include <iostream>
#include <random>		#include <random>
#include <string>		#include <string>
#include <thread>		#include <thread>
#include <vector>		#include <vector>

namespace clang {		namespace clang {
namespace vfs {

/// An implementation of vfs::FileSystem that only allows access to
/// files and folders inside a set of whitelisted directories.
///
/// FIXME(ibiryukov): should it also emulate access to parents of whitelisted
/// directories with only whitelisted contents?
class FilteredFileSystem : public vfs::FileSystem {
public:
/// The paths inside \p WhitelistedDirs should be absolute
FilteredFileSystem(std::vector<std::string> WhitelistedDirs,
IntrusiveRefCntPtr<vfs::FileSystem> InnerFS)
: WhitelistedDirs(std::move(WhitelistedDirs)), InnerFS(InnerFS) {
assert(std::all_of(WhitelistedDirs.begin(), WhitelistedDirs.end(),
[](const std::string &Path) -> bool {
return llvm::sys::path::is_absolute(Path);
}) &&
"Not all WhitelistedDirs are absolute");
}

virtual llvm::ErrorOr<Status> status(const Twine &Path) {
if (!isInsideWhitelistedDir(Path))
return llvm::errc::no_such_file_or_directory;
return InnerFS->status(Path);
}

virtual llvm::ErrorOr<std::unique_ptr<File>>
openFileForRead(const Twine &Path) {
if (!isInsideWhitelistedDir(Path))
return llvm::errc::no_such_file_or_directory;
return InnerFS->openFileForRead(Path);
}

llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
getBufferForFile(const Twine &Name, int64_t FileSize = -1,
bool RequiresNullTerminator = true,
bool IsVolatile = false) {
if (!isInsideWhitelistedDir(Name))
return llvm::errc::no_such_file_or_directory;
return InnerFS->getBufferForFile(Name, FileSize, RequiresNullTerminator,
IsVolatile);
}

virtual directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) {
if (!isInsideWhitelistedDir(Dir)) {
EC = llvm::errc::no_such_file_or_directory;
return directory_iterator();
}
return InnerFS->dir_begin(Dir, EC);
}

virtual std::error_code setCurrentWorkingDirectory(const Twine &Path) {
return InnerFS->setCurrentWorkingDirectory(Path);
}

virtual llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const {
return InnerFS->getCurrentWorkingDirectory();
}

bool exists(const Twine &Path) {
if (!isInsideWhitelistedDir(Path))
return false;
return InnerFS->exists(Path);
}

std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const {
return InnerFS->makeAbsolute(Path);
}

private:
bool isInsideWhitelistedDir(const Twine &InputPath) const {
SmallString<128> Path;
InputPath.toVector(Path);

if (makeAbsolute(Path))
return false;

for (const auto &Dir : WhitelistedDirs) {
if (Path.startswith(Dir))
return true;
}
return false;
}

std::vector<std::string> WhitelistedDirs;
IntrusiveRefCntPtr<vfs::FileSystem> InnerFS;
};

/// Create a vfs::FileSystem that has access only to temporary directories
/// (obtained by calling system_temp_directory).
IntrusiveRefCntPtr<vfs::FileSystem> getTempOnlyFS() {
llvm::SmallString<128> TmpDir1;
llvm::sys::path::system_temp_directory(/erasedOnReboot=/false, TmpDir1);
llvm::SmallString<128> TmpDir2;
llvm::sys::path::system_temp_directory(/erasedOnReboot=/true, TmpDir2);

std::vector<std::string> TmpDirs;
TmpDirs.push_back(TmpDir1.str());
if (TmpDir1 != TmpDir2)
TmpDirs.push_back(TmpDir2.str());
return new vfs::FilteredFileSystem(std::move(TmpDirs),
vfs::getRealFileSystem());
}
} // namespace vfs

namespace clangd {		namespace clangd {
namespace {		namespace {

struct StringWithPos {
std::string Text;
clangd::Position MarkerPos;
};

/// Returns location of "{mark}" substring in \p Text and removes it from \p
/// Text. Note that \p Text must contain exactly one occurence of "{mark}".
///
/// Marker name can be configured using \p MarkerName parameter.
StringWithPos parseTextMarker(StringRef Text, StringRef MarkerName = "mark") {
SmallString<16> Marker;
Twine("{" + MarkerName + "}").toVector(/ref/ Marker);

std::size_t MarkerOffset = Text.find(Marker);
assert(MarkerOffset != StringRef::npos && "{mark} wasn't found in Text.");

std::string WithoutMarker;
WithoutMarker += Text.take_front(MarkerOffset);
WithoutMarker += Text.drop_front(MarkerOffset + Marker.size());
assert(StringRef(WithoutMarker).find(Marker) == StringRef::npos &&
"There were multiple occurences of {mark} inside Text");

clangd::Position MarkerPos =
clangd::offsetToPosition(WithoutMarker, MarkerOffset);
return {std::move(WithoutMarker), MarkerPos};
}

// Don't wait for async ops in clangd test more than that to avoid blocking		// Don't wait for async ops in clangd test more than that to avoid blocking
// indefinitely in case of bugs.		// indefinitely in case of bugs.
static const std::chrono::seconds DefaultFutureTimeout =		static const std::chrono::seconds DefaultFutureTimeout =
std::chrono::seconds(10);		std::chrono::seconds(10);

static bool diagsContainErrors(ArrayRef<DiagWithFixIts> Diagnostics) {		static bool diagsContainErrors(ArrayRef<DiagWithFixIts> Diagnostics) {
for (const auto &DiagAndFixIts : Diagnostics) {		for (const auto &DiagAndFixIts : Diagnostics) {
// FIXME: severities returned by clangd should have a descriptive		// FIXME: severities returned by clangd should have a descriptive
Show All 25 Lines	public:
VFSTag lastVFSTag() { return LastVFSTag; }		VFSTag lastVFSTag() { return LastVFSTag; }

private:		private:
std::mutex Mutex;		std::mutex Mutex;
bool HadErrorInLastDiags = false;		bool HadErrorInLastDiags = false;
VFSTag LastVFSTag = VFSTag();		VFSTag LastVFSTag = VFSTag();
};		};

class MockCompilationDatabase : public GlobalCompilationDatabase {
public:
MockCompilationDatabase(bool AddFreestandingFlag) {
// We have to add -ffreestanding to VFS-specific tests to avoid errors on
// implicit includes of stdc-predef.h.
if (AddFreestandingFlag)
ExtraClangFlags.push_back("-ffreestanding");
}

llvm::Optional<tooling::CompileCommand>
getCompileCommand(PathRef File) const override {
if (ExtraClangFlags.empty())
return llvm::None;

auto CommandLine = ExtraClangFlags;
CommandLine.insert(CommandLine.begin(), "clang");
CommandLine.insert(CommandLine.end(), File.str());
return {tooling::CompileCommand(llvm::sys::path::parent_path(File),
llvm::sys::path::filename(File),
std::move(CommandLine), "")};
}

std::vector<std::string> ExtraClangFlags;
};

IntrusiveRefCntPtr<vfs::FileSystem>
buildTestFS(llvm::StringMap<std::string> const &Files) {
IntrusiveRefCntPtr<vfs::InMemoryFileSystem> MemFS(
new vfs::InMemoryFileSystem);
for (auto &FileAndContents : Files)
MemFS->addFile(FileAndContents.first(), time_t(),
llvm::MemoryBuffer::getMemBuffer(FileAndContents.second,
FileAndContents.first()));

auto OverlayFS = IntrusiveRefCntPtr<vfs::OverlayFileSystem>(
new vfs::OverlayFileSystem(vfs::getTempOnlyFS()));
OverlayFS->pushOverlay(std::move(MemFS));
return OverlayFS;
}

class ConstantFSProvider : public FileSystemProvider {		class ConstantFSProvider : public FileSystemProvider {
public:		public:
ConstantFSProvider(IntrusiveRefCntPtr<vfs::FileSystem> FS,		ConstantFSProvider(IntrusiveRefCntPtr<vfs::FileSystem> FS,
VFSTag Tag = VFSTag())		VFSTag Tag = VFSTag())
: FS(std::move(FS)), Tag(std::move(Tag)) {}		: FS(std::move(FS)), Tag(std::move(Tag)) {}

Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>		Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>
getTaggedFileSystem(PathRef File) override {		getTaggedFileSystem(PathRef File) override {
return make_tagged(FS, Tag);		return make_tagged(FS, Tag);
}		}

private:		private:
IntrusiveRefCntPtr<vfs::FileSystem> FS;		IntrusiveRefCntPtr<vfs::FileSystem> FS;
VFSTag Tag;		VFSTag Tag;
};		};

class MockFSProvider : public FileSystemProvider {
public:
Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>
getTaggedFileSystem(PathRef File) override {
if (ExpectedFile) {
EXPECT_EQ(*ExpectedFile, File);
}

auto FS = buildTestFS(Files);
return make_tagged(FS, Tag);
}

llvm::Optional<SmallString<32>> ExpectedFile;
llvm::StringMap<std::string> Files;
VFSTag Tag = VFSTag();
};

/// Replaces all patterns of the form 0x123abc with spaces		/// Replaces all patterns of the form 0x123abc with spaces
std::string replacePtrsInDump(std::string const &Dump) {		std::string replacePtrsInDump(std::string const &Dump) {
llvm::Regex RE("0x[0-9a-fA-F]+");		llvm::Regex RE("0x[0-9a-fA-F]+");
llvm::SmallVector<StringRef, 1> Matches;		llvm::SmallVector<StringRef, 1> Matches;
llvm::StringRef Pending = Dump;		llvm::StringRef Pending = Dump;

std::string Result;		std::string Result;
while (RE.match(Pending, &Matches)) {		while (RE.match(Pending, &Matches)) {
Show All 12 Lines	std::string dumpASTWithoutMemoryLocs(ClangdServer &Server, PathRef File) {
auto DumpWithMemLocs = Server.dumpAST(File);		auto DumpWithMemLocs = Server.dumpAST(File);
return replacePtrsInDump(DumpWithMemLocs);		return replacePtrsInDump(DumpWithMemLocs);
}		}

} // namespace		} // namespace

class ClangdVFSTest : public ::testing::Test {		class ClangdVFSTest : public ::testing::Test {
protected:		protected:
SmallString<16> getVirtualTestRoot() {
#ifdef LLVM_ON_WIN32
return SmallString<16>("C:\\clangd-test");
#else
return SmallString<16>("/clangd-test");
#endif
}

llvm::SmallString<32> getVirtualTestFilePath(PathRef File) {
assert(llvm::sys::path::is_relative(File) && "FileName should be relative");

llvm::SmallString<32> Path;
llvm::sys::path::append(Path, getVirtualTestRoot(), File);
return Path;
}

std::string parseSourceAndDumpAST(		std::string parseSourceAndDumpAST(
PathRef SourceFileRelPath, StringRef SourceContents,		PathRef SourceFileRelPath, StringRef SourceContents,
std::vector<std::pair<PathRef, StringRef>> ExtraFiles = {},		std::vector<std::pair<PathRef, StringRef>> ExtraFiles = {},
bool ExpectErrors = false) {		bool ExpectErrors = false) {
MockFSProvider FS;		MockFSProvider FS;
ErrorCheckingDiagConsumer DiagConsumer;		ErrorCheckingDiagConsumer DiagConsumer;
MockCompilationDatabase CDB(/AddFreestandingFlag=/true);		MockCompilationDatabase CDB(/AddFreestandingFlag=/true);
ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),		ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
▲ Show 20 Lines • Show All 285 Lines • ▼ Show 20 Lines	)cpp";
EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());		EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());
// Subsequent addDocument calls should finish without errors too.		// Subsequent addDocument calls should finish without errors too.
Server.addDocument(FooCpp, SourceContents1);		Server.addDocument(FooCpp, SourceContents1);
EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());		EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());
Server.addDocument(FooCpp, SourceContents2);		Server.addDocument(FooCpp, SourceContents2);
EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());		EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());
}		}

class ClangdCompletionTest : public ClangdVFSTest {
protected:
template <class Predicate>
bool ContainsItemPred(CompletionList const &Items, Predicate Pred) {
for (const auto &Item : Items.items) {
if (Pred(Item))
return true;
}
return false;
}

bool ContainsItem(CompletionList const &Items, StringRef Name) {
return ContainsItemPred(Items, [Name](clangd::CompletionItem Item) {
return Item.insertText == Name;
});
return false;
}
};

TEST_F(ClangdCompletionTest, CheckContentsOverride) {
MockFSProvider FS;
ErrorCheckingDiagConsumer DiagConsumer;
MockCompilationDatabase CDB(/AddFreestandingFlag=/true);

ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
/StorePreamblesInMemory=/true,
clangd::CodeCompleteOptions(),
EmptyLogger::getInstance());

auto FooCpp = getVirtualTestFilePath("foo.cpp");
const auto SourceContents = R"cpp(
int aba;
int b = ;
)cpp";

const auto OverridenSourceContents = R"cpp(
int cbc;
int b = ;
)cpp";
// Complete after '=' sign. We need to be careful to keep the SourceContents'
// size the same.
// We complete on the 3rd line (2nd in zero-based numbering), because raw
// string literal of the SourceContents starts with a newline(it's easy to
// miss).
Position CompletePos = {2, 8};
FS.Files[FooCpp] = SourceContents;
FS.ExpectedFile = FooCpp;

// No need to sync reparses here as there are no asserts on diagnostics (or
// other async operations).
Server.addDocument(FooCpp, SourceContents);

{
auto CodeCompletionResults1 =
Server.codeComplete(FooCpp, CompletePos, None).get().Value;
EXPECT_TRUE(ContainsItem(CodeCompletionResults1, "aba"));
EXPECT_FALSE(ContainsItem(CodeCompletionResults1, "cbc"));
}

{
auto CodeCompletionResultsOverriden =
Server
.codeComplete(FooCpp, CompletePos,
StringRef(OverridenSourceContents))
.get()
.Value;
EXPECT_TRUE(ContainsItem(CodeCompletionResultsOverriden, "cbc"));
EXPECT_FALSE(ContainsItem(CodeCompletionResultsOverriden, "aba"));
}

{
auto CodeCompletionResults2 =
Server.codeComplete(FooCpp, CompletePos, None).get().Value;
EXPECT_TRUE(ContainsItem(CodeCompletionResults2, "aba"));
EXPECT_FALSE(ContainsItem(CodeCompletionResults2, "cbc"));
}
}

TEST_F(ClangdCompletionTest, Limit) {
MockFSProvider FS;
MockCompilationDatabase CDB(/AddFreestandingFlag=/true);
CDB.ExtraClangFlags.push_back("-xc++");
ErrorCheckingDiagConsumer DiagConsumer;
clangd::CodeCompleteOptions Opts;
Opts.Limit = 2;
ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
/StorePreamblesInMemory=/true, Opts,
EmptyLogger::getInstance());

auto FooCpp = getVirtualTestFilePath("foo.cpp");
FS.Files[FooCpp] = "";
FS.ExpectedFile = FooCpp;
StringWithPos Completion = parseTextMarker(R"cpp(
struct ClassWithMembers {
int AAA();
int BBB();
int CCC();
}
int main() { ClassWithMembers().{complete} }
)cpp",
"complete");
Server.addDocument(FooCpp, Completion.Text);

/// For after-dot completion we must always get consistent results.
auto Results = Server
.codeComplete(FooCpp, Completion.MarkerPos,
StringRef(Completion.Text))
.get()
.Value;

EXPECT_TRUE(Results.isIncomplete);
EXPECT_EQ(Opts.Limit, Results.items.size());
EXPECT_TRUE(ContainsItem(Results, "AAA"));
EXPECT_TRUE(ContainsItem(Results, "BBB"));
EXPECT_FALSE(ContainsItem(Results, "CCC"));
}

TEST_F(ClangdCompletionTest, Filter) {
MockFSProvider FS;
MockCompilationDatabase CDB(/AddFreestandingFlag=/true);
CDB.ExtraClangFlags.push_back("-xc++");
ErrorCheckingDiagConsumer DiagConsumer;
clangd::CodeCompleteOptions Opts;
ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
/StorePreamblesInMemory=/true, Opts,
EmptyLogger::getInstance());

auto FooCpp = getVirtualTestFilePath("foo.cpp");
FS.Files[FooCpp] = "";
FS.ExpectedFile = FooCpp;
const char *Body = R"cpp(
int Abracadabra;
int Alakazam;
struct S {
int FooBar;
int FooBaz;
int Qux;
};
)cpp";
auto Complete = [&](StringRef Query) {
StringWithPos Completion = parseTextMarker(
formatv("{0} int main() { {1}{{complete}} }", Body, Query).str(),
"complete");
Server.addDocument(FooCpp, Completion.Text);
return Server
.codeComplete(FooCpp, Completion.MarkerPos, StringRef(Completion.Text))
.get()
.Value;
};

auto Foba = Complete("S().Foba");
EXPECT_TRUE(ContainsItem(Foba, "FooBar"));
EXPECT_TRUE(ContainsItem(Foba, "FooBaz"));
EXPECT_FALSE(ContainsItem(Foba, "Qux"));

auto FR = Complete("S().FR");
EXPECT_TRUE(ContainsItem(FR, "FooBar"));
EXPECT_FALSE(ContainsItem(FR, "FooBaz"));
EXPECT_FALSE(ContainsItem(FR, "Qux"));

auto Op = Complete("S().opr");
EXPECT_TRUE(ContainsItem(Op, "operator="));

auto Aaa = Complete("aaa");
EXPECT_TRUE(ContainsItem(Aaa, "Abracadabra"));
EXPECT_TRUE(ContainsItem(Aaa, "Alakazam"));

auto UA = Complete("_a");
EXPECT_TRUE(ContainsItem(UA, "static_cast"));
EXPECT_FALSE(ContainsItem(UA, "Abracadabra"));
}

TEST_F(ClangdCompletionTest, CompletionOptions) {
MockFSProvider FS;
ErrorCheckingDiagConsumer DiagConsumer;
MockCompilationDatabase CDB(/AddFreestandingFlag=/true);
CDB.ExtraClangFlags.push_back("-xc++");

auto FooCpp = getVirtualTestFilePath("foo.cpp");
FS.Files[FooCpp] = "";
FS.ExpectedFile = FooCpp;

const auto GlobalCompletionSourceTemplate = R"cpp(
#define MACRO X

int global_var;
int global_func();

struct GlobalClass {};

struct ClassWithMembers {
/// Doc for method.
int method();
};

int test() {
struct LocalClass {};

/// Doc for local_var.
int local_var;

{complete}
}
)cpp";
const auto MemberCompletionSourceTemplate = R"cpp(
#define MACRO X

int global_var;

int global_func();

struct GlobalClass {};

struct ClassWithMembers {
/// Doc for method.
int method();

int field;
private:
int private_field;
};

int test() {
struct LocalClass {};

/// Doc for local_var.
int local_var;

ClassWithMembers().{complete}
}
)cpp";

StringWithPos GlobalCompletion =
parseTextMarker(GlobalCompletionSourceTemplate, "complete");
StringWithPos MemberCompletion =
parseTextMarker(MemberCompletionSourceTemplate, "complete");

auto TestWithOpts = [&](clangd::CodeCompleteOptions Opts) {
ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
/StorePreamblesInMemory=/true, Opts,
EmptyLogger::getInstance());
// No need to sync reparses here as there are no asserts on diagnostics (or
// other async operations).
Server.addDocument(FooCpp, GlobalCompletion.Text);

StringRef MethodItemText = Opts.EnableSnippets ? "method()" : "method";
StringRef GlobalFuncItemText =
Opts.EnableSnippets ? "global_func()" : "global_func";

/// For after-dot completion we must always get consistent results.
{
auto Results = Server
.codeComplete(FooCpp, MemberCompletion.MarkerPos,
StringRef(MemberCompletion.Text))
.get()
.Value;

// Class members. The only items that must be present in after-dor
// completion.
EXPECT_TRUE(ContainsItem(Results, MethodItemText));
EXPECT_TRUE(ContainsItem(Results, MethodItemText));
EXPECT_TRUE(ContainsItem(Results, "field"));
EXPECT_EQ(Opts.IncludeIneligibleResults,
ContainsItem(Results, "private_field"));
// Global items.
EXPECT_FALSE(ContainsItem(Results, "global_var"));
EXPECT_FALSE(ContainsItem(Results, GlobalFuncItemText));
EXPECT_FALSE(ContainsItem(Results, "GlobalClass"));
// A macro.
EXPECT_FALSE(ContainsItem(Results, "MACRO"));
// Local items.
EXPECT_FALSE(ContainsItem(Results, "LocalClass"));
// There should be no code patterns (aka snippets) in after-dot
// completion. At least there aren't any we're aware of.
EXPECT_FALSE(
ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
return Item.kind == clangd::CompletionItemKind::Snippet;
}));
// Check documentation.
EXPECT_EQ(
Opts.IncludeBriefComments,
ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
return !Item.documentation.empty();
}));
}
// Global completion differs based on the Opts that were passed.
{
auto Results = Server
.codeComplete(FooCpp, GlobalCompletion.MarkerPos,
StringRef(GlobalCompletion.Text))
.get()
.Value;

// Class members. Should never be present in global completions.
EXPECT_FALSE(ContainsItem(Results, MethodItemText));
EXPECT_FALSE(ContainsItem(Results, "field"));
// Global items.
EXPECT_EQ(ContainsItem(Results, "global_var"), Opts.IncludeGlobals);
EXPECT_EQ(ContainsItem(Results, GlobalFuncItemText), Opts.IncludeGlobals);
EXPECT_EQ(ContainsItem(Results, "GlobalClass"), Opts.IncludeGlobals);
// A macro.
EXPECT_EQ(ContainsItem(Results, "MACRO"), Opts.IncludeMacros);
// Local items. Must be present always.
EXPECT_TRUE(ContainsItem(Results, "local_var"));
EXPECT_TRUE(ContainsItem(Results, "LocalClass"));
// FIXME(ibiryukov): snippets have wrong Item.kind now. Reenable this
// check after https://reviews.llvm.org/D38720 makes it in.
//
// Code patterns (aka snippets).
// EXPECT_EQ(
// Opts.IncludeCodePatterns && Opts.EnableSnippets,
// ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
// return Item.kind == clangd::CompletionItemKind::Snippet;
// }));

// Check documentation.
EXPECT_EQ(
Opts.IncludeBriefComments,
ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
return !Item.documentation.empty();
}));
}
};

clangd::CodeCompleteOptions CCOpts;
for (bool IncludeMacros : {true, false}){
CCOpts.IncludeMacros = IncludeMacros;
for (bool IncludeGlobals : {true, false}){
CCOpts.IncludeGlobals = IncludeGlobals;
for (bool IncludeBriefComments : {true, false}){
CCOpts.IncludeBriefComments = IncludeBriefComments;
for (bool EnableSnippets : {true, false}){
CCOpts.EnableSnippets = EnableSnippets;
for (bool IncludeCodePatterns : {true, false}) {
CCOpts.IncludeCodePatterns = IncludeCodePatterns;
for (bool IncludeIneligibleResults : {true, false}) {
CCOpts.IncludeIneligibleResults = IncludeIneligibleResults;
TestWithOpts(CCOpts);
}
}
}
}
}
}
}

class ClangdThreadingTest : public ClangdVFSTest {};		class ClangdThreadingTest : public ClangdVFSTest {};

TEST_F(ClangdThreadingTest, StressTest) {		TEST_F(ClangdThreadingTest, StressTest) {
// Without 'static' clang gives an error for a usage inside TestDiagConsumer.		// Without 'static' clang gives an error for a usage inside TestDiagConsumer.
static const unsigned FilesCount = 5;		static const unsigned FilesCount = 5;
const unsigned RequestsCount = 500;		const unsigned RequestsCount = 500;
// Blocking requests wait for the parsing to complete, they slow down the test		// Blocking requests wait for the parsing to complete, they slow down the test
// dramatically, so they are issued rarely. Each		// dramatically, so they are issued rarely. Each
▲ Show 20 Lines • Show All 390 Lines • Show Last 20 Lines

clang-tools-extra/trunk/unittests/clangd/CodeCompleteTests.cpp

				//===-- CodeCompleteTests.cpp ------------------------------------ C++ --===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				#include "ClangdServer.h"
				#include "Compiler.h"
				#include "Protocol.h"
				#include "TestFS.h"
				#include "gtest/gtest.h"

				namespace clang {
				namespace clangd {
				namespace {
				using namespace llvm;

				class IgnoreDiagnostics : public DiagnosticsConsumer {
				void onDiagnosticsReady(
				PathRef File, Tagged<std::vector<DiagWithFixIts>> Diagnostics) override {}
				};

				struct StringWithPos {
				std::string Text;
				clangd::Position MarkerPos;
				};

				/// Returns location of "{mark}" substring in \p Text and removes it from \p
				/// Text. Note that \p Text must contain exactly one occurence of "{mark}".
				///
				/// Marker name can be configured using \p MarkerName parameter.
				StringWithPos parseTextMarker(StringRef Text, StringRef MarkerName = "mark") {
				SmallString<16> Marker;
				Twine("{" + MarkerName + "}").toVector(/ref/ Marker);

				std::size_t MarkerOffset = Text.find(Marker);
				assert(MarkerOffset != StringRef::npos && "{mark} wasn't found in Text.");

				std::string WithoutMarker;
				WithoutMarker += Text.take_front(MarkerOffset);
				WithoutMarker += Text.drop_front(MarkerOffset + Marker.size());
				assert(StringRef(WithoutMarker).find(Marker) == StringRef::npos &&
				"There were multiple occurences of {mark} inside Text");

				clangd::Position MarkerPos =
				clangd::offsetToPosition(WithoutMarker, MarkerOffset);
				return {std::move(WithoutMarker), MarkerPos};
				}

				class ClangdCompletionTest : public ::testing::Test {
				protected:
				template <class Predicate>
				bool ContainsItemPred(CompletionList const &Items, Predicate Pred) {
				for (const auto &Item : Items.items) {
				if (Pred(Item))
				return true;
				}
				return false;
				}

				bool ContainsItem(CompletionList const &Items, StringRef Name) {
				return ContainsItemPred(Items, [Name](clangd::CompletionItem Item) {
				return Item.insertText == Name;
				});
				return false;
				}
				};

				TEST_F(ClangdCompletionTest, CheckContentsOverride) {
				MockFSProvider FS;
				IgnoreDiagnostics DiagConsumer;
				MockCompilationDatabase CDB(/AddFreestandingFlag=/true);

				ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
				/StorePreamblesInMemory=/true,
				clangd::CodeCompleteOptions(),
				EmptyLogger::getInstance());

				auto FooCpp = getVirtualTestFilePath("foo.cpp");
				const auto SourceContents = R"cpp(
				int aba;
				int b = ;
				)cpp";

				const auto OverridenSourceContents = R"cpp(
				int cbc;
				int b = ;
				)cpp";
				// Complete after '=' sign. We need to be careful to keep the SourceContents'
				// size the same.
				// We complete on the 3rd line (2nd in zero-based numbering), because raw
				// string literal of the SourceContents starts with a newline(it's easy to
				// miss).
				Position CompletePos = {2, 8};
				FS.Files[FooCpp] = SourceContents;
				FS.ExpectedFile = FooCpp;

				// No need to sync reparses here as there are no asserts on diagnostics (or
				// other async operations).
				Server.addDocument(FooCpp, SourceContents);

				{
				auto CodeCompletionResults1 =
				Server.codeComplete(FooCpp, CompletePos, None).get().Value;
				EXPECT_TRUE(ContainsItem(CodeCompletionResults1, "aba"));
				EXPECT_FALSE(ContainsItem(CodeCompletionResults1, "cbc"));
				}

				{
				auto CodeCompletionResultsOverriden =
				Server
				.codeComplete(FooCpp, CompletePos,
				StringRef(OverridenSourceContents))
				.get()
				.Value;
				EXPECT_TRUE(ContainsItem(CodeCompletionResultsOverriden, "cbc"));
				EXPECT_FALSE(ContainsItem(CodeCompletionResultsOverriden, "aba"));
				}

				{
				auto CodeCompletionResults2 =
				Server.codeComplete(FooCpp, CompletePos, None).get().Value;
				EXPECT_TRUE(ContainsItem(CodeCompletionResults2, "aba"));
				EXPECT_FALSE(ContainsItem(CodeCompletionResults2, "cbc"));
				}
				}

				TEST_F(ClangdCompletionTest, Limit) {
				MockFSProvider FS;
				MockCompilationDatabase CDB(/AddFreestandingFlag=/true);
				CDB.ExtraClangFlags.push_back("-xc++");
				IgnoreDiagnostics DiagConsumer;
				clangd::CodeCompleteOptions Opts;
				Opts.Limit = 2;
				ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
				/StorePreamblesInMemory=/true, Opts,
				EmptyLogger::getInstance());

				auto FooCpp = getVirtualTestFilePath("foo.cpp");
				FS.Files[FooCpp] = "";
				FS.ExpectedFile = FooCpp;
				StringWithPos Completion = parseTextMarker(R"cpp(
				struct ClassWithMembers {
				int AAA();
				int BBB();
				int CCC();
				}
				int main() { ClassWithMembers().{complete} }
				)cpp",
				"complete");
				Server.addDocument(FooCpp, Completion.Text);

				/// For after-dot completion we must always get consistent results.
				auto Results = Server
				.codeComplete(FooCpp, Completion.MarkerPos,
				StringRef(Completion.Text))
				.get()
				.Value;

				EXPECT_TRUE(Results.isIncomplete);
				EXPECT_EQ(Opts.Limit, Results.items.size());
				EXPECT_TRUE(ContainsItem(Results, "AAA"));
				EXPECT_TRUE(ContainsItem(Results, "BBB"));
				EXPECT_FALSE(ContainsItem(Results, "CCC"));
				}

				TEST_F(ClangdCompletionTest, Filter) {
				MockFSProvider FS;
				MockCompilationDatabase CDB(/AddFreestandingFlag=/true);
				CDB.ExtraClangFlags.push_back("-xc++");
				IgnoreDiagnostics DiagConsumer;
				clangd::CodeCompleteOptions Opts;
				ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
				/StorePreamblesInMemory=/true, Opts,
				EmptyLogger::getInstance());

				auto FooCpp = getVirtualTestFilePath("foo.cpp");
				FS.Files[FooCpp] = "";
				FS.ExpectedFile = FooCpp;
				const char *Body = R"cpp(
				int Abracadabra;
				int Alakazam;
				struct S {
				int FooBar;
				int FooBaz;
				int Qux;
				};
				)cpp";
				auto Complete = [&](StringRef Query) {
				StringWithPos Completion = parseTextMarker(
				formatv("{0} int main() { {1}{{complete}} }", Body, Query).str(),
				"complete");
				Server.addDocument(FooCpp, Completion.Text);
				return Server
				.codeComplete(FooCpp, Completion.MarkerPos, StringRef(Completion.Text))
				.get()
				.Value;
				};

				auto Foba = Complete("S().Foba");
				EXPECT_TRUE(ContainsItem(Foba, "FooBar"));
				EXPECT_TRUE(ContainsItem(Foba, "FooBaz"));
				EXPECT_FALSE(ContainsItem(Foba, "Qux"));

				auto FR = Complete("S().FR");
				EXPECT_TRUE(ContainsItem(FR, "FooBar"));
				EXPECT_FALSE(ContainsItem(FR, "FooBaz"));
				EXPECT_FALSE(ContainsItem(FR, "Qux"));

				auto Op = Complete("S().opr");
				EXPECT_TRUE(ContainsItem(Op, "operator="));

				auto Aaa = Complete("aaa");
				EXPECT_TRUE(ContainsItem(Aaa, "Abracadabra"));
				EXPECT_TRUE(ContainsItem(Aaa, "Alakazam"));

				auto UA = Complete("_a");
				EXPECT_TRUE(ContainsItem(UA, "static_cast"));
				EXPECT_FALSE(ContainsItem(UA, "Abracadabra"));
				}

				TEST_F(ClangdCompletionTest, CompletionOptions) {
				MockFSProvider FS;
				IgnoreDiagnostics DiagConsumer;
				MockCompilationDatabase CDB(/AddFreestandingFlag=/true);
				CDB.ExtraClangFlags.push_back("-xc++");

				auto FooCpp = getVirtualTestFilePath("foo.cpp");
				FS.Files[FooCpp] = "";
				FS.ExpectedFile = FooCpp;

				const auto GlobalCompletionSourceTemplate = R"cpp(
				#define MACRO X

				int global_var;
				int global_func();

				struct GlobalClass {};

				struct ClassWithMembers {
				/// Doc for method.
				int method();
				};

				int test() {
				struct LocalClass {};

				/// Doc for local_var.
				int local_var;

				{complete}
				}
				)cpp";
				const auto MemberCompletionSourceTemplate = R"cpp(
				#define MACRO X

				int global_var;

				int global_func();

				struct GlobalClass {};

				struct ClassWithMembers {
				/// Doc for method.
				int method();

				int field;
				private:
				int private_field;
				};

				int test() {
				struct LocalClass {};

				/// Doc for local_var.
				int local_var;

				ClassWithMembers().{complete}
				}
				)cpp";

				StringWithPos GlobalCompletion =
				parseTextMarker(GlobalCompletionSourceTemplate, "complete");
				StringWithPos MemberCompletion =
				parseTextMarker(MemberCompletionSourceTemplate, "complete");

				auto TestWithOpts = [&](clangd::CodeCompleteOptions Opts) {
				ClangdServer Server(CDB, DiagConsumer, FS, getDefaultAsyncThreadsCount(),
				/StorePreamblesInMemory=/true, Opts,
				EmptyLogger::getInstance());
				// No need to sync reparses here as there are no asserts on diagnostics (or
				// other async operations).
				Server.addDocument(FooCpp, GlobalCompletion.Text);

				StringRef MethodItemText = Opts.EnableSnippets ? "method()" : "method";
				StringRef GlobalFuncItemText =
				Opts.EnableSnippets ? "global_func()" : "global_func";

				/// For after-dot completion we must always get consistent results.
				{
				auto Results = Server
				.codeComplete(FooCpp, MemberCompletion.MarkerPos,
				StringRef(MemberCompletion.Text))
				.get()
				.Value;

				// Class members. The only items that must be present in after-dor
				// completion.
				EXPECT_TRUE(ContainsItem(Results, MethodItemText));
				EXPECT_TRUE(ContainsItem(Results, MethodItemText));
				EXPECT_TRUE(ContainsItem(Results, "field"));
				EXPECT_EQ(Opts.IncludeIneligibleResults,
				ContainsItem(Results, "private_field"));
				// Global items.
				EXPECT_FALSE(ContainsItem(Results, "global_var"));
				EXPECT_FALSE(ContainsItem(Results, GlobalFuncItemText));
				EXPECT_FALSE(ContainsItem(Results, "GlobalClass"));
				// A macro.
				EXPECT_FALSE(ContainsItem(Results, "MACRO"));
				// Local items.
				EXPECT_FALSE(ContainsItem(Results, "LocalClass"));
				// There should be no code patterns (aka snippets) in after-dot
				// completion. At least there aren't any we're aware of.
				EXPECT_FALSE(
				ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
				return Item.kind == clangd::CompletionItemKind::Snippet;
				}));
				// Check documentation.
				EXPECT_EQ(
				Opts.IncludeBriefComments,
				ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
				return !Item.documentation.empty();
				}));
				}
				// Global completion differs based on the Opts that were passed.
				{
				auto Results = Server
				.codeComplete(FooCpp, GlobalCompletion.MarkerPos,
				StringRef(GlobalCompletion.Text))
				.get()
				.Value;

				// Class members. Should never be present in global completions.
				EXPECT_FALSE(ContainsItem(Results, MethodItemText));
				EXPECT_FALSE(ContainsItem(Results, "field"));
				// Global items.
				EXPECT_EQ(ContainsItem(Results, "global_var"), Opts.IncludeGlobals);
				EXPECT_EQ(ContainsItem(Results, GlobalFuncItemText), Opts.IncludeGlobals);
				EXPECT_EQ(ContainsItem(Results, "GlobalClass"), Opts.IncludeGlobals);
				// A macro.
				EXPECT_EQ(ContainsItem(Results, "MACRO"), Opts.IncludeMacros);
				// Local items. Must be present always.
				EXPECT_TRUE(ContainsItem(Results, "local_var"));
				EXPECT_TRUE(ContainsItem(Results, "LocalClass"));
				// FIXME(ibiryukov): snippets have wrong Item.kind now. Reenable this
				// check after https://reviews.llvm.org/D38720 makes it in.
				//
				// Code patterns (aka snippets).
				// EXPECT_EQ(
				// Opts.IncludeCodePatterns && Opts.EnableSnippets,
				// ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
				// return Item.kind == clangd::CompletionItemKind::Snippet;
				// }));

				// Check documentation.
				EXPECT_EQ(
				Opts.IncludeBriefComments,
				ContainsItemPred(Results, [](clangd::CompletionItem const &Item) {
				return !Item.documentation.empty();
				}));
				}
				};

				clangd::CodeCompleteOptions CCOpts;
				for (bool IncludeMacros : {true, false}) {
				CCOpts.IncludeMacros = IncludeMacros;
				for (bool IncludeGlobals : {true, false}) {
				CCOpts.IncludeGlobals = IncludeGlobals;
				for (bool IncludeBriefComments : {true, false}) {
				CCOpts.IncludeBriefComments = IncludeBriefComments;
				for (bool EnableSnippets : {true, false}) {
				CCOpts.EnableSnippets = EnableSnippets;
				for (bool IncludeCodePatterns : {true, false}) {
				CCOpts.IncludeCodePatterns = IncludeCodePatterns;
				for (bool IncludeIneligibleResults : {true, false}) {
				CCOpts.IncludeIneligibleResults = IncludeIneligibleResults;
				TestWithOpts(CCOpts);
				}
				}
				}
				}
				}
				}
				}

				} // namespace
				} // namespace clangd
				} // namespace clang

clang-tools-extra/trunk/unittests/clangd/TestFS.h

				//===-- TestFS.h ------------------------------------------------- C++ --===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				//
				// Allows setting up fake filesystem environments for tests.
				//
				//===----------------------------------------------------------------------===//
				#include "ClangdServer.h"
				#include "clang/Basic/VirtualFileSystem.h"
				#include "llvm/ADT/IntrusiveRefCntPtr.h"
				#include "llvm/Support/Path.h"

				namespace clang {
				namespace clangd {

				// Builds a VFS that provides access to the provided files, plus temporary
				// directories.
				llvm::IntrusiveRefCntPtr<vfs::FileSystem>
				buildTestFS(llvm::StringMap<std::string> const &Files);

				// A VFS provider that returns TestFSes containing a provided set of files.
				class MockFSProvider : public FileSystemProvider {
				public:
				Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>
				getTaggedFileSystem(PathRef File) override;

				llvm::Optional<SmallString<32>> ExpectedFile;
				llvm::StringMap<std::string> Files;
				VFSTag Tag = VFSTag();
				};

				// A Compilation database that returns a fixed set of compile flags.
				class MockCompilationDatabase : public GlobalCompilationDatabase {
				public:
				MockCompilationDatabase(bool AddFreestandingFlag) {
				// We have to add -ffreestanding to VFS-specific tests to avoid errors on
				// implicit includes of stdc-predef.h.
				if (AddFreestandingFlag)
				ExtraClangFlags.push_back("-ffreestanding");
				}

				llvm::Optional<tooling::CompileCommand>
				getCompileCommand(PathRef File) const override;

				std::vector<std::string> ExtraClangFlags;
				};

				// Returns a suitable absolute path for this OS.
				llvm::SmallString<32> getVirtualTestFilePath(PathRef File);

				} // namespace clangd
				} // namespace clang

clang-tools-extra/trunk/unittests/clangd/TestFS.cpp

				//===-- TestFS.cpp ----------------------------------------------- C++ --===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				#include "TestFS.h"
				#include "llvm/Support/Errc.h"
				#include "gtest/gtest.h"

				namespace clang {
				namespace clangd {
				namespace {

				/// An implementation of vfs::FileSystem that only allows access to
				/// files and folders inside a set of whitelisted directories.
				///
				/// FIXME(ibiryukov): should it also emulate access to parents of whitelisted
				/// directories with only whitelisted contents?
				class FilteredFileSystem : public vfs::FileSystem {
				public:
				/// The paths inside \p WhitelistedDirs should be absolute
				FilteredFileSystem(std::vector<std::string> WhitelistedDirs,
				IntrusiveRefCntPtr<vfs::FileSystem> InnerFS)
				: WhitelistedDirs(std::move(WhitelistedDirs)), InnerFS(InnerFS) {
				assert(std::all_of(WhitelistedDirs.begin(), WhitelistedDirs.end(),
				[](const std::string &Path) -> bool {
				return llvm::sys::path::is_absolute(Path);
				}) &&
				"Not all WhitelistedDirs are absolute");
				}

				virtual llvm::ErrorOr<vfs::Status> status(const Twine &Path) {
				if (!isInsideWhitelistedDir(Path))
				return llvm::errc::no_such_file_or_directory;
				return InnerFS->status(Path);
				}

				virtual llvm::ErrorOr<std::unique_ptr<vfs::File>>
				openFileForRead(const Twine &Path) {
				if (!isInsideWhitelistedDir(Path))
				return llvm::errc::no_such_file_or_directory;
				return InnerFS->openFileForRead(Path);
				}

				llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
				getBufferForFile(const Twine &Name, int64_t FileSize = -1,
				bool RequiresNullTerminator = true,
				bool IsVolatile = false) {
				if (!isInsideWhitelistedDir(Name))
				return llvm::errc::no_such_file_or_directory;
				return InnerFS->getBufferForFile(Name, FileSize, RequiresNullTerminator,
				IsVolatile);
				}

				virtual vfs::directory_iterator dir_begin(const Twine &Dir,
				std::error_code &EC) {
				if (!isInsideWhitelistedDir(Dir)) {
				EC = llvm::errc::no_such_file_or_directory;
				return vfs::directory_iterator();
				}
				return InnerFS->dir_begin(Dir, EC);
				}

				virtual std::error_code setCurrentWorkingDirectory(const Twine &Path) {
				return InnerFS->setCurrentWorkingDirectory(Path);
				}

				virtual llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const {
				return InnerFS->getCurrentWorkingDirectory();
				}

				bool exists(const Twine &Path) {
				if (!isInsideWhitelistedDir(Path))
				return false;
				return InnerFS->exists(Path);
				}

				std::error_code makeAbsolute(SmallVectorImpl<char> &Path) const {
				return InnerFS->makeAbsolute(Path);
				}

				private:
				bool isInsideWhitelistedDir(const Twine &InputPath) const {
				SmallString<128> Path;
				InputPath.toVector(Path);

				if (makeAbsolute(Path))
				return false;

				for (const auto &Dir : WhitelistedDirs) {
				if (Path.startswith(Dir))
				return true;
				}
				return false;
				}

				std::vector<std::string> WhitelistedDirs;
				IntrusiveRefCntPtr<vfs::FileSystem> InnerFS;
				};

				/// Create a vfs::FileSystem that has access only to temporary directories
				/// (obtained by calling system_temp_directory).
				IntrusiveRefCntPtr<vfs::FileSystem> getTempOnlyFS() {
				llvm::SmallString<128> TmpDir1;
				llvm::sys::path::system_temp_directory(/erasedOnReboot=/false, TmpDir1);
				llvm::SmallString<128> TmpDir2;
				llvm::sys::path::system_temp_directory(/erasedOnReboot=/true, TmpDir2);

				std::vector<std::string> TmpDirs;
				TmpDirs.push_back(TmpDir1.str());
				if (TmpDir1 != TmpDir2)
				TmpDirs.push_back(TmpDir2.str());
				return new FilteredFileSystem(std::move(TmpDirs), vfs::getRealFileSystem());
				}

				} // namespace

				IntrusiveRefCntPtr<vfs::FileSystem>
				buildTestFS(llvm::StringMap<std::string> const &Files) {
				IntrusiveRefCntPtr<vfs::InMemoryFileSystem> MemFS(
				new vfs::InMemoryFileSystem);
				for (auto &FileAndContents : Files)
				MemFS->addFile(FileAndContents.first(), time_t(),
				llvm::MemoryBuffer::getMemBuffer(FileAndContents.second,
				FileAndContents.first()));

				auto OverlayFS = IntrusiveRefCntPtr<vfs::OverlayFileSystem>(
				new vfs::OverlayFileSystem(getTempOnlyFS()));
				OverlayFS->pushOverlay(std::move(MemFS));
				return OverlayFS;
				}

				Tagged<IntrusiveRefCntPtr<vfs::FileSystem>>
				MockFSProvider::getTaggedFileSystem(PathRef File) {
				if (ExpectedFile) {
				EXPECT_EQ(*ExpectedFile, File);
				}

				auto FS = buildTestFS(Files);
				return make_tagged(FS, Tag);
				}

				llvm::Optional<tooling::CompileCommand>
				MockCompilationDatabase::getCompileCommand(PathRef File) const {
				if (ExtraClangFlags.empty())
				return llvm::None;

				auto CommandLine = ExtraClangFlags;
				CommandLine.insert(CommandLine.begin(), "clang");
				CommandLine.insert(CommandLine.end(), File.str());
				return {tooling::CompileCommand(llvm::sys::path::parent_path(File),
				llvm::sys::path::filename(File),
				std::move(CommandLine), "")};
				}

				static const char *getVirtualTestRoot() {
				#ifdef LLVM_ON_WIN32
				return "C:\\clangd-test";
				#else
				return "/clangd-test";
				#endif
				}

				llvm::SmallString<32> getVirtualTestFilePath(PathRef File) {
				assert(llvm::sys::path::is_relative(File) && "FileName should be relative");

				llvm::SmallString<32> Path;
				llvm::sys::path::append(Path, getVirtualTestRoot(), File);
				return Path;
				}

				} // namespace clangd
				} // namespace clang