value: CamelCase
- key: readability-identifier-naming.FunctionCase
value: camelBack
+ # Exclude from scanning as this is an exported symbol used for fuzzing
+ # throughout the code base.
+ - key: readability-identifier-naming.FunctionIgnoredRegexp
+ value: "LLVMFuzzerTestOneInput"
- key: readability-identifier-naming.MemberCase
value: CamelCase
- key: readability-identifier-naming.ParameterCase
return llvm::None;
}
-const llvm::StringLiteral APPLY_FIX_COMMAND = "clangd.applyFix";
-const llvm::StringLiteral APPLY_TWEAK_COMMAND = "clangd.applyTweak";
+const llvm::StringLiteral ApplyFixCommand = "clangd.applyFix";
+const llvm::StringLiteral ApplyTweakCommand = "clangd.applyTweak";
/// Transforms a tweak into a code action that would apply it if executed.
/// EXPECTS: T.prepare() was called and returned true.
// directly.
CA.command.emplace();
CA.command->title = T.Title;
- CA.command->command = std::string(APPLY_TWEAK_COMMAND);
+ CA.command->command = std::string(ApplyTweakCommand);
TweakArgs Args;
Args.file = File;
Args.tweakID = T.ID;
if (Action.command) {
Cmd = *Action.command;
} else if (Action.edit) {
- Cmd.command = std::string(APPLY_FIX_COMMAND);
+ Cmd.command = std::string(ApplyFixCommand);
Cmd.argument = *Action.edit;
} else {
return None;
Bind.method("$/memoryUsage", this, &ClangdLSPServer::onMemoryUsage);
if (Opts.FoldingRanges)
Bind.method("textDocument/foldingRange", this, &ClangdLSPServer::onFoldingRange);
- Bind.command(APPLY_FIX_COMMAND, this, &ClangdLSPServer::onCommandApplyEdit);
- Bind.command(APPLY_TWEAK_COMMAND, this, &ClangdLSPServer::onCommandApplyTweak);
+ Bind.command(ApplyFixCommand, this, &ClangdLSPServer::onCommandApplyEdit);
+ Bind.command(ApplyTweakCommand, this, &ClangdLSPServer::onCommandApplyTweak);
ApplyWorkspaceEdit = Bind.outgoingMethod("workspace/applyEdit");
PublishDiagnostics = Bind.outgoingNotification("textDocument/publishDiagnostics");
return false;
auto FID = SM.getFileID(Loc);
// All proto generated headers should start with this line.
- static const char *PROTO_HEADER_COMMENT =
+ static const char *ProtoHeaderComment =
"// Generated by the protocol buffer compiler. DO NOT EDIT!";
// Double check that this is an actual protobuf header.
- return SM.getBufferData(FID).startswith(PROTO_HEADER_COMMENT);
+ return SM.getBufferData(FID).startswith(ProtoHeaderComment);
}
namespace {
class ASTWorker;
} // namespace
-static clang::clangd::Key<std::string> kFileBeingProcessed;
+static clang::clangd::Key<std::string> FileBeingProcessed;
llvm::Optional<llvm::StringRef> TUScheduler::getFileBeingProcessedInContext() {
- if (auto *File = Context::current().get(kFileBeingProcessed))
+ if (auto *File = Context::current().get(FileBeingProcessed))
return llvm::StringRef(*File);
return None;
}
}
// Allow this request to be cancelled if invalidated.
- Context Ctx = Context::current().derive(kFileBeingProcessed, FileName);
+ Context Ctx = Context::current().derive(FileBeingProcessed, FileName);
Canceler Invalidate = nullptr;
if (Invalidation) {
WithContext WC(std::move(Ctx));
auto Task = [Worker, Consistency, Name = Name.str(), File = File.str(),
Contents = It->second->Contents,
Command = Worker->getCurrentCompileCommand(),
- Ctx = Context::current().derive(kFileBeingProcessed,
+ Ctx = Context::current().derive(FileBeingProcessed,
std::string(File)),
Action = std::move(Action), this]() mutable {
ThreadCrashReporter ScopedReporter([&Name, &Contents, &Command]() {
QualType VisitCXXThrowExpr(const CXXThrowExpr *S) {
return S->getSubExpr()->getType();
}
- QualType VisitCoyieldStmt(const CoyieldExpr *S) {
+ // FIXME(sammccall): this should be VisitCoyieldExpr
+ // see https://reviews.llvm.org/D115634
+ QualType visitCoyieldStmt(const CoyieldExpr *S) {
return type(S->getOperand());
}
// Treat a designated initializer like a reference to the field.
return Requests;
}
-static void MemQueries(benchmark::State &State) {
+static void memQueries(benchmark::State &State) {
const auto Mem = buildMem();
const auto Requests = extractQueriesFromLogs();
for (auto _ : State)
for (const auto &Request : Requests)
Mem->fuzzyFind(Request, [](const Symbol &S) {});
}
-BENCHMARK(MemQueries);
+BENCHMARK(memQueries);
-static void DexQueries(benchmark::State &State) {
+static void dexQueries(benchmark::State &State) {
const auto Dex = buildDex();
const auto Requests = extractQueriesFromLogs();
for (auto _ : State)
for (const auto &Request : Requests)
Dex->fuzzyFind(Request, [](const Symbol &S) {});
}
-BENCHMARK(DexQueries);
+BENCHMARK(dexQueries);
-static void DexBuild(benchmark::State &State) {
+static void dexBuild(benchmark::State &State) {
for (auto _ : State)
buildDex();
}
-BENCHMARK(DexBuild);
+BENCHMARK(dexBuild);
} // namespace
} // namespace clangd
using namespace clang::clangd;
-extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size) {
- if (size == 0)
+extern "C" int LLVMFuzzerTestOneInput(uint8_t *Data, size_t Size) {
+ if (Size == 0)
return 0;
// fmemopen isn't portable, but I think we only run the fuzzer on Linux.
- std::FILE *In = fmemopen(data, size, "r");
+ std::FILE *In = fmemopen(Data, Size, "r");
auto Transport = newJSONTransport(In, llvm::nulls(),
/*InMirror=*/nullptr, /*Pretty=*/false,
/*Style=*/JSONStreamStyle::Delimited);
};
template <> struct MappingTraits<SymbolInfo> {
- static void mapping(IO &io, SymbolInfo &SymInfo) {
+ static void mapping(IO &IO, SymbolInfo &SymInfo) {
// FIXME: expose other fields?
- io.mapRequired("Kind", SymInfo.Kind);
- io.mapRequired("Lang", SymInfo.Lang);
+ IO.mapRequired("Kind", SymInfo.Kind);
+ IO.mapRequired("Lang", SymInfo.Lang);
}
};
template <>
struct MappingTraits<clang::clangd::Symbol::IncludeHeaderWithReferences> {
- static void mapping(IO &io,
+ static void mapping(IO &IO,
clang::clangd::Symbol::IncludeHeaderWithReferences &Inc) {
- io.mapRequired("Header", Inc.IncludeHeader);
- io.mapRequired("References", Inc.References);
+ IO.mapRequired("Header", Inc.IncludeHeader);
+ IO.mapRequired("References", Inc.References);
}
};
namespace clang {
namespace clangd {
-MATCHER_P(Named, N, "") { return arg.Name == N; }
-MATCHER_P(QName, N, "") { return (arg.Scope + arg.Name).str() == N; }
-MATCHER(Declared, "") {
+MATCHER_P(named, N, "") { return arg.Name == N; }
+MATCHER_P(qName, N, "") { return (arg.Scope + arg.Name).str() == N; }
+MATCHER(declared, "") {
return !StringRef(arg.CanonicalDeclaration.FileURI).empty();
}
-MATCHER(Defined, "") { return !StringRef(arg.Definition.FileURI).empty(); }
-MATCHER_P(FileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
+MATCHER(defined, "") { return !StringRef(arg.Definition.FileURI).empty(); }
+MATCHER_P(fileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
::testing::Matcher<const RefSlab &>
-RefsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
+refsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
return ElementsAre(::testing::Pair(_, UnorderedElementsAreArray(Matchers)));
}
// URI cannot be empty since it references keys in the IncludeGraph.
-MATCHER(EmptyIncludeNode, "") {
+MATCHER(emptyIncludeNode, "") {
return arg.Flags == IncludeGraphNode::SourceFlag::None && !arg.URI.empty() &&
arg.Digest == FileDigest{{0}} && arg.DirectIncludes.empty();
}
-MATCHER(HadErrors, "") {
+MATCHER(hadErrors, "") {
return arg.Flags & IncludeGraphNode::SourceFlag::HadErrors;
}
-MATCHER_P(NumReferences, N, "") { return arg.References == N; }
+MATCHER_P(numReferences, N, "") { return arg.References == N; }
class MemoryShardStorage : public BackgroundIndexStorage {
mutable std::mutex StorageMu;
// Wait for both files to be indexed.
ASSERT_TRUE(Idx.blockUntilIdleForTest());
EXPECT_THAT(runFuzzyFind(Idx, ""),
- UnorderedElementsAre(QName("foo"), QName("foo::two"),
- QName("bar"), QName("bar::one")));
+ UnorderedElementsAre(qName("foo"), qName("foo::two"),
+ qName("bar"), qName("bar::one")));
}
TEST_F(BackgroundIndexTest, IndexTwoFiles) {
ASSERT_TRUE(Idx.blockUntilIdleForTest());
EXPECT_THAT(runFuzzyFind(Idx, ""),
- UnorderedElementsAre(AllOf(Named("common"), NumReferences(1U)),
- AllOf(Named("A_CC"), NumReferences(0U)),
- AllOf(Named("g"), NumReferences(1U)),
- AllOf(Named("f_b"), Declared(),
- Not(Defined()), NumReferences(0U))));
+ UnorderedElementsAre(AllOf(named("common"), numReferences(1U)),
+ AllOf(named("A_CC"), numReferences(0U)),
+ AllOf(named("g"), numReferences(1U)),
+ AllOf(named("f_b"), declared(),
+ Not(defined()), numReferences(0U))));
Cmd.Filename = testPath("root/B.cc");
Cmd.CommandLine = {"clang++", Cmd.Filename};
ASSERT_TRUE(Idx.blockUntilIdleForTest());
// B_CC is dropped as we don't collect symbols from A.h in this compilation.
EXPECT_THAT(runFuzzyFind(Idx, ""),
- UnorderedElementsAre(AllOf(Named("common"), NumReferences(5U)),
- AllOf(Named("A_CC"), NumReferences(0U)),
- AllOf(Named("g"), NumReferences(1U)),
- AllOf(Named("f_b"), Declared(), Defined(),
- NumReferences(1U))));
+ UnorderedElementsAre(AllOf(named("common"), numReferences(5U)),
+ AllOf(named("A_CC"), numReferences(0U)),
+ AllOf(named("g"), numReferences(1U)),
+ AllOf(named("f_b"), declared(), defined(),
+ numReferences(1U))));
auto Syms = runFuzzyFind(Idx, "common");
- EXPECT_THAT(Syms, UnorderedElementsAre(Named("common")));
+ EXPECT_THAT(Syms, UnorderedElementsAre(named("common")));
auto Common = *Syms.begin();
EXPECT_THAT(getRefs(Idx, Common.ID),
- RefsAre({FileURI("unittest:///root/A.h"),
- FileURI("unittest:///root/A.cc"),
- FileURI("unittest:///root/B.cc"),
- FileURI("unittest:///root/B.cc"),
- FileURI("unittest:///root/B.cc"),
- FileURI("unittest:///root/B.cc")}));
+ refsAre({fileURI("unittest:///root/A.h"),
+ fileURI("unittest:///root/A.cc"),
+ fileURI("unittest:///root/B.cc"),
+ fileURI("unittest:///root/B.cc"),
+ fileURI("unittest:///root/B.cc"),
+ fileURI("unittest:///root/B.cc")}));
}
TEST_F(BackgroundIndexTest, MainFileRefs) {
ASSERT_TRUE(Idx.blockUntilIdleForTest());
EXPECT_THAT(
runFuzzyFind(Idx, ""),
- UnorderedElementsAre(AllOf(Named("header_sym"), NumReferences(1U)),
- AllOf(Named("main_sym"), NumReferences(1U))));
+ UnorderedElementsAre(AllOf(named("header_sym"), numReferences(1U)),
+ AllOf(named("main_sym"), numReferences(1U))));
}
TEST_F(BackgroundIndexTest, ShardStorageTest) {
void f_b();
class A_CC {};
)cpp";
- std::string A_CC = "";
FS.Files[testPath("root/A.cc")] = R"cpp(
#include "A.h"
void g() { (void)common; }
EXPECT_NE(ShardHeader, nullptr);
EXPECT_THAT(
*ShardHeader->Symbols,
- UnorderedElementsAre(Named("common"), Named("A_CC"),
- AllOf(Named("f_b"), Declared(), Not(Defined()))));
+ UnorderedElementsAre(named("common"), named("A_CC"),
+ AllOf(named("f_b"), declared(), Not(defined()))));
for (const auto &Ref : *ShardHeader->Refs)
EXPECT_THAT(Ref.second,
- UnorderedElementsAre(FileURI("unittest:///root/A.h")));
+ UnorderedElementsAre(fileURI("unittest:///root/A.h")));
auto ShardSource = MSS.loadShard(testPath("root/A.cc"));
EXPECT_NE(ShardSource, nullptr);
EXPECT_THAT(*ShardSource->Symbols,
- UnorderedElementsAre(Named("g"), Named("B_CC")));
+ UnorderedElementsAre(named("g"), named("B_CC")));
for (const auto &Ref : *ShardSource->Refs)
EXPECT_THAT(Ref.second,
- UnorderedElementsAre(FileURI("unittest:///root/A.cc")));
+ UnorderedElementsAre(fileURI("unittest:///root/A.cc")));
// The BaseOf relationship between A_CC and B_CC is stored in both the file
// containing the definition of the subject (A_CC) and the file containing
void f_b();
class A_CC {};
)cpp";
- std::string A_CC = "#include \"A.h\"\nvoid g() { (void)common; }";
- FS.Files[testPath("root/A.cc")] = A_CC;
+ FS.Files[testPath("root/A.cc")] =
+ "#include \"A.h\"\nvoid g() { (void)common; }";
llvm::StringMap<std::string> Storage;
size_t CacheHits = 0;
EXPECT_NE(ShardSource->Sources->lookup("unittest:///root/A.cc").Digest,
FileDigest{{0}});
EXPECT_THAT(ShardSource->Sources->lookup("unittest:///root/A.h"),
- EmptyIncludeNode());
+ emptyIncludeNode());
auto ShardHeader = MSS.loadShard(testPath("root/A.h"));
EXPECT_TRUE(ShardHeader->Sources);
EXPECT_NE(ShardHeader->Sources->lookup("unittest:///root/A.h").Digest,
FileDigest{{0}});
EXPECT_THAT(ShardHeader->Sources->lookup("unittest:///root/B.h"),
- EmptyIncludeNode());
+ emptyIncludeNode());
}
TEST_F(BackgroundIndexTest, ShardStorageLoad) {
// Check if the new symbol has arrived.
auto ShardHeader = MSS.loadShard(testPath("root/A.h"));
EXPECT_NE(ShardHeader, nullptr);
- EXPECT_THAT(*ShardHeader->Symbols, Contains(Named("A_CCnew")));
+ EXPECT_THAT(*ShardHeader->Symbols, Contains(named("A_CCnew")));
// Change source.
FS.Files[testPath("root/A.cc")] =
// Check if the new symbol has arrived.
ShardHeader = MSS.loadShard(testPath("root/A.h"));
EXPECT_NE(ShardHeader, nullptr);
- EXPECT_THAT(*ShardHeader->Symbols, Contains(Named("A_CCnew")));
+ EXPECT_THAT(*ShardHeader->Symbols, Contains(named("A_CCnew")));
auto ShardSource = MSS.loadShard(testPath("root/A.cc"));
EXPECT_NE(ShardSource, nullptr);
EXPECT_THAT(*ShardSource->Symbols,
- Contains(AllOf(Named("f_b"), Declared(), Defined())));
+ Contains(AllOf(named("f_b"), declared(), defined())));
}
TEST_F(BackgroundIndexTest, ShardStorageEmptyFile) {
ShardHeader = MSS.loadShard(testPath("root/B.h"));
EXPECT_NE(ShardHeader, nullptr);
EXPECT_THAT(*ShardHeader->Symbols,
- Contains(AllOf(Named("new_func"), Declared(), Not(Defined()))));
+ Contains(AllOf(named("new_func"), declared(), Not(defined()))));
}
TEST_F(BackgroundIndexTest, NoDotsInAbsPath) {
{
auto Shard = MSS.loadShard(testPath("A.cc"));
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("foo")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(named("foo")));
EXPECT_THAT(Shard->Sources->keys(),
UnorderedElementsAre("unittest:///A.cc", "unittest:///A.h",
"unittest:///B.h"));
- EXPECT_THAT(Shard->Sources->lookup("unittest:///A.cc"), HadErrors());
+ EXPECT_THAT(Shard->Sources->lookup("unittest:///A.cc"), hadErrors());
}
{
auto Shard = MSS.loadShard(testPath("A.h"));
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("foo")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(named("foo")));
EXPECT_THAT(Shard->Sources->keys(),
UnorderedElementsAre("unittest:///A.h"));
- EXPECT_THAT(Shard->Sources->lookup("unittest:///A.h"), HadErrors());
+ EXPECT_THAT(Shard->Sources->lookup("unittest:///A.h"), hadErrors());
}
{
auto Shard = MSS.loadShard(testPath("B.h"));
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("asdf")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(named("asdf")));
EXPECT_THAT(Shard->Sources->keys(),
UnorderedElementsAre("unittest:///B.h", "unittest:///C.h"));
- EXPECT_THAT(Shard->Sources->lookup("unittest:///B.h"), HadErrors());
+ EXPECT_THAT(Shard->Sources->lookup("unittest:///B.h"), hadErrors());
}
{
EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre());
EXPECT_THAT(Shard->Sources->keys(),
UnorderedElementsAre("unittest:///C.h"));
- EXPECT_THAT(Shard->Sources->lookup("unittest:///C.h"), HadErrors());
+ EXPECT_THAT(Shard->Sources->lookup("unittest:///C.h"), hadErrors());
}
}
using ::testing::UnorderedElementsAre;
// Helpers for matching call hierarchy data structures.
-MATCHER_P(WithName, N, "") { return arg.name == N; }
-MATCHER_P(WithSelectionRange, R, "") { return arg.selectionRange == R; }
+MATCHER_P(withName, N, "") { return arg.name == N; }
+MATCHER_P(withSelectionRange, R, "") { return arg.selectionRange == R; }
template <class ItemMatcher>
-::testing::Matcher<CallHierarchyIncomingCall> From(ItemMatcher M) {
+::testing::Matcher<CallHierarchyIncomingCall> from(ItemMatcher M) {
return Field(&CallHierarchyIncomingCall::from, M);
}
template <class... RangeMatchers>
-::testing::Matcher<CallHierarchyIncomingCall> FromRanges(RangeMatchers... M) {
+::testing::Matcher<CallHierarchyIncomingCall> fromRanges(RangeMatchers... M) {
return Field(&CallHierarchyIncomingCall::fromRanges,
UnorderedElementsAre(M...));
}
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Source.range("Callee")))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Source.range("Callee")))));
auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
ASSERT_THAT(IncomingLevel2,
- ElementsAre(AllOf(From(WithName("caller2")),
- FromRanges(Source.range("Caller1A"),
+ ElementsAre(AllOf(from(withName("caller2")),
+ fromRanges(Source.range("Caller1A"),
Source.range("Caller1B"))),
- AllOf(From(WithName("caller3")),
- FromRanges(Source.range("Caller1C")))));
+ AllOf(from(withName("caller3")),
+ fromRanges(Source.range("Caller1C")))));
auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
ASSERT_THAT(IncomingLevel3,
- ElementsAre(AllOf(From(WithName("caller3")),
- FromRanges(Source.range("Caller2")))));
+ ElementsAre(AllOf(from(withName("caller3")),
+ fromRanges(Source.range("Caller2")))));
auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
EXPECT_THAT(IncomingLevel4, IsEmpty());
auto Index = TU.index();
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Source.range("Callee")))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Source.range("Callee")))));
auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
ASSERT_THAT(IncomingLevel2,
- ElementsAre(AllOf(From(WithName("caller2")),
- FromRanges(Source.range("Caller1A"),
+ ElementsAre(AllOf(from(withName("caller2")),
+ fromRanges(Source.range("Caller1A"),
Source.range("Caller1B"))),
- AllOf(From(WithName("caller3")),
- FromRanges(Source.range("Caller1C")))));
+ AllOf(from(withName("caller3")),
+ fromRanges(Source.range("Caller1C")))));
auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
ASSERT_THAT(IncomingLevel3,
- ElementsAre(AllOf(From(WithName("caller3")),
- FromRanges(Source.range("Caller2")))));
+ ElementsAre(AllOf(from(withName("caller3")),
+ fromRanges(Source.range("Caller2")))));
auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
EXPECT_THAT(IncomingLevel4, IsEmpty());
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Source.range("Callee")))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Source.range("Callee")))));
auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
EXPECT_THAT(IncomingLevel2,
- ElementsAre(AllOf(From(WithName("caller2")),
- FromRanges(Source.range("Caller1")))));
+ ElementsAre(AllOf(from(withName("caller2")),
+ fromRanges(Source.range("Caller1")))));
}
TEST(CallHierarchy, IncomingQualified) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
- ASSERT_THAT(Items, ElementsAre(WithName("Waldo::find")));
+ ASSERT_THAT(Items, ElementsAre(withName("Waldo::find")));
auto Incoming = incomingCalls(Items[0], Index.get());
EXPECT_THAT(Incoming,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Source.range("Caller1"))),
- AllOf(From(WithName("caller2")),
- FromRanges(Source.range("Caller2")))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Source.range("Caller1"))),
+ AllOf(from(withName("caller2")),
+ fromRanges(Source.range("Caller2")))));
}
TEST(CallHierarchy, IncomingMultiFileCpp) {
auto CheckCallHierarchy = [&](ParsedAST &AST, Position Pos, PathRef TUPath) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Pos, TUPath);
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Caller1C.range()))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Caller1C.range()))));
auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
ASSERT_THAT(
IncomingLevel2,
- ElementsAre(AllOf(From(WithName("caller2")),
- FromRanges(Caller2C.range("A"), Caller2C.range("B"))),
- AllOf(From(WithName("caller3")),
- FromRanges(Caller3C.range("Caller1")))));
+ ElementsAre(AllOf(from(withName("caller2")),
+ fromRanges(Caller2C.range("A"), Caller2C.range("B"))),
+ AllOf(from(withName("caller3")),
+ fromRanges(Caller3C.range("Caller1")))));
auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
ASSERT_THAT(IncomingLevel3,
- ElementsAre(AllOf(From(WithName("caller3")),
- FromRanges(Caller3C.range("Caller2")))));
+ ElementsAre(AllOf(from(withName("caller3")),
+ fromRanges(Caller3C.range("Caller2")))));
auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
EXPECT_THAT(IncomingLevel4, IsEmpty());
auto CheckCallHierarchy = [&](ParsedAST &AST, Position Pos, PathRef TUPath) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Pos, TUPath);
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Caller1C.range()))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Caller1C.range()))));
auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
ASSERT_THAT(
IncomingLevel2,
- ElementsAre(AllOf(From(WithName("caller2")),
- FromRanges(Caller2C.range("A"), Caller2C.range("B"))),
- AllOf(From(WithName("caller3")),
- FromRanges(Caller3C.range("Caller1")))));
+ ElementsAre(AllOf(from(withName("caller2")),
+ fromRanges(Caller2C.range("A"), Caller2C.range("B"))),
+ AllOf(from(withName("caller3")),
+ fromRanges(Caller3C.range("Caller1")))));
auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
ASSERT_THAT(IncomingLevel3,
- ElementsAre(AllOf(From(WithName("caller3")),
- FromRanges(Caller3C.range("Caller2")))));
+ ElementsAre(AllOf(from(withName("caller3")),
+ fromRanges(Caller3C.range("Caller2")))));
auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
EXPECT_THAT(IncomingLevel4, IsEmpty());
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto Incoming = incomingCalls(Items[0], Index.get());
ASSERT_THAT(
Incoming,
ElementsAre(
- AllOf(From(WithName("caller1")), FromRanges(Source.range("call1"))),
- AllOf(From(WithName("caller2")), FromRanges(Source.range("call2"))),
- AllOf(From(WithName("caller3")), FromRanges(Source.range("call3")))));
+ AllOf(from(withName("caller1")), fromRanges(Source.range("call1"))),
+ AllOf(from(withName("caller2")), fromRanges(Source.range("call2"))),
+ AllOf(from(withName("caller3")), fromRanges(Source.range("call3")))));
}
} // namespace
using llvm::Succeeded;
using testing::ElementsAre;
-MATCHER_P(DiagMessage, M, "") {
+MATCHER_P(diagMessage, M, "") {
if (const auto *O = arg.getAsObject()) {
if (const auto Msg = O->getString("message"))
return *Msg == M;
Client.didOpen("foo.cpp", "void main(int, char**);");
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("'main' must return 'int' (fix available)"))));
+ diagMessage("'main' must return 'int' (fix available)"))));
Client.didChange("foo.cpp", "int x = \"42\";");
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("Cannot initialize a variable of type 'int' with "
+ diagMessage("Cannot initialize a variable of type 'int' with "
"an lvalue of type 'const char[3]'"))));
Client.didClose("foo.cpp");
)cpp");
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("'foo.h' file not found"),
- DiagMessage("Use of undeclared identifier 'VAR'"))));
+ diagMessage("'foo.h' file not found"),
+ diagMessage("Use of undeclared identifier 'VAR'"))));
// Now create the header.
FS.Files["foo.h"] = "#define VAR original";
Client.notify(
llvm::json::Object{{"textDocument", Client.documentID("foo.h")}});
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("Use of undeclared identifier 'original'"))));
+ diagMessage("Use of undeclared identifier 'original'"))));
// Now modify the header from within the "editor".
FS.Files["foo.h"] = "#define VAR changed";
Client.notify(
// Foo.cpp should be rebuilt with new diagnostics.
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("Use of undeclared identifier 'changed'"))));
+ diagMessage("Use of undeclared identifier 'changed'"))));
}
TEST_F(LSPTest, RecordsLatencies) {
Client.didOpen("foo.cpp", "int x = FOO;");
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("Use of undeclared identifier 'FOO'"))));
+ diagMessage("Use of undeclared identifier 'FOO'"))));
// bar.cpp shows the configured compile command.
Client.didOpen("bar.cpp", "int x = FOO;");
EXPECT_THAT(Client.diagnostics("bar.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("Use of undeclared identifier 'BAR'"))));
+ diagMessage("Use of undeclared identifier 'BAR'"))));
}
TEST_F(LSPTest, ModulesTest) {
auto &Client = start();
Client.didOpen("foo.cpp", "test;");
EXPECT_THAT(Client.diagnostics("foo.cpp"),
- llvm::ValueIs(testing::ElementsAre(DiagMessage(DiagMsg))));
+ llvm::ValueIs(testing::ElementsAre(diagMessage(DiagMsg))));
}
} // namespace
} // namespace clangd
using ContextKind = CodeCompletionContext::Kind;
// GMock helpers for matching completion items.
-MATCHER_P(Named, Name, "") { return arg.Name == Name; }
-MATCHER_P(MainFileRefs, Refs, "") { return arg.MainFileRefs == Refs; }
-MATCHER_P(ScopeRefs, Refs, "") { return arg.ScopeRefsInFile == Refs; }
-MATCHER_P(NameStartsWith, Prefix, "") {
+MATCHER_P(named, Name, "") { return arg.Name == Name; }
+MATCHER_P(mainFileRefs, Refs, "") { return arg.MainFileRefs == Refs; }
+MATCHER_P(scopeRefs, Refs, "") { return arg.ScopeRefsInFile == Refs; }
+MATCHER_P(nameStartsWith, Prefix, "") {
return llvm::StringRef(arg.Name).startswith(Prefix);
}
-MATCHER_P(Scope, S, "") { return arg.Scope == S; }
-MATCHER_P(Qualifier, Q, "") { return arg.RequiredQualifier == Q; }
-MATCHER_P(Labeled, Label, "") {
+MATCHER_P(scope, S, "") { return arg.Scope == S; }
+MATCHER_P(qualifier, Q, "") { return arg.RequiredQualifier == Q; }
+MATCHER_P(labeled, Label, "") {
return arg.RequiredQualifier + arg.Name + arg.Signature == Label;
}
-MATCHER_P(SigHelpLabeled, Label, "") { return arg.label == Label; }
-MATCHER_P(Kind, K, "") { return arg.Kind == K; }
-MATCHER_P(Doc, D, "") {
+MATCHER_P(sigHelpLabeled, Label, "") { return arg.label == Label; }
+MATCHER_P(kind, K, "") { return arg.Kind == K; }
+MATCHER_P(doc, D, "") {
return arg.Documentation && arg.Documentation->asPlainText() == D;
}
-MATCHER_P(ReturnType, D, "") { return arg.ReturnType == D; }
-MATCHER_P(HasInclude, IncludeHeader, "") {
+MATCHER_P(returnType, D, "") { return arg.ReturnType == D; }
+MATCHER_P(hasInclude, IncludeHeader, "") {
return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader;
}
-MATCHER_P(InsertInclude, IncludeHeader, "") {
+MATCHER_P(insertInclude, IncludeHeader, "") {
return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader &&
bool(arg.Includes[0].Insertion);
}
-MATCHER(InsertInclude, "") {
+MATCHER(insertInclude, "") {
return !arg.Includes.empty() && bool(arg.Includes[0].Insertion);
}
-MATCHER_P(SnippetSuffix, Text, "") { return arg.SnippetSuffix == Text; }
-MATCHER_P(Origin, OriginSet, "") { return arg.Origin == OriginSet; }
-MATCHER_P(Signature, S, "") { return arg.Signature == S; }
+MATCHER_P(snippetSuffix, Text, "") { return arg.SnippetSuffix == Text; }
+MATCHER_P(origin, OriginSet, "") { return arg.Origin == OriginSet; }
+MATCHER_P(signature, S, "") { return arg.Signature == S; }
-// Shorthand for Contains(Named(Name)).
-Matcher<const std::vector<CodeCompletion> &> Has(std::string Name) {
- return Contains(Named(std::move(Name)));
+// Shorthand for Contains(named(Name)).
+Matcher<const std::vector<CodeCompletion> &> has(std::string Name) {
+ return Contains(named(std::move(Name)));
}
-Matcher<const std::vector<CodeCompletion> &> Has(std::string Name,
+Matcher<const std::vector<CodeCompletion> &> has(std::string Name,
CompletionItemKind K) {
- return Contains(AllOf(Named(std::move(Name)), Kind(K)));
+ return Contains(AllOf(named(std::move(Name)), kind(K)));
}
-MATCHER(IsDocumented, "") { return arg.Documentation.hasValue(); }
-MATCHER(Deprecated, "") { return arg.Deprecated; }
+MATCHER(isDocumented, "") { return arg.Documentation.hasValue(); }
+MATCHER(deprecated, "") { return arg.Deprecated; }
std::unique_ptr<SymbolIndex> memIndex(std::vector<Symbol> Symbols) {
SymbolSlab::Builder Slab;
)cpp",
/*IndexSymbols=*/{}, Opts);
EXPECT_THAT(Results.Completions,
- ElementsAre(Named("ABG"), Named("AlphaBetaGamma")));
+ ElementsAre(named("ABG"), named("AlphaBetaGamma")));
}
TEST(DecisionForestRankingModel, ReferencesAffectRanking) {
{ns("clangA"), withReferences(NumReferences, func("clangD"))},
Opts)
.Completions,
- ElementsAre(Named("clangD"), Named("clangA")));
+ ElementsAre(named("clangD"), named("clangA")));
EXPECT_THAT(
completions("int main() { clang^ }",
{withReferences(NumReferences, ns("clangA")), func("clangD")},
Opts)
.Completions,
- ElementsAre(Named("clangA"), Named("clangD")));
+ ElementsAre(named("clangA"), named("clangD")));
}
TEST(DecisionForestRankingModel, DecisionForestScorerCallbackTest) {
/*IndexSymbols=*/{}, Opts);
EXPECT_TRUE(Results.HasMore);
- EXPECT_THAT(Results.Completions, ElementsAre(Named("AAA"), Named("BBB")));
+ EXPECT_THAT(Results.Completions, ElementsAre(named("AAA"), named("BBB")));
}
TEST(CompletionTest, Filter) {
// Only items matching the fuzzy query are returned.
EXPECT_THAT(completions(Body + "int main() { S().Foba^ }").Completions,
- AllOf(Has("FooBar"), Has("FooBaz"), Not(Has("Qux"))));
+ AllOf(has("FooBar"), has("FooBaz"), Not(has("Qux"))));
// Macros require prefix match, either from index or AST.
Symbol Sym = var("MotorCarIndex");
Sym.SymInfo.Kind = index::SymbolKind::Macro;
EXPECT_THAT(
completions(Body + "int main() { C^ }", {Sym}).Completions,
- AllOf(Has("Car"), Not(Has("MotorCar")), Not(Has("MotorCarIndex"))));
+ AllOf(has("Car"), Not(has("MotorCar")), Not(has("MotorCarIndex"))));
EXPECT_THAT(completions(Body + "int main() { M^ }", {Sym}).Completions,
- AllOf(Has("MotorCar"), Has("MotorCarIndex")));
+ AllOf(has("MotorCar"), has("MotorCarIndex")));
}
void testAfterDotCompletion(clangd::CodeCompleteOptions Opts) {
struct GlobalClass {};
struct ClassWithMembers {
- /// Doc for method.
+ /// doc for method.
int method();
int field;
int test() {
struct LocalClass {};
- /// Doc for local_var.
+ /// doc for local_var.
int local_var;
ClassWithMembers().^
// Class members. The only items that must be present in after-dot
// completion.
EXPECT_THAT(Results.Completions,
- AllOf(Has("method"), Has("field"), Not(Has("ClassWithMembers")),
- Not(Has("operator=")), Not(Has("~ClassWithMembers"))));
+ AllOf(has("method"), has("field"), Not(has("ClassWithMembers")),
+ Not(has("operator=")), Not(has("~ClassWithMembers"))));
EXPECT_IFF(Opts.IncludeIneligibleResults, Results.Completions,
- Has("private_field"));
+ has("private_field"));
// Global items.
EXPECT_THAT(
Results.Completions,
- Not(AnyOf(Has("global_var"), Has("index_var"), Has("global_func"),
- Has("global_func()"), Has("index_func"), Has("GlobalClass"),
- Has("IndexClass"), Has("MACRO"), Has("LocalClass"))));
+ Not(AnyOf(has("global_var"), has("index_var"), has("global_func"),
+ has("global_func()"), has("index_func"), has("GlobalClass"),
+ has("IndexClass"), has("MACRO"), has("LocalClass"))));
// There should be no code patterns (aka snippets) in after-dot
// completion. At least there aren't any we're aware of.
EXPECT_THAT(Results.Completions,
- Not(Contains(Kind(CompletionItemKind::Snippet))));
+ Not(Contains(kind(CompletionItemKind::Snippet))));
// Check documentation.
- EXPECT_THAT(Results.Completions, Contains(IsDocumented()));
+ EXPECT_THAT(Results.Completions, Contains(isDocumented()));
}
void testGlobalScopeCompletion(clangd::CodeCompleteOptions Opts) {
struct GlobalClass {};
struct ClassWithMembers {
- /// Doc for method.
+ /// doc for method.
int method();
};
int test() {
struct LocalClass {};
- /// Doc for local_var.
+ /// doc for local_var.
int local_var;
^
EXPECT_TRUE(Results.RanParser);
// Class members. Should never be present in global completions.
EXPECT_THAT(Results.Completions,
- Not(AnyOf(Has("method"), Has("method()"), Has("field"))));
+ Not(AnyOf(has("method"), has("method()"), has("field"))));
// Global items.
EXPECT_THAT(Results.Completions,
- AllOf(Has("global_var"), Has("index_var"), Has("global_func"),
- Has("index_func" /* our fake symbol doesn't include () */),
- Has("GlobalClass"), Has("IndexClass")));
+ AllOf(has("global_var"), has("index_var"), has("global_func"),
+ has("index_func" /* our fake symbol doesn't include () */),
+ has("GlobalClass"), has("IndexClass")));
// A macro.
- EXPECT_THAT(Results.Completions, Has("MACRO"));
+ EXPECT_THAT(Results.Completions, has("MACRO"));
// Local items. Must be present always.
EXPECT_THAT(Results.Completions,
- AllOf(Has("local_var"), Has("LocalClass"),
- Contains(Kind(CompletionItemKind::Snippet))));
+ AllOf(has("local_var"), has("LocalClass"),
+ Contains(kind(CompletionItemKind::Snippet))));
// Check documentation.
- EXPECT_THAT(Results.Completions, Contains(IsDocumented()));
+ EXPECT_THAT(Results.Completions, Contains(isDocumented()));
}
TEST(CompletionTest, CompletionOptions) {
void Foo::pub() { this->^ }
)cpp");
EXPECT_THAT(Internal.Completions,
- AllOf(Has("priv"), Has("prot"), Has("pub")));
+ AllOf(has("priv"), has("prot"), has("pub")));
auto External = completions(R"cpp(
class Foo {
}
)cpp");
EXPECT_THAT(External.Completions,
- AllOf(Has("pub"), Not(Has("prot")), Not(Has("priv"))));
+ AllOf(has("pub"), Not(has("prot")), Not(has("priv"))));
}
TEST(CompletionTest, Qualifiers) {
void test() { Bar().^ }
)cpp");
EXPECT_THAT(Results.Completions,
- Contains(AllOf(Qualifier(""), Named("bar"))));
+ Contains(AllOf(qualifier(""), named("bar"))));
// Hidden members are not shown.
EXPECT_THAT(Results.Completions,
- Not(Contains(AllOf(Qualifier("Foo::"), Named("foo")))));
+ Not(Contains(AllOf(qualifier("Foo::"), named("foo")))));
// Private members are not shown.
EXPECT_THAT(Results.Completions,
- Not(Contains(AllOf(Qualifier(""), Named("foo")))));
+ Not(Contains(AllOf(qualifier(""), named("foo")))));
}
TEST(CompletionTest, InjectedTypename) {
// These are suppressed when accessed as a member...
EXPECT_THAT(completions("struct X{}; void foo(){ X().^ }").Completions,
- Not(Has("X")));
+ Not(has("X")));
EXPECT_THAT(completions("struct X{ void foo(){ this->^ } };").Completions,
- Not(Has("X")));
+ Not(has("X")));
// ...but accessible in other, more useful cases.
EXPECT_THAT(completions("struct X{ void foo(){ ^ } };").Completions,
- Has("X"));
+ has("X"));
EXPECT_THAT(
completions("struct Y{}; struct X:Y{ void foo(){ ^ } };").Completions,
- Has("Y"));
+ has("Y"));
EXPECT_THAT(
completions(
"template<class> struct Y{}; struct X:Y<int>{ void foo(){ ^ } };")
.Completions,
- Has("Y"));
+ has("Y"));
// This case is marginal (`using X::X` is useful), we allow it for now.
EXPECT_THAT(completions("struct X{}; void foo(){ X::^ }").Completions,
- Has("X"));
+ has("X"));
}
TEST(CompletionTest, SkipInjectedWhenUnqualified) {
EXPECT_THAT(completions("struct X { void f() { X^ }};").Completions,
- ElementsAre(Named("X"), Named("~X")));
+ ElementsAre(named("X"), named("~X")));
}
TEST(CompletionTest, Snippets) {
/*IndexSymbols=*/{}, Opts);
EXPECT_THAT(
Results.Completions,
- HasSubsequence(Named("a"),
- SnippetSuffix("(${1:int i}, ${2:const float f})")));
+ HasSubsequence(named("a"),
+ snippetSuffix("(${1:int i}, ${2:const float f})")));
}
TEST(CompletionTest, NoSnippetsInUsings) {
)cpp",
/*IndexSymbols=*/{}, Opts);
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Named("func"), Labeled("func(int a, int b)"),
- SnippetSuffix(""))));
+ ElementsAre(AllOf(named("func"), labeled("func(int a, int b)"),
+ snippetSuffix(""))));
// Check index completions too.
auto Func = func("ns::func");
)cpp",
/*IndexSymbols=*/{Func}, Opts);
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Named("func"), Labeled("func(int a, int b)"),
- SnippetSuffix(""))));
+ ElementsAre(AllOf(named("func"), labeled("func(int a, int b)"),
+ snippetSuffix(""))));
// Check all-scopes completions too.
Opts.AllScopes = true;
)cpp",
/*IndexSymbols=*/{Func}, Opts);
EXPECT_THAT(Results.Completions,
- Contains(AllOf(Named("func"), Labeled("ns::func(int a, int b)"),
- SnippetSuffix(""))));
+ Contains(AllOf(named("func"), labeled("ns::func(int a, int b)"),
+ snippetSuffix(""))));
}
TEST(CompletionTest, Kinds) {
)cpp",
{func("indexFunction"), var("indexVariable"), cls("indexClass")});
EXPECT_THAT(Results.Completions,
- AllOf(Has("function", CompletionItemKind::Function),
- Has("variable", CompletionItemKind::Variable),
- Has("int", CompletionItemKind::Keyword),
- Has("Struct", CompletionItemKind::Struct),
- Has("MACRO", CompletionItemKind::Text),
- Has("indexFunction", CompletionItemKind::Function),
- Has("indexVariable", CompletionItemKind::Variable),
- Has("indexClass", CompletionItemKind::Class)));
+ AllOf(has("function", CompletionItemKind::Function),
+ has("variable", CompletionItemKind::Variable),
+ has("int", CompletionItemKind::Keyword),
+ has("Struct", CompletionItemKind::Struct),
+ has("MACRO", CompletionItemKind::Text),
+ has("indexFunction", CompletionItemKind::Function),
+ has("indexVariable", CompletionItemKind::Variable),
+ has("indexClass", CompletionItemKind::Class)));
Results = completions("nam^");
EXPECT_THAT(Results.Completions,
- Has("namespace", CompletionItemKind::Snippet));
+ has("namespace", CompletionItemKind::Snippet));
// Members of anonymous unions are of kind 'field'.
Results = completions(
)cpp");
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Named("a"), Kind(CompletionItemKind::Field))));
+ UnorderedElementsAre(AllOf(named("a"), kind(CompletionItemKind::Field))));
// Completion kinds for templates should not be unknown.
Results = completions(
EXPECT_THAT(
Results.Completions,
UnorderedElementsAre(
- AllOf(Named("complete_class"), Kind(CompletionItemKind::Class)),
- AllOf(Named("complete_function"), Kind(CompletionItemKind::Function)),
- AllOf(Named("complete_type_alias"),
- Kind(CompletionItemKind::Interface)),
- AllOf(Named("complete_variable"), Kind(CompletionItemKind::Variable)),
- AllOf(Named("complete_static_member"),
- Kind(CompletionItemKind::Property))));
+ AllOf(named("complete_class"), kind(CompletionItemKind::Class)),
+ AllOf(named("complete_function"), kind(CompletionItemKind::Function)),
+ AllOf(named("complete_type_alias"),
+ kind(CompletionItemKind::Interface)),
+ AllOf(named("complete_variable"), kind(CompletionItemKind::Variable)),
+ AllOf(named("complete_static_member"),
+ kind(CompletionItemKind::Property))));
Results = completions(
R"cpp(
)cpp");
EXPECT_THAT(
Results.Completions,
- Contains(AllOf(Named("Red"), Kind(CompletionItemKind::EnumMember))));
+ Contains(AllOf(named("Red"), kind(CompletionItemKind::EnumMember))));
}
TEST(CompletionTest, NoDuplicates) {
{cls("Adapter")});
// Make sure there are no duplicate entries of 'Adapter'.
- EXPECT_THAT(Results.Completions, ElementsAre(Named("Adapter")));
+ EXPECT_THAT(Results.Completions, ElementsAre(named("Adapter")));
}
TEST(CompletionTest, ScopedNoIndex) {
")cpp");
// Babble is a better match than BigBang. Box doesn't match at all.
EXPECT_THAT(Results.Completions,
- ElementsAre(Named("Babble"), Named("BigBang")));
+ ElementsAre(named("Babble"), named("BigBang")));
}
TEST(CompletionTest, Scoped) {
")cpp",
{var("fake::BigBang")});
EXPECT_THAT(Results.Completions,
- ElementsAre(Named("Babble"), Named("BigBang")));
+ ElementsAre(named("Babble"), named("BigBang")));
}
TEST(CompletionTest, ScopedWithFilter) {
void f() { ns::x^ }
)cpp",
{cls("ns::XYZ"), func("ns::foo")});
- EXPECT_THAT(Results.Completions, UnorderedElementsAre(Named("XYZ")));
+ EXPECT_THAT(Results.Completions, UnorderedElementsAre(named("XYZ")));
}
TEST(CompletionTest, ReferencesAffectRanking) {
EXPECT_THAT(completions("int main() { abs^ }", {func("absA"), func("absB")})
.Completions,
- HasSubsequence(Named("absA"), Named("absB")));
+ HasSubsequence(named("absA"), named("absB")));
EXPECT_THAT(completions("int main() { abs^ }",
{func("absA"), withReferences(1000, func("absB"))})
.Completions,
- HasSubsequence(Named("absB"), Named("absA")));
+ HasSubsequence(named("absB"), named("absA")));
}
TEST(CompletionTest, ContextWords) {
// Yellow would normally sort last (alphabetic).
// But the recent mention should bump it up.
ASSERT_THAT(Results.Completions,
- HasSubsequence(Named("YELLOW"), Named("BLUE")));
+ HasSubsequence(named("YELLOW"), named("BLUE")));
}
TEST(CompletionTest, GlobalQualified) {
)cpp",
{cls("XYZ")});
EXPECT_THAT(Results.Completions,
- AllOf(Has("XYZ", CompletionItemKind::Class),
- Has("f", CompletionItemKind::Function)));
+ AllOf(has("XYZ", CompletionItemKind::Class),
+ has("f", CompletionItemKind::Function)));
}
TEST(CompletionTest, FullyQualified) {
)cpp",
{cls("ns::XYZ")});
EXPECT_THAT(Results.Completions,
- AllOf(Has("XYZ", CompletionItemKind::Class),
- Has("bar", CompletionItemKind::Function)));
+ AllOf(has("XYZ", CompletionItemKind::Class),
+ has("bar", CompletionItemKind::Function)));
}
TEST(CompletionTest, SemaIndexMerge) {
// We get results from both index and sema, with no duplicates.
EXPECT_THAT(Results.Completions,
UnorderedElementsAre(
- AllOf(Named("local"), Origin(SymbolOrigin::AST)),
- AllOf(Named("Index"), Origin(SymbolOrigin::Static)),
- AllOf(Named("both"),
- Origin(SymbolOrigin::AST | SymbolOrigin::Static))));
+ AllOf(named("local"), origin(SymbolOrigin::AST)),
+ AllOf(named("Index"), origin(SymbolOrigin::Static)),
+ AllOf(named("both"),
+ origin(SymbolOrigin::AST | SymbolOrigin::Static))));
}
TEST(CompletionTest, SemaIndexMergeWithLimit) {
TU.Code = Test.code().str();
auto Results = completions(TU, Test.point(), {Sym});
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Named("X"), InsertInclude("\"bar.h\""))));
+ ElementsAre(AllOf(named("X"), insertInclude("\"bar.h\""))));
// Can be disabled via option.
CodeCompleteOptions NoInsertion;
NoInsertion.InsertIncludes = CodeCompleteOptions::NeverInsert;
Results = completions(TU, Test.point(), {Sym}, NoInsertion);
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Named("X"), Not(InsertInclude()))));
+ ElementsAre(AllOf(named("X"), Not(insertInclude()))));
// Duplicate based on inclusions in preamble.
Test = Annotations(R"cpp(
#include "sub/bar.h" // not shortest, so should only match resolved.
)cpp");
TU.Code = Test.code().str();
Results = completions(TU, Test.point(), {Sym});
- EXPECT_THAT(Results.Completions, ElementsAre(AllOf(Named("X"), Labeled("X"),
- Not(InsertInclude()))));
+ EXPECT_THAT(Results.Completions, ElementsAre(AllOf(named("X"), labeled("X"),
+ Not(insertInclude()))));
}
TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
)cpp",
{SymX, SymY});
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Named("X"), Not(InsertInclude())),
- AllOf(Named("Y"), Not(InsertInclude()))));
+ ElementsAre(AllOf(named("X"), Not(insertInclude())),
+ AllOf(named("Y"), Not(insertInclude()))));
}
TEST(CompletionTest, IndexSuppressesPreambleCompletions) {
Opts.Index = I.get();
auto WithIndex = completions(TU, Test.point(), {}, Opts);
EXPECT_THAT(WithIndex.Completions,
- UnorderedElementsAre(Named("local"), Named("index")));
+ UnorderedElementsAre(named("local"), named("index")));
auto ClassFromPreamble = completions(TU, Test.point("2"), {}, Opts);
- EXPECT_THAT(ClassFromPreamble.Completions, Contains(Named("member")));
+ EXPECT_THAT(ClassFromPreamble.Completions, Contains(named("member")));
Opts.Index = nullptr;
auto WithoutIndex = completions(TU, Test.point(), {}, Opts);
EXPECT_THAT(WithoutIndex.Completions,
- UnorderedElementsAre(Named("local"), Named("preamble")));
+ UnorderedElementsAre(named("local"), named("preamble")));
}
// This verifies that we get normal preprocessor completions in the preamble.
#endif
)cpp")
.Completions;
- EXPECT_THAT(Results, ElementsAre(Named("ifndef")));
+ EXPECT_THAT(Results, ElementsAre(named("ifndef")));
}
TEST(CompletionTest, CompletionRecoveryASTType) {
overloaded().^
})cpp")
.Completions;
- EXPECT_THAT(Results, ElementsAre(Named("member")));
+ EXPECT_THAT(Results, ElementsAre(named("member")));
}
TEST(CompletionTest, DynamicIndexIncludeInsertion) {
llvm::cantFail(runCodeComplete(Server, File, Test.point(), {}));
EXPECT_THAT(CompletionList.Completions,
- ElementsAre(AllOf(Named("Foo"), HasInclude("\"foo_header.h\""),
- InsertInclude())));
+ ElementsAre(AllOf(named("Foo"), hasInclude("\"foo_header.h\""),
+ insertInclude())));
}
TEST(CompletionTest, DynamicIndexMultiFile) {
auto Results = cantFail(runCodeComplete(Server, File, Test.point(), {}));
// "XYZ" and "foo" are not included in the file being completed but are still
// visible through the index.
- EXPECT_THAT(Results.Completions, Has("XYZ", CompletionItemKind::Class));
- EXPECT_THAT(Results.Completions, Has("foo", CompletionItemKind::Function));
- EXPECT_THAT(Results.Completions, Has("XXX", CompletionItemKind::Class));
+ EXPECT_THAT(Results.Completions, has("XYZ", CompletionItemKind::Class));
+ EXPECT_THAT(Results.Completions, has("foo", CompletionItemKind::Function));
+ EXPECT_THAT(Results.Completions, has("XXX", CompletionItemKind::Class));
EXPECT_THAT(Results.Completions,
- Contains((Named("fooooo"), Kind(CompletionItemKind::Function),
- Doc("Doooc"), ReturnType("void"))));
+ Contains((named("fooooo"), kind(CompletionItemKind::Function),
+ doc("Doooc"), returnType("void"))));
}
TEST(CompletionTest, Documentation) {
int x = ^
)cpp");
EXPECT_THAT(Results.Completions,
- Contains(AllOf(Named("foo"),
- Doc("Annotation: custom_annotation\nNon-doxygen comment."))));
+ Contains(AllOf(
+ named("foo"),
+ doc("Annotation: custom_annotation\nNon-doxygen comment."))));
EXPECT_THAT(
Results.Completions,
- Contains(AllOf(Named("bar"), Doc("Doxygen comment.\n\\param int a"))));
+ Contains(AllOf(named("bar"), doc("Doxygen comment.\n\\param int a"))));
EXPECT_THAT(Results.Completions,
- Contains(AllOf(Named("baz"), Doc("Multi-line block comment"))));
+ Contains(AllOf(named("baz"), doc("Multi-line block comment"))));
}
TEST(CompletionTest, CommentsFromSystemHeaders) {
EXPECT_THAT(
CompletionList.Completions,
- Contains(AllOf(Named("foo"), Doc("This comment should be retained!"))));
+ Contains(AllOf(named("foo"), doc("This comment should be retained!"))));
}
TEST(CompletionTest, GlobalCompletionFiltering) {
}
)cpp");
- EXPECT_THAT(Results.Completions, Contains(Labeled("clang")));
- EXPECT_THAT(Results.Completions, Not(Contains(Labeled("clang::"))));
+ EXPECT_THAT(Results.Completions, Contains(labeled("clang")));
+ EXPECT_THAT(Results.Completions, Not(Contains(labeled("clang::"))));
}
TEST(CompletionTest, BacktrackCrashes) {
int foo(ns::FooBar^
)cpp");
- EXPECT_THAT(Results.Completions, ElementsAre(Labeled("FooBarBaz")));
+ EXPECT_THAT(Results.Completions, ElementsAre(labeled("FooBarBaz")));
// Check we don't crash in that case too.
completions(R"cpp(
)cpp");
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(Named("X"), Named("Y")));
+ UnorderedElementsAre(named("X"), named("Y")));
}
TEST(CompletionTest, CompleteInMacroAndNamespaceWithStringification) {
} // namespace ns
)cpp");
- EXPECT_THAT(Results.Completions, Contains(Named("X")));
+ EXPECT_THAT(Results.Completions, Contains(named("X")));
}
TEST(CompletionTest, IgnoreCompleteInExcludedPPBranchWithRecoveryContext) {
int Z(int A, int B = 0, int C = 0, int D = 0);
)cpp";
EXPECT_THAT(completions(Context + "int y = X^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("X(int A = 0)")));
+ UnorderedElementsAre(labeled("X(int A = 0)")));
EXPECT_THAT(completions(Context + "int y = Y^", {}, Opts).Completions,
- UnorderedElementsAre(AllOf(Labeled("Y(int A, int B = 0)"),
- SnippetSuffix("(${1:int A})"))));
+ UnorderedElementsAre(AllOf(labeled("Y(int A, int B = 0)"),
+ snippetSuffix("(${1:int A})"))));
EXPECT_THAT(completions(Context + "int y = Z^", {}, Opts).Completions,
UnorderedElementsAre(
- AllOf(Labeled("Z(int A, int B = 0, int C = 0, int D = 0)"),
- SnippetSuffix("(${1:int A})"))));
+ AllOf(labeled("Z(int A, int B = 0, int C = 0, int D = 0)"),
+ snippetSuffix("(${1:int A})"))));
}
TEST(CompletionTest, NoCrashWithTemplateParamsAndPreferredTypes) {
}
)cpp")
.Completions;
- EXPECT_THAT(Completions, Contains(Named("TT")));
+ EXPECT_THAT(Completions, Contains(named("TT")));
}
TEST(CompletionTest, NestedTemplateHeuristics) {
}
)cpp")
.Completions;
- EXPECT_THAT(Completions, Contains(Named("xxx")));
+ EXPECT_THAT(Completions, Contains(named("xxx")));
}
TEST(CompletionTest, RecordCCResultCallback) {
completions("int xy1, xy2; int a = xy^", /*IndexSymbols=*/{}, Opts);
EXPECT_THAT(RecordedCompletions,
- UnorderedElementsAre(Named("xy1"), Named("xy2")));
+ UnorderedElementsAre(named("xy1"), named("xy2")));
}
TEST(CompletionTest, ASTSignals) {
Opts);
EXPECT_THAT(RecordedCompletions,
UnorderedElementsAre(
- AllOf(Named("xy1"), MainFileRefs(3u), ScopeRefs(0u)),
- AllOf(Named("xy2"), MainFileRefs(1u), ScopeRefs(0u)),
- AllOf(Named("xyindex"), MainFileRefs(10u), ScopeRefs(0u)),
- AllOf(Named("xytar"), MainFileRefs(0u), ScopeRefs(5u)),
- AllOf(/*both from sema and index*/ Named("xybar"),
- MainFileRefs(0u), ScopeRefs(3u))));
+ AllOf(named("xy1"), mainFileRefs(3u), scopeRefs(0u)),
+ AllOf(named("xy2"), mainFileRefs(1u), scopeRefs(0u)),
+ AllOf(named("xyindex"), mainFileRefs(10u), scopeRefs(0u)),
+ AllOf(named("xytar"), mainFileRefs(0u), scopeRefs(5u)),
+ AllOf(/*both from sema and index*/ named("xybar"),
+ mainFileRefs(0u), scopeRefs(3u))));
}
SignatureHelp
const ExpectedParameter &P) {
return OS << P.Text;
}
-MATCHER_P(ParamsAre, P, "") {
+MATCHER_P(paramsAre, P, "") {
if (P.size() != arg.parameters.size())
return false;
for (unsigned I = 0; I < P.size(); ++I) {
}
return true;
}
-MATCHER_P(SigDoc, Doc, "") { return arg.documentation.value == Doc; }
+MATCHER_P(sigDoc, doc, "") { return arg.documentation.value == doc; }
/// \p AnnotatedLabel is a signature label with ranges marking parameters, e.g.
/// foo([[int p1]], [[double p2]]) -> void
-Matcher<SignatureInformation> Sig(llvm::StringRef AnnotatedLabel) {
+Matcher<SignatureInformation> sig(llvm::StringRef AnnotatedLabel) {
llvm::Annotations A(AnnotatedLabel);
std::string Label = std::string(A.code());
std::vector<ExpectedParameter> Parameters;
P.Offsets.first = lspLength(llvm::StringRef(Label).substr(0, Range.Begin));
P.Offsets.second = lspLength(llvm::StringRef(Label).substr(1, Range.End));
}
- return AllOf(SigHelpLabeled(Label), ParamsAre(Parameters));
+ return AllOf(sigHelpLabeled(Label), paramsAre(Parameters));
}
TEST(SignatureHelpTest, Overloads) {
int main() { foo(^); }
)cpp");
EXPECT_THAT(Results.signatures,
- UnorderedElementsAre(Sig("foo([[float x]], [[float y]]) -> void"),
- Sig("foo([[float x]], [[int y]]) -> void"),
- Sig("foo([[int x]], [[float y]]) -> void"),
- Sig("foo([[int x]], [[int y]]) -> void")));
+ UnorderedElementsAre(sig("foo([[float x]], [[float y]]) -> void"),
+ sig("foo([[float x]], [[int y]]) -> void"),
+ sig("foo([[int x]], [[float y]]) -> void"),
+ sig("foo([[int x]], [[int y]]) -> void")));
// We always prefer the first signature.
EXPECT_EQ(0, Results.activeSignature);
EXPECT_EQ(0, Results.activeParameter);
auto CheckParenInit = [&](std::string Init) {
EXPECT_THAT(signatures(Top + Init).signatures,
- UnorderedElementsAre(Sig("S([[int]])")))
+ UnorderedElementsAre(sig("S([[int]])")))
<< Init;
};
CheckParenInit("S s(^);");
auto CheckBracedInit = [&](std::string Init) {
EXPECT_THAT(signatures(Top + Init).signatures,
- UnorderedElementsAre(Sig("S{[[int]]}")))
+ UnorderedElementsAre(sig("S{[[int]]}")))
<< Init;
};
CheckBracedInit("S s{^};");
int a, b, c, d;
};
)cpp";
- auto AggregateSig = Sig("S{[[int a]], [[int b]], [[int c]], [[int d]]}");
+ auto AggregateSig = sig("S{[[int a]], [[int b]], [[int c]], [[int d]]}");
EXPECT_THAT(signatures(Top + "S s{^}").signatures,
- UnorderedElementsAre(AggregateSig, Sig("S{}"),
- Sig("S{[[const S &]]}"),
- Sig("S{[[S &&]]}")));
+ UnorderedElementsAre(AggregateSig, sig("S{}"),
+ sig("S{[[const S &]]}"),
+ sig("S{[[S &&]]}")));
EXPECT_THAT(signatures(Top + "S s{1,^}").signatures,
ElementsAre(AggregateSig));
EXPECT_EQ(signatures(Top + "S s{1,^}").activeParameter, 1);
f(^);
}
)cpp");
- EXPECT_THAT(Results.signatures, UnorderedElementsAre(Sig("f() -> void")));
+ EXPECT_THAT(Results.signatures, UnorderedElementsAre(sig("f() -> void")));
}
TEST(SignatureHelpTest, DefaultArgs) {
)cpp");
EXPECT_THAT(Results.signatures,
UnorderedElementsAre(
- Sig("bar([[int x]], [[int y = 0]]) -> void"),
- Sig("bar([[float x = 0]], [[int y = 42]]) -> void")));
+ sig("bar([[int x]], [[int y = 0]]) -> void"),
+ sig("bar([[float x = 0]], [[int y = 42]]) -> void")));
EXPECT_EQ(0, Results.activeSignature);
EXPECT_EQ(0, Results.activeParameter);
}
int main() { baz(baz(1,2,3), ^); }
)cpp");
EXPECT_THAT(Results.signatures,
- ElementsAre(Sig("baz([[int a]], [[int b]], [[int c]]) -> int")));
+ ElementsAre(sig("baz([[int a]], [[int b]], [[int c]]) -> int")));
EXPECT_EQ(0, Results.activeSignature);
EXPECT_EQ(1, Results.activeParameter);
}
auto Results =
signatureHelp(testPath(TU.Filename), Test.point(), *EmptyPreamble,
TU.inputs(FS), MarkupKind::PlainText);
- EXPECT_THAT(Results.signatures, ElementsAre(Sig("foo([[int x]]) -> int")));
+ EXPECT_THAT(Results.signatures, ElementsAre(sig("foo([[int x]]) -> int")));
EXPECT_EQ(0, Results.activeSignature);
EXPECT_EQ(0, Results.activeParameter);
}
{func("::SomeNameInTheIndex"), func("::Foo::SomeNameInTheIndex")});
EXPECT_THAT(Completions.Completions,
- AllOf(Contains(Labeled("SomeNameOfField")),
- Contains(Labeled("SomeNameOfTypedefField")),
- Not(Contains(Labeled("SomeNameInTheIndex")))));
+ AllOf(Contains(labeled("SomeNameOfField")),
+ Contains(labeled("SomeNameOfTypedefField")),
+ Not(Contains(labeled("SomeNameInTheIndex")))));
}
TEST(CompletionTest, NoIndexCompletionsInsideDependentCode) {
{func("::SomeNameInTheIndex")});
EXPECT_THAT(Completions.Completions,
- Not(Contains(Labeled("SomeNameInTheIndex"))));
+ Not(Contains(labeled("SomeNameInTheIndex"))));
}
{
{func("::SomeNameInTheIndex")});
EXPECT_THAT(Completions.Completions,
- Not(Contains(Labeled("SomeNameInTheIndex"))));
+ Not(Contains(labeled("SomeNameInTheIndex"))));
}
{
{func("::SomeNameInTheIndex")});
EXPECT_THAT(Completions.Completions,
- Not(Contains(Labeled("SomeNameInTheIndex"))));
+ Not(Contains(labeled("SomeNameInTheIndex"))));
}
}
// Member completions are bundled.
EXPECT_THAT(completions(Context + "int y = X().^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("a(…)"), Labeled("b(float)")));
+ UnorderedElementsAre(labeled("a(…)"), labeled("b(float)")));
// Constructor completions are bundled.
EXPECT_THAT(completions(Context + "X z = X^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("X"), Labeled("X(…)")));
+ UnorderedElementsAre(labeled("X"), labeled("X(…)")));
// Non-member completions are bundled, including index+sema.
Symbol NoArgsGFunc = func("GFuncC");
EXPECT_THAT(
completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
- UnorderedElementsAre(Labeled("GFuncC(…)"), Labeled("GFuncD(int)")));
+ UnorderedElementsAre(labeled("GFuncC(…)"), labeled("GFuncD(int)")));
// Differences in header-to-insert suppress bundling.
std::string DeclFile = URI::create(testPath("foo")).toString();
NoArgsGFunc.IncludeHeaders.emplace_back("<foo>", 1);
EXPECT_THAT(
completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
- UnorderedElementsAre(AllOf(Named("GFuncC"), InsertInclude("<foo>")),
- Labeled("GFuncC(int)"), Labeled("GFuncD(int)")));
+ UnorderedElementsAre(AllOf(named("GFuncC"), insertInclude("<foo>")),
+ labeled("GFuncC(int)"), labeled("GFuncD(int)")));
// Examine a bundled completion in detail.
auto A =
// We shouldn't crash. Unfortunately, current workaround is to not produce
// comments for symbols from headers.
EXPECT_THAT(Completions.Completions,
- Contains(AllOf(Not(IsDocumented()), Named("func"))));
+ Contains(AllOf(Not(isDocumented()), named("func"))));
}
TEST(CompletionTest, NonDocComments) {
// We should not get any of those comments in completion.
EXPECT_THAT(
completions(Text).Completions,
- UnorderedElementsAre(AllOf(Not(IsDocumented()), Named("comments_foo")),
- AllOf(IsDocumented(), Named("comments_baz")),
- AllOf(IsDocumented(), Named("comments_quux")),
- AllOf(Not(IsDocumented()), Named("comments_ns")),
+ UnorderedElementsAre(AllOf(Not(isDocumented()), named("comments_foo")),
+ AllOf(isDocumented(), named("comments_baz")),
+ AllOf(isDocumented(), named("comments_quux")),
+ AllOf(Not(isDocumented()), named("comments_ns")),
// FIXME(ibiryukov): the following items should have
// empty documentation, since they are separated from
// a comment with an empty line. Unfortunately, I
// couldn't make Sema tests pass if we ignore those.
- AllOf(IsDocumented(), Named("comments_bar")),
- AllOf(IsDocumented(), Named("comments_qux"))));
+ AllOf(isDocumented(), named("comments_bar")),
+ AllOf(isDocumented(), named("comments_qux"))));
}
TEST(CompletionTest, CompleteOnInvalidLine) {
// We get results from both index and sema, with no duplicates.
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(Scope("ns::"), Scope("ns::"), Scope("ns::")));
+ UnorderedElementsAre(scope("ns::"), scope("ns::"), scope("ns::")));
}
TEST(CompletionTest, Render) {
if (auto x = ns::NotRecover^)
}
)cpp");
- EXPECT_THAT(Results.Completions, UnorderedElementsAre(Named("NotRecovered")));
+ EXPECT_THAT(Results.Completions, UnorderedElementsAre(named("NotRecovered")));
}
TEST(CompletionTest, ScopeOfClassFieldInConstructorInitializer) {
}
)cpp");
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Scope("ns::X::"), Named("x_"))));
+ UnorderedElementsAre(AllOf(scope("ns::X::"), named("x_"))));
}
// Like other class members, constructor init lists have to parse what's below,
};
}
)cpp");
- EXPECT_THAT(Results.Completions, ElementsAre(Named("xyz_")));
+ EXPECT_THAT(Results.Completions, ElementsAre(named("xyz_")));
Results = completions(
R"cpp(
};
}
)cpp");
- EXPECT_THAT(Results.Completions, ElementsAre(Named("foo")));
+ EXPECT_THAT(Results.Completions, ElementsAre(named("foo")));
}
TEST(CompletionTest, CodeCompletionContext) {
int main() { foo(^); }
)cpp");
EXPECT_THAT(Results.signatures,
- ElementsAre(Sig("foo([[int x]]) -> void"),
- Sig("foo([[int x]], [[int y = 0]]) -> void"),
- Sig("foo([[float x]], [[int y]]) -> void"),
- Sig("foo([[int x]], [[float y]]) -> void"),
- Sig("foo([[float x]], [[float y]]) -> void")));
+ ElementsAre(sig("foo([[int x]]) -> void"),
+ sig("foo([[int x]], [[int y = 0]]) -> void"),
+ sig("foo([[float x]], [[int y]]) -> void"),
+ sig("foo([[int x]], [[float y]]) -> void"),
+ sig("foo([[float x]], [[float y]]) -> void")));
// We always prefer the first signature.
EXPECT_EQ(0, Results.activeSignature);
EXPECT_EQ(0, Results.activeParameter);
)cpp";
EXPECT_THAT(signatures(Sig0).signatures,
- ElementsAre(Sig("foo([[T]], [[T]], [[T]]) -> void")));
+ ElementsAre(sig("foo([[T]], [[T]], [[T]]) -> void")));
StringRef Sig1 = R"cpp(
template <class T>
})cpp";
EXPECT_THAT(signatures(Sig1).signatures,
- ElementsAre(Sig("foo([[T]], [[T]], [[T]]) -> void")));
+ ElementsAre(sig("foo([[T]], [[T]], [[T]]) -> void")));
StringRef Sig2 = R"cpp(
template <class ...T>
)cpp";
EXPECT_THAT(signatures(Sig2).signatures,
- ElementsAre(Sig("foo([[T...]]) -> void")));
+ ElementsAre(sig("foo([[T...]]) -> void")));
// It is debatable whether we should substitute the outer template parameter
// ('T') in that case. Currently we don't substitute it in signature help, but
)cpp";
EXPECT_THAT(signatures(Sig3).signatures,
- ElementsAre(Sig("foo([[T]], [[U]]) -> void")));
+ ElementsAre(sig("foo([[T]], [[U]]) -> void")));
}
TEST(SignatureHelpTest, IndexDocumentation) {
Symbol Foo0 = sym("foo", index::SymbolKind::Function, "@F@\\0#");
- Foo0.Documentation = "Doc from the index";
+ Foo0.Documentation = "doc from the index";
Symbol Foo1 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#");
- Foo1.Documentation = "Doc from the index";
+ Foo1.Documentation = "doc from the index";
Symbol Foo2 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#I#");
StringRef Sig0 = R"cpp(
EXPECT_THAT(
signatures(Sig0, {Foo0}).signatures,
- ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Doc from the index")),
- AllOf(Sig("foo([[double]]) -> int"), SigDoc(""))));
+ ElementsAre(AllOf(sig("foo() -> int"), sigDoc("doc from the index")),
+ AllOf(sig("foo([[double]]) -> int"), sigDoc(""))));
StringRef Sig1 = R"cpp(
int foo();
// Overriden doc from sema
int foo(int);
- // Doc from sema
+ // doc from sema
int foo(int, int);
void test() {
EXPECT_THAT(
signatures(Sig1, {Foo0, Foo1, Foo2}).signatures,
ElementsAre(
- AllOf(Sig("foo() -> int"), SigDoc("Doc from the index")),
- AllOf(Sig("foo([[int]]) -> int"), SigDoc("Overriden doc from sema")),
- AllOf(Sig("foo([[int]], [[int]]) -> int"), SigDoc("Doc from sema"))));
+ AllOf(sig("foo() -> int"), sigDoc("doc from the index")),
+ AllOf(sig("foo([[int]]) -> int"), sigDoc("Overriden doc from sema")),
+ AllOf(sig("foo([[int]], [[int]]) -> int"), sigDoc("doc from sema"))));
}
TEST(SignatureHelpTest, DynamicIndexDocumentation) {
EXPECT_THAT(llvm::cantFail(runSignatureHelp(Server, File, FileContent.point(),
MarkupKind::PlainText))
.signatures,
- ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Member doc"))));
+ ElementsAre(AllOf(sig("foo() -> int"), sigDoc("Member doc"))));
}
TEST(CompletionTest, CompletionFunctionArgsDisabled) {
{}, Opts);
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("()")),
- AllOf(Named("xfoo"), SnippetSuffix("($0)"))));
+ UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix("()")),
+ AllOf(named("xfoo"), snippetSuffix("($0)"))));
}
{
auto Results = completions(
void f() { xba^ })cpp",
{}, Opts);
EXPECT_THAT(Results.Completions, UnorderedElementsAre(AllOf(
- Named("xbar"), SnippetSuffix("()"))));
+ named("xbar"), snippetSuffix("()"))));
}
{
Opts.BundleOverloads = true;
{}, Opts);
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("($0)"))));
+ UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix("($0)"))));
}
{
auto Results = completions(
{}, Opts);
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("<$1>($0)"))));
+ UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix("<$1>($0)"))));
}
{
auto Results = completions(
{}, Opts);
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Named("foo_class"), SnippetSuffix("<$0>")),
- AllOf(Named("foo_alias"), SnippetSuffix("<$0>"))));
+ UnorderedElementsAre(AllOf(named("foo_class"), snippetSuffix("<$0>")),
+ AllOf(named("foo_alias"), snippetSuffix("<$0>"))));
}
{
auto Results = completions(
FO^ )cpp",
{}, Opts);
EXPECT_THAT(Results.Completions, UnorderedElementsAre(AllOf(
- Named("FOO"), SnippetSuffix("($0)"))));
+ named("FOO"), snippetSuffix("($0)"))));
}
}
const auto Results = completions(Text);
EXPECT_THAT(
Results.Completions,
- AllOf(Contains(AllOf(Labeled("void vfunc(bool param, int p) override"),
- NameStartsWith("vfunc"))),
- Contains(AllOf(Labeled("void ttt(bool param) const override"),
- NameStartsWith("ttt"))),
- Not(Contains(Labeled("void vfunc(bool param) override")))));
+ AllOf(Contains(AllOf(labeled("void vfunc(bool param, int p) override"),
+ nameStartsWith("vfunc"))),
+ Contains(AllOf(labeled("void ttt(bool param) const override"),
+ nameStartsWith("ttt"))),
+ Not(Contains(labeled("void vfunc(bool param) override")))));
}
TEST(CompletionTest, OverridesNonIdentName) {
auto Results = completions("Fun^", {Sym}).Completions;
assert(!Results.empty());
- EXPECT_THAT(Results[0], AllOf(Named("Func"), InsertInclude("\"bar.h\"")));
+ EXPECT_THAT(Results[0], AllOf(named("Func"), insertInclude("\"bar.h\"")));
EXPECT_EQ(Results[0].Includes.size(), 2u);
}
Sym.IncludeHeaders.emplace_back("\"bar.h\"", 1000);
EXPECT_THAT(completions(TU, Test.point(), {Sym}).Completions,
- UnorderedElementsAre(AllOf(Named("Func"), HasInclude("\"foo.h\""),
- Not(InsertInclude()))));
+ UnorderedElementsAre(AllOf(named("Func"), hasInclude("\"foo.h\""),
+ Not(insertInclude()))));
}
TEST(CompletionTest, MergeMacrosFromIndexAndSema) {
Sym.Flags |= Symbol::IndexedForCodeCompletion;
EXPECT_THAT(completions("#define Clangd_Macro_Test\nClangd_Macro_T^", {Sym})
.Completions,
- UnorderedElementsAre(Named("Clangd_Macro_Test")));
+ UnorderedElementsAre(named("Clangd_Macro_Test")));
}
TEST(CompletionTest, MacroFromPreamble) {
// We should get results from the main file, including the preamble section.
// However no results from included files (the index should cover them).
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(Named("CLANGD_PREAMBLE_MAIN"),
- Named("CLANGD_MAIN"),
- Named("CLANGD_INDEX")));
+ UnorderedElementsAre(named("CLANGD_PREAMBLE_MAIN"),
+ named("CLANGD_MAIN"),
+ named("CLANGD_INDEX")));
}
TEST(CompletionTest, DeprecatedResults) {
EXPECT_THAT(
completions(Body + "int main() { TestClang^ }").Completions,
- UnorderedElementsAre(AllOf(Named("TestClangd"), Not(Deprecated())),
- AllOf(Named("TestClangc"), Deprecated())));
+ UnorderedElementsAre(AllOf(named("TestClangd"), Not(deprecated())),
+ AllOf(named("TestClangc"), deprecated())));
}
TEST(SignatureHelpTest, PartialSpec) {
template <typename T> struct Foo {};
template <typename T> struct Foo<T*> { Foo(T); };
Foo<int*> F(^);)cpp");
- EXPECT_THAT(Results.signatures, Contains(Sig("Foo([[T]])")));
+ EXPECT_THAT(Results.signatures, Contains(sig("Foo([[T]])")));
EXPECT_EQ(0, Results.activeParameter);
}
int main() { foo(1+^); }
)cpp");
EXPECT_THAT(Results.signatures,
- ElementsAre(Sig("foo([[int x]]) -> void"),
- Sig("foo([[int x]], [[int y]]) -> void")));
+ ElementsAre(sig("foo([[int x]]) -> void"),
+ sig("foo([[int x]], [[int y]]) -> void")));
EXPECT_EQ(0, Results.activeParameter);
}
{
int main() { foo(1^); }
)cpp");
EXPECT_THAT(Results.signatures,
- ElementsAre(Sig("foo([[int x]]) -> void"),
- Sig("foo([[int x]], [[int y]]) -> void")));
+ ElementsAre(sig("foo([[int x]]) -> void"),
+ sig("foo([[int x]], [[int y]]) -> void")));
EXPECT_EQ(0, Results.activeParameter);
}
{
int main() { foo(1^0); }
)cpp");
EXPECT_THAT(Results.signatures,
- ElementsAre(Sig("foo([[int x]]) -> void"),
- Sig("foo([[int x]], [[int y]]) -> void")));
+ ElementsAre(sig("foo([[int x]]) -> void"),
+ sig("foo([[int x]], [[int y]]) -> void")));
EXPECT_EQ(0, Results.activeParameter);
}
{
int main() { bar(foo(2, 3^)); }
)cpp");
EXPECT_THAT(Results.signatures,
- ElementsAre(Sig("foo([[int x]], [[int y]]) -> void")));
+ ElementsAre(sig("foo([[int x]], [[int y]]) -> void")));
EXPECT_EQ(1, Results.activeParameter);
}
}
};
)cpp");
EXPECT_THAT(Results.signatures,
- UnorderedElementsAre(Sig("A([[int]])"), Sig("A([[A &&]])"),
- Sig("A([[const A &]])")));
+ UnorderedElementsAre(sig("A([[int]])"), sig("A([[A &&]])"),
+ sig("A([[const A &]])")));
}
{
const auto Results = signatures(R"cpp(
};
)cpp");
EXPECT_THAT(Results.signatures,
- UnorderedElementsAre(Sig("A([[int]])"), Sig("A([[A &&]])"),
- Sig("A([[const A &]])")));
+ UnorderedElementsAre(sig("A([[int]])"), sig("A([[A &&]])"),
+ sig("A([[const A &]])")));
}
{
const auto Results = signatures(R"cpp(
};
)cpp");
EXPECT_THAT(Results.signatures,
- UnorderedElementsAre(Sig("A([[int]])"), Sig("A([[A &&]])"),
- Sig("A([[const A &]])")));
+ UnorderedElementsAre(sig("A([[int]])"), sig("A([[A &&]])"),
+ sig("A([[const A &]])")));
}
}
{
const auto Result = signatures(Header + "fun(^);}");
EXPECT_EQ(0, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
{
const auto Result = signatures(Header + "fun(1, ^);}");
EXPECT_EQ(1, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
{
const auto Result = signatures(Header + "fun(1, 2, ^);}");
EXPECT_EQ(1, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
}
{
const auto Result = signatures(Header + "fun(^);}");
EXPECT_EQ(0, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
{
const auto Result = signatures(Header + "fun(1, ^);}");
EXPECT_EQ(1, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
{
const auto Result = signatures(Header + "fun(1, 2, ^);}");
EXPECT_EQ(1, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
}
{
const auto Result = signatures(Header + "c.fun(^);}");
EXPECT_EQ(0, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
{
const auto Result = signatures(Header + "c.fun(1, ^);}");
EXPECT_EQ(1, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
{
const auto Result = signatures(Header + "c.fun(1, 2, ^);}");
EXPECT_EQ(1, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
}
{
const auto Result = signatures(Header + "get_fun()(^);}");
EXPECT_EQ(0, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
{
const auto Result = signatures(Header + "get_fun()(1, ^);}");
EXPECT_EQ(1, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
{
const auto Result = signatures(Header + "get_fun()(1, 2, ^);}");
EXPECT_EQ(1, Result.activeParameter);
- EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+ EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
}
}
auto Results = completions(TU, Test.point());
EXPECT_THAT(Results.Completions,
- AllOf(Has("sub/", CompletionItemKind::Folder),
- Has("bar.h\"", CompletionItemKind::File)));
+ AllOf(has("sub/", CompletionItemKind::Folder),
+ has("bar.h\"", CompletionItemKind::File)));
}
TEST(CompletionTest, NoCrashAtNonAlphaIncludeHeader) {
{cls("na::ClangdA"), cls("nx::ClangdX"), cls("Clangd3")}, Opts);
EXPECT_THAT(Results.Completions,
UnorderedElementsAre(
- AllOf(Qualifier(""), Scope("na::"), Named("ClangdA"))));
+ AllOf(qualifier(""), scope("na::"), named("ClangdA"))));
}
TEST(CompletionTest, AllScopesCompletion) {
Opts);
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier("nx::"), Named("Clangd1")),
- AllOf(Qualifier("ny::"), Named("Clangd2")),
- AllOf(Qualifier(""), Scope(""), Named("Clangd3")),
- AllOf(Qualifier("nb::"), Named("Clangd4"))));
+ UnorderedElementsAre(AllOf(qualifier("nx::"), named("Clangd1")),
+ AllOf(qualifier("ny::"), named("Clangd2")),
+ AllOf(qualifier(""), scope(""), named("Clangd3")),
+ AllOf(qualifier("nb::"), named("Clangd4"))));
}
TEST(CompletionTest, NoQualifierIfShadowed) {
// Although Clangd1 is from another namespace, Sema tells us it's in-scope and
// needs no qualifier.
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Named("Clangd1")),
- AllOf(Qualifier("nx::"), Named("Clangd2"))));
+ UnorderedElementsAre(AllOf(qualifier(""), named("Clangd1")),
+ AllOf(qualifier("nx::"), named("Clangd2"))));
}
TEST(CompletionTest, NoCompletionsForNewNames) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("value")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(ReturnType("int")));
- EXPECT_THAT(C, ElementsAre(Signature("")));
- EXPECT_THAT(C, ElementsAre(SnippetSuffix("")));
+ EXPECT_THAT(C, ElementsAre(named("value")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(returnType("int")));
+ EXPECT_THAT(C, ElementsAre(signature("")));
+ EXPECT_THAT(C, ElementsAre(snippetSuffix("")));
}
TEST(CompletionTest, ObjectiveCMethodOneArgument) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("valueForCharacter:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(ReturnType("int")));
- EXPECT_THAT(C, ElementsAre(Signature("(char)")));
- EXPECT_THAT(C, ElementsAre(SnippetSuffix("${1:(char)}")));
+ EXPECT_THAT(C, ElementsAre(named("valueForCharacter:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(returnType("int")));
+ EXPECT_THAT(C, ElementsAre(signature("(char)")));
+ EXPECT_THAT(C, ElementsAre(snippetSuffix("${1:(char)}")));
}
TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromBeginning) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("fooWithValue:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(ReturnType("id")));
- EXPECT_THAT(C, ElementsAre(Signature("(int) fooey:(unsigned int)")));
+ EXPECT_THAT(C, ElementsAre(named("fooWithValue:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(returnType("id")));
+ EXPECT_THAT(C, ElementsAre(signature("(int) fooey:(unsigned int)")));
EXPECT_THAT(
- C, ElementsAre(SnippetSuffix("${1:(int)} fooey:${2:(unsigned int)}")));
+ C, ElementsAre(snippetSuffix("${1:(int)} fooey:${2:(unsigned int)}")));
}
TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromMiddle) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("fooey:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(ReturnType("id")));
- EXPECT_THAT(C, ElementsAre(Signature("(unsigned int)")));
- EXPECT_THAT(C, ElementsAre(SnippetSuffix("${1:(unsigned int)}")));
+ EXPECT_THAT(C, ElementsAre(named("fooey:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(returnType("id")));
+ EXPECT_THAT(C, ElementsAre(signature("(unsigned int)")));
+ EXPECT_THAT(C, ElementsAre(snippetSuffix("${1:(unsigned int)}")));
}
TEST(CompletionTest, ObjectiveCSimpleMethodDeclaration) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("foo")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(Qualifier("- (void)")));
+ EXPECT_THAT(C, ElementsAre(named("foo")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(qualifier("- (void)")));
}
TEST(CompletionTest, ObjectiveCMethodDeclaration) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("valueForCharacter:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(Qualifier("- (int)")));
- EXPECT_THAT(C, ElementsAre(Signature("(char)c secondArgument:(id)object")));
+ EXPECT_THAT(C, ElementsAre(named("valueForCharacter:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(qualifier("- (int)")));
+ EXPECT_THAT(C, ElementsAre(signature("(char)c secondArgument:(id)object")));
}
TEST(CompletionTest, ObjectiveCMethodDeclarationPrefixTyped) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("valueForCharacter:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(Signature("(char)c")));
+ EXPECT_THAT(C, ElementsAre(named("valueForCharacter:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(signature("(char)c")));
}
TEST(CompletionTest, ObjectiveCMethodDeclarationFromMiddle) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("secondArgument:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(Signature("(id)object")));
+ EXPECT_THAT(C, ElementsAre(named("secondArgument:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(signature("(id)object")));
}
TEST(CompletionTest, CursorInSnippets) {
// Last placeholder in code patterns should be $0 to put the cursor there.
EXPECT_THAT(Results.Completions,
Contains(AllOf(
- Named("while"),
- SnippetSuffix(" (${1:condition}) {\n${0:statements}\n}"))));
+ named("while"),
+ snippetSuffix(" (${1:condition}) {\n${0:statements}\n}"))));
// However, snippets for functions must *not* end with $0.
EXPECT_THAT(Results.Completions,
- Contains(AllOf(Named("while_foo"),
- SnippetSuffix("(${1:int a}, ${2:int b})"))));
+ Contains(AllOf(named("while_foo"),
+ snippetSuffix("(${1:int a}, ${2:int b})"))));
}
TEST(CompletionTest, WorksWithNullType) {
}
}
)cpp");
- EXPECT_THAT(R.Completions, ElementsAre(Named("loopVar")));
+ EXPECT_THAT(R.Completions, ElementsAre(named("loopVar")));
}
TEST(CompletionTest, UsingDecl) {
Opts.AllScopes = true;
auto R = completions(Source, {}, Opts);
EXPECT_THAT(R.Completions,
- ElementsAre(AllOf(Scope("std::"), Named("foo"),
- Kind(CompletionItemKind::Reference))));
+ ElementsAre(AllOf(scope("std::"), named("foo"),
+ kind(CompletionItemKind::Reference))));
}
TEST(CompletionTest, ScopeIsUnresolved) {
)cpp",
{cls("a::b::XYZ")}, Opts);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Named("XYZ"))));
+ UnorderedElementsAre(AllOf(qualifier(""), named("XYZ"))));
}
TEST(CompletionTest, NestedScopeIsUnresolved) {
)cpp",
{cls("a::b::c::XYZ")}, Opts);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Named("XYZ"))));
+ UnorderedElementsAre(AllOf(qualifier(""), named("XYZ"))));
}
// Clang parser gets confused here and doesn't report the ns:: prefix.
)cpp",
{cls("foo::ns::ABCDE")}, Opts);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Named("ABCDE"))));
+ UnorderedElementsAre(AllOf(qualifier(""), named("ABCDE"))));
}
TEST(CompletionTest, DerivedMethodsAreAlwaysVisible) {
)cpp")
.Completions;
EXPECT_THAT(Completions,
- ElementsAre(AllOf(ReturnType("int"), Named("size"))));
+ ElementsAre(AllOf(returnType("int"), named("size"))));
}
TEST(CompletionTest, NoCrashWithIncompleteLambda) {
// The completion of x itself can cause a problem: in the code completion
// callback, its type is not known, which affects the linkage calculation.
// A bad linkage value gets cached, and subsequently updated.
- EXPECT_THAT(Completions, Contains(Named("x")));
+ EXPECT_THAT(Completions, Contains(named("x")));
auto Signatures = signatures("auto x() { x(^").signatures;
- EXPECT_THAT(Signatures, Contains(Sig("x() -> auto")));
+ EXPECT_THAT(Signatures, Contains(sig("x() -> auto")));
}
TEST(CompletionTest, DelayedTemplateParsing) {
TU.ExtraArgs.push_back("-fdelayed-template-parsing");
EXPECT_THAT(completions(TU, Test.point()).Completions,
- Contains(Named("xxx")));
+ Contains(named("xxx")));
}
TEST(CompletionTest, CompletionRange) {
)cpp");
EXPECT_FALSE(Results.RanParser);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(Named("void"), Named("func"), Named("int"),
- Named("xyz"), Named("abc")));
+ UnorderedElementsAre(named("void"), named("func"), named("int"),
+ named("xyz"), named("abc")));
}
TEST(NoCompileCompletionTest, WithFilter) {
}
)cpp");
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(Named("sym1"), Named("sym2")));
+ UnorderedElementsAre(named("sym1"), named("sym2")));
}
TEST(NoCompileCompletionTest, WithIndex) {
)cpp",
Syms);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Scope("")),
- AllOf(Qualifier(""), Scope("a::")),
- AllOf(Qualifier(""), Scope("ns::b::"))));
+ UnorderedElementsAre(AllOf(qualifier(""), scope("")),
+ AllOf(qualifier(""), scope("a::")),
+ AllOf(qualifier(""), scope("ns::b::"))));
CodeCompleteOptions Opts;
Opts.AllScopes = true;
Results = completionsNoCompile(
)cpp",
Syms, Opts);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Scope("")),
- AllOf(Qualifier(""), Scope("a::")),
- AllOf(Qualifier(""), Scope("ns::b::")),
- AllOf(Qualifier("c::"), Scope("c::")),
- AllOf(Qualifier("d::"), Scope("ns::d::"))));
+ UnorderedElementsAre(AllOf(qualifier(""), scope("")),
+ AllOf(qualifier(""), scope("a::")),
+ AllOf(qualifier(""), scope("ns::b::")),
+ AllOf(qualifier("c::"), scope("c::")),
+ AllOf(qualifier("d::"), scope("ns::d::"))));
Results = completionsNoCompile(
R"cpp(
// Qualified completion.
)cpp",
Syms, Opts);
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Qualifier(""), Scope("ns::b::"))));
+ ElementsAre(AllOf(qualifier(""), scope("ns::b::"))));
Results = completionsNoCompile(
R"cpp(
// Absolutely qualified completion.
)cpp",
Syms, Opts);
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Qualifier(""), Scope("a::"))));
+ ElementsAre(AllOf(qualifier(""), scope("a::"))));
}
TEST(AllowImplicitCompletion, All) {
)cpp";
EXPECT_THAT(completions(Context + "int y = fo^", {}, Opts).Completions,
UnorderedElementsAre(
- AllOf(Labeled("foo(int A)"), SnippetSuffix("(${1:int A})"))));
+ AllOf(labeled("foo(int A)"), snippetSuffix("(${1:int A})"))));
EXPECT_THAT(
completions(Context + "int y = fo^(42)", {}, Opts).Completions,
- UnorderedElementsAre(AllOf(Labeled("foo(int A)"), SnippetSuffix(""))));
+ UnorderedElementsAre(AllOf(labeled("foo(int A)"), snippetSuffix(""))));
// FIXME(kirillbobyrev): No snippet should be produced here.
EXPECT_THAT(completions(Context + "int y = fo^o(42)", {}, Opts).Completions,
UnorderedElementsAre(
- AllOf(Labeled("foo(int A)"), SnippetSuffix("(${1:int A})"))));
+ AllOf(labeled("foo(int A)"), snippetSuffix("(${1:int A})"))));
EXPECT_THAT(
completions(Context + "int y = ba^", {}, Opts).Completions,
- UnorderedElementsAre(AllOf(Labeled("bar()"), SnippetSuffix("()"))));
+ UnorderedElementsAre(AllOf(labeled("bar()"), snippetSuffix("()"))));
EXPECT_THAT(completions(Context + "int y = ba^()", {}, Opts).Completions,
- UnorderedElementsAre(AllOf(Labeled("bar()"), SnippetSuffix(""))));
+ UnorderedElementsAre(AllOf(labeled("bar()"), snippetSuffix(""))));
EXPECT_THAT(
completions(Context + "Object o = Obj^", {}, Opts).Completions,
- Contains(AllOf(Labeled("Object(int B)"), SnippetSuffix("(${1:int B})"),
- Kind(CompletionItemKind::Constructor))));
+ Contains(AllOf(labeled("Object(int B)"), snippetSuffix("(${1:int B})"),
+ kind(CompletionItemKind::Constructor))));
EXPECT_THAT(completions(Context + "Object o = Obj^()", {}, Opts).Completions,
- Contains(AllOf(Labeled("Object(int B)"), SnippetSuffix(""),
- Kind(CompletionItemKind::Constructor))));
+ Contains(AllOf(labeled("Object(int B)"), snippetSuffix(""),
+ kind(CompletionItemKind::Constructor))));
EXPECT_THAT(
completions(Context + "Container c = Cont^", {}, Opts).Completions,
- Contains(AllOf(Labeled("Container<typename T>(int Size)"),
- SnippetSuffix("<${1:typename T}>(${2:int Size})"),
- Kind(CompletionItemKind::Constructor))));
+ Contains(AllOf(labeled("Container<typename T>(int Size)"),
+ snippetSuffix("<${1:typename T}>(${2:int Size})"),
+ kind(CompletionItemKind::Constructor))));
EXPECT_THAT(
completions(Context + "Container c = Cont^()", {}, Opts).Completions,
- Contains(AllOf(Labeled("Container<typename T>(int Size)"),
- SnippetSuffix("<${1:typename T}>"),
- Kind(CompletionItemKind::Constructor))));
+ Contains(AllOf(labeled("Container<typename T>(int Size)"),
+ snippetSuffix("<${1:typename T}>"),
+ kind(CompletionItemKind::Constructor))));
EXPECT_THAT(
completions(Context + "Container c = Cont^<int>()", {}, Opts).Completions,
- Contains(AllOf(Labeled("Container<typename T>(int Size)"),
- SnippetSuffix(""),
- Kind(CompletionItemKind::Constructor))));
+ Contains(AllOf(labeled("Container<typename T>(int Size)"),
+ snippetSuffix(""),
+ kind(CompletionItemKind::Constructor))));
EXPECT_THAT(completions(Context + "MAC^(2)", {}, Opts).Completions,
- Contains(AllOf(Labeled("MACRO(x)"), SnippetSuffix(""),
- Kind(CompletionItemKind::Text))));
+ Contains(AllOf(labeled("MACRO(x)"), snippetSuffix(""),
+ kind(CompletionItemKind::Text))));
}
TEST(CompletionTest, NoCrashDueToMacroOrdering) {
#define ECHO2(X) ECHO(X)
int finish_preamble = EC^HO(2);)cpp")
.Completions,
- UnorderedElementsAre(Labeled("ECHO(X)"), Labeled("ECHO2(X)")));
+ UnorderedElementsAre(labeled("ECHO(X)"), labeled("ECHO2(X)")));
}
TEST(CompletionTest, ObjCCategoryDecls) {
TU.Code = Test.code().str();
auto Results = completions(TU, Test.point());
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(Labeled("FooExt1"), Labeled("FooExt2")));
+ UnorderedElementsAre(labeled("FooExt1"), labeled("FooExt2")));
}
{
Annotations Test(R"objc(
)objc");
TU.Code = Test.code().str();
auto Results = completions(TU, Test.point());
- EXPECT_THAT(Results.Completions, UnorderedElementsAre(Labeled("BarExt")));
+ EXPECT_THAT(Results.Completions, UnorderedElementsAre(labeled("BarExt")));
}
}
)cpp";
EXPECT_THAT(completions(Code + "fun(/*^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("foo=")));
+ UnorderedElementsAre(labeled("foo=")));
EXPECT_THAT(completions(Code + "fun(1, /*^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("bar=")));
+ UnorderedElementsAre(labeled("bar=")));
EXPECT_THAT(completions(Code + "/*^", {}, Opts).Completions, IsEmpty());
// Test de-duplication.
EXPECT_THAT(
completions(Code + "overloaded(/*^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("param_int="), Labeled("param_char=")));
+ UnorderedElementsAre(labeled("param_int="), labeled("param_char=")));
// Comment already has some text in it.
EXPECT_THAT(completions(Code + "fun(/* ^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("foo=")));
+ UnorderedElementsAre(labeled("foo=")));
EXPECT_THAT(completions(Code + "fun(/* f^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("foo=")));
+ UnorderedElementsAre(labeled("foo=")));
EXPECT_THAT(completions(Code + "fun(/* x^", {}, Opts).Completions, IsEmpty());
EXPECT_THAT(completions(Code + "fun(/* f ^", {}, Opts).Completions,
IsEmpty());
auto First = signatures(Top + "bool x = foo<^");
EXPECT_THAT(
First.signatures,
- UnorderedElementsAre(Sig("foo<[[typename T]], [[int]]>() -> bool"),
- Sig("foo<[[int I]], [[int]]>() -> bool")));
+ UnorderedElementsAre(sig("foo<[[typename T]], [[int]]>() -> bool"),
+ sig("foo<[[int I]], [[int]]>() -> bool")));
EXPECT_EQ(First.activeParameter, 0);
auto Second = signatures(Top + "bool x = foo<1, ^");
EXPECT_THAT(Second.signatures,
- ElementsAre(Sig("foo<[[int I]], [[int]]>() -> bool")));
+ ElementsAre(sig("foo<[[int I]], [[int]]>() -> bool")));
EXPECT_EQ(Second.activeParameter, 1);
}
// Only run the PATH/symlink resolving test on unix, we need to fiddle
// with permissions and environment variables...
#ifdef LLVM_ON_UNIX
-MATCHER(Ok, "") {
+MATCHER(ok, "") {
if (arg) {
*result_listener << arg.message();
return false;
// bar
llvm::SmallString<256> TempDir;
ASSERT_THAT(llvm::sys::fs::createUniqueDirectory("ClangPathResolve", TempDir),
- Ok());
+ ok());
// /var/tmp is a symlink on Mac. Resolve it so we're asserting the right path.
- ASSERT_THAT(llvm::sys::fs::real_path(TempDir.str(), TempDir), Ok());
+ ASSERT_THAT(llvm::sys::fs::real_path(TempDir.str(), TempDir), ok());
auto CleanDir = llvm::make_scope_exit(
[&] { llvm::sys::fs::remove_directories(TempDir); });
- ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/bin"), Ok());
- ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/lib"), Ok());
+ ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/bin"), ok());
+ ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/lib"), ok());
int FD;
- ASSERT_THAT(llvm::sys::fs::openFileForWrite(TempDir + "/lib/bar", FD), Ok());
- ASSERT_THAT(llvm::sys::Process::SafelyCloseFileDescriptor(FD), Ok());
+ ASSERT_THAT(llvm::sys::fs::openFileForWrite(TempDir + "/lib/bar", FD), ok());
+ ASSERT_THAT(llvm::sys::Process::SafelyCloseFileDescriptor(FD), ok());
::chmod((TempDir + "/lib/bar").str().c_str(), 0755); // executable
ASSERT_THAT(
llvm::sys::fs::create_link(TempDir + "/lib/bar", TempDir + "/bin/foo"),
- Ok());
+ ok());
// Test the case where the driver is an absolute path to a symlink.
auto Mangler = CommandMangler::forTests();
Config::CDBSearchSpec::Ancestors)
<< "default value";
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage(
+ ElementsAre(diagMessage(
"CompilationDatabase must be an absolute path, because this "
"fragment is not associated with any directory.")));
<< "by default";
EXPECT_THAT(
Diags.Diagnostics,
- ElementsAre(DiagMessage(
+ ElementsAre(diagMessage(
"Invalid Background value 'Foo'. Valid values are Build, Skip.")));
}
EXPECT_THAT(
Diags.Diagnostics,
ElementsAre(
- DiagMessage(
+ diagMessage(
"clang-tidy check 'bugprone-use-after-move' was not found"),
- DiagMessage("clang-tidy check 'llvm-include-order' was not found")));
+ diagMessage("clang-tidy check 'llvm-include-order' was not found")));
#endif
}
EXPECT_THAT(
Diags.Diagnostics,
ElementsAre(
- AllOf(DiagMessage("clang-tidy check 'unknown-check' was not found"),
- DiagKind(llvm::SourceMgr::DK_Warning)),
+ AllOf(diagMessage("clang-tidy check 'unknown-check' was not found"),
+ diagKind(llvm::SourceMgr::DK_Warning)),
AllOf(
- DiagMessage("clang-tidy check 'llvm-includeorder' was not found"),
- DiagKind(llvm::SourceMgr::DK_Warning))));
+ diagMessage("clang-tidy check 'llvm-includeorder' was not found"),
+ diagKind(llvm::SourceMgr::DK_Warning))));
}
TEST_F(ConfigCompileTests, ExternalServerNeedsTrusted) {
compileAndApply();
EXPECT_THAT(
Diags.Diagnostics,
- ElementsAre(DiagMessage(
+ ElementsAre(diagMessage(
"Remote index may not be specified by untrusted configuration. "
"Copy this into user config to use it.")));
EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
EXPECT_THAT(
Diags.Diagnostics,
Contains(
- AllOf(DiagMessage("Exactly one of File, Server or None must be set."),
- DiagKind(llvm::SourceMgr::DK_Error))));
+ AllOf(diagMessage("Exactly one of File, Server or None must be set."),
+ diagKind(llvm::SourceMgr::DK_Error))));
#else
ASSERT_TRUE(Conf.Index.External.hasValue());
EXPECT_EQ(Conf.Index.External->Kind, Config::ExternalIndexSpec::File);
EXPECT_THAT(
Diags.Diagnostics,
Contains(
- AllOf(DiagMessage("Exactly one of File, Server or None must be set."),
- DiagKind(llvm::SourceMgr::DK_Error))));
+ AllOf(diagMessage("Exactly one of File, Server or None must be set."),
+ diagKind(llvm::SourceMgr::DK_Error))));
}
TEST_F(ConfigCompileTests, ExternalBlockDisablesBackgroundIndex) {
ASSERT_THAT(
Diags.Diagnostics,
ElementsAre(
- AllOf(DiagMessage("MountPoint must be an absolute path, because this "
+ AllOf(diagMessage("MountPoint must be an absolute path, because this "
"fragment is not associated with any directory."),
- DiagKind(llvm::SourceMgr::DK_Error))));
+ diagKind(llvm::SourceMgr::DK_Error))));
EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
auto FooPath = testPath("foo/", llvm::sys::path::Style::posix);
auto Combined = Provider::combine({&Foo, &Bar});
Config Cfg = Combined->getConfig(Params(), Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("foo"), DiagMessage("bar")));
+ ElementsAre(diagMessage("foo"), diagMessage("bar")));
EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo1", "bar1"));
Diags.Diagnostics.clear();
Cfg = Combined->getConfig(Params(), Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("foo"), DiagMessage("bar")));
+ ElementsAre(diagMessage("foo"), diagMessage("bar")));
EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo2", "bar2"));
}
auto P = Provider::fromYAMLFile(testPath("foo.yaml"), /*Directory=*/"", FS);
auto Cfg = P->getConfig(Params(), Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("Unknown CompileFlags key 'Unknown'")));
+ ElementsAre(diagMessage("Unknown CompileFlags key 'Unknown'")));
EXPECT_THAT(Diags.Files, ElementsAre(testPath("foo.yaml")));
EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
Diags.clear();
Cfg = P->getConfig(Params(), Diags.callback());
EXPECT_THAT(
Diags.Diagnostics,
- ElementsAre(DiagMessage(
+ ElementsAre(diagMessage(
"Unknown CompileFlags key 'Removr'; did you mean 'Remove'?")));
EXPECT_THAT(Diags.Files, ElementsAre(testPath("foo.yaml")));
EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
Cfg = P->getConfig(ABCParams, Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("Unknown CompileFlags key 'Unknown'")));
+ ElementsAre(diagMessage("Unknown CompileFlags key 'Unknown'")));
// FIXME: fails on windows: paths have mixed slashes like C:\a/b\c.yaml
EXPECT_THAT(Diags.Files,
ElementsAre(testPath("a/foo.yaml"), testPath("a/b/c/foo.yaml")));
FS.Files["foo.yaml"] = AddFooWithErr;
auto Cfg = P->getConfig(StaleOK, Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("Unknown CompileFlags key 'Unknown'")));
+ ElementsAre(diagMessage("Unknown CompileFlags key 'Unknown'")));
EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
Diags.clear();
}
};
-MATCHER_P(DiagMessage, M, "") { return arg.Message == M; }
-MATCHER_P(DiagKind, K, "") { return arg.Kind == K; }
-MATCHER_P(DiagPos, P, "") { return arg.Pos == P; }
-MATCHER_P(DiagRange, R, "") { return arg.Rng == R; }
+MATCHER_P(diagMessage, M, "") { return arg.Message == M; }
+MATCHER_P(diagKind, K, "") { return arg.Kind == K; }
+MATCHER_P(diagPos, P, "") { return arg.Pos == P; }
+MATCHER_P(diagRange, R, "") { return arg.Rng == R; }
inline Position toPosition(llvm::SMLoc L, const llvm::SourceMgr &SM) {
auto LineCol = SM.getLineAndColumn(L);
namespace clang {
namespace clangd {
namespace config {
+
+// PrintTo is a magic identifier of GTest
+// NOLINTNEXTLINE (readability-identifier-naming)
template <typename T> void PrintTo(const Located<T> &V, std::ostream *OS) {
*OS << ::testing::PrintToString(*V);
}
using ::testing::ElementsAre;
using ::testing::IsEmpty;
-MATCHER_P(Val, Value, "") {
+MATCHER_P(val, Value, "") {
if (*arg == Value)
return true;
*result_listener << "value is " << *arg;
EXPECT_THAT(Diags.Files, ElementsAre("config.yaml"));
ASSERT_EQ(Results.size(), 4u);
EXPECT_FALSE(Results[0].If.HasUnrecognizedCondition);
- EXPECT_THAT(Results[0].If.PathMatch, ElementsAre(Val("abc")));
- EXPECT_THAT(Results[0].CompileFlags.Add, ElementsAre(Val("foo"), Val("bar")));
+ EXPECT_THAT(Results[0].If.PathMatch, ElementsAre(val("abc")));
+ EXPECT_THAT(Results[0].CompileFlags.Add, ElementsAre(val("foo"), val("bar")));
- EXPECT_THAT(Results[1].CompileFlags.Add, ElementsAre(Val("b\naz\n")));
+ EXPECT_THAT(Results[1].CompileFlags.Add, ElementsAre(val("b\naz\n")));
ASSERT_TRUE(Results[2].Index.Background);
EXPECT_EQ("Skip", *Results[2].Index.Background.getValue());
ASSERT_THAT(
Diags.Diagnostics,
- ElementsAre(AllOf(DiagMessage("Unknown If key 'UnknownCondition'"),
- DiagKind(llvm::SourceMgr::DK_Warning),
- DiagPos(YAML.range("unknown").start),
- DiagRange(YAML.range("unknown"))),
- AllOf(DiagMessage("Unexpected token. Expected Key, Flow "
+ ElementsAre(AllOf(diagMessage("Unknown If key 'UnknownCondition'"),
+ diagKind(llvm::SourceMgr::DK_Warning),
+ diagPos(YAML.range("unknown").start),
+ diagRange(YAML.range("unknown"))),
+ AllOf(diagMessage("Unexpected token. Expected Key, Flow "
"Entry, or Flow Mapping End."),
- DiagKind(llvm::SourceMgr::DK_Error),
- DiagPos(YAML.point("unexpected")),
- DiagRange(llvm::None))));
+ diagKind(llvm::SourceMgr::DK_Error),
+ diagPos(YAML.point("unexpected")),
+ diagRange(llvm::None))));
ASSERT_EQ(Results.size(), 1u); // invalid fragment discarded.
- EXPECT_THAT(Results.front().CompileFlags.Add, ElementsAre(Val("first")));
+ EXPECT_THAT(Results.front().CompileFlags.Add, ElementsAre(val("first")));
EXPECT_TRUE(Results.front().If.HasUnrecognizedCondition);
}
)yaml";
auto Results = Fragment::parseYAML(YAML, "config.yaml", Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("If should be a dictionary"),
- DiagMessage("Config should be a dictionary")));
+ ElementsAre(diagMessage("If should be a dictionary"),
+ diagMessage("Config should be a dictionary")));
ASSERT_THAT(Results, IsEmpty());
}
Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
ASSERT_EQ(Results.size(), 1u);
ASSERT_TRUE(Results[0].Index.External);
- EXPECT_THAT(*Results[0].Index.External.getValue()->File, Val("foo"));
- EXPECT_THAT(*Results[0].Index.External.getValue()->MountPoint, Val("baz"));
+ EXPECT_THAT(*Results[0].Index.External.getValue()->File, val("foo"));
+ EXPECT_THAT(*Results[0].Index.External.getValue()->MountPoint, val("baz"));
ASSERT_THAT(Diags.Diagnostics, IsEmpty());
- EXPECT_THAT(*Results[0].Index.External.getValue()->Server, Val("bar"));
+ EXPECT_THAT(*Results[0].Index.External.getValue()->Server, val("bar"));
}
TEST(ParseYAML, AllScopes) {
Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
ASSERT_THAT(Diags.Diagnostics, IsEmpty());
ASSERT_EQ(Results.size(), 1u);
- EXPECT_THAT(Results[0].Completion.AllScopes, llvm::ValueIs(Val(true)));
+ EXPECT_THAT(Results[0].Completion.AllScopes, llvm::ValueIs(val(true)));
}
TEST(ParseYAML, AllScopesWarn) {
auto Results =
Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(AllOf(DiagMessage("AllScopes should be a boolean"),
- DiagKind(llvm::SourceMgr::DK_Warning),
- DiagPos(YAML.range("diagrange").start),
- DiagRange(YAML.range("diagrange")))));
+ ElementsAre(AllOf(diagMessage("AllScopes should be a boolean"),
+ diagKind(llvm::SourceMgr::DK_Warning),
+ diagPos(YAML.range("diagrange").start),
+ diagRange(YAML.range("diagrange")))));
ASSERT_EQ(Results.size(), 1u);
EXPECT_THAT(Results[0].Completion.AllScopes, testing::Eq(llvm::None));
}
Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
ASSERT_THAT(Diags.Diagnostics, IsEmpty());
ASSERT_EQ(Results.size(), 1u);
- EXPECT_THAT(Results[0].Hover.ShowAKA, llvm::ValueIs(Val(true)));
+ EXPECT_THAT(Results[0].Hover.ShowAKA, llvm::ValueIs(val(true)));
}
TEST(ParseYAML, InlayHints) {
Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
ASSERT_THAT(Diags.Diagnostics, IsEmpty());
ASSERT_EQ(Results.size(), 1u);
- EXPECT_THAT(Results[0].InlayHints.Enabled, llvm::ValueIs(Val(false)));
- EXPECT_THAT(Results[0].InlayHints.ParameterNames, llvm::ValueIs(Val(true)));
+ EXPECT_THAT(Results[0].InlayHints.Enabled, llvm::ValueIs(val(false)));
+ EXPECT_THAT(Results[0].InlayHints.ParameterNames, llvm::ValueIs(val(true)));
EXPECT_EQ(Results[0].InlayHints.DeducedTypes, llvm::None);
}
using ::testing::UnorderedElementsAre;
using testing::UnorderedElementsAreArray;
-::testing::Matcher<const Diag &> WithFix(::testing::Matcher<Fix> FixMatcher) {
+::testing::Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher) {
return Field(&Diag::Fixes, ElementsAre(FixMatcher));
}
-::testing::Matcher<const Diag &> WithFix(::testing::Matcher<Fix> FixMatcher1,
+::testing::Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher1,
::testing::Matcher<Fix> FixMatcher2) {
return Field(&Diag::Fixes, UnorderedElementsAre(FixMatcher1, FixMatcher2));
}
::testing::Matcher<const Diag &>
-WithNote(::testing::Matcher<Note> NoteMatcher) {
+withNote(::testing::Matcher<Note> NoteMatcher) {
return Field(&Diag::Notes, ElementsAre(NoteMatcher));
}
::testing::Matcher<const Diag &>
-WithNote(::testing::Matcher<Note> NoteMatcher1,
+withNote(::testing::Matcher<Note> NoteMatcher1,
::testing::Matcher<Note> NoteMatcher2) {
return Field(&Diag::Notes, UnorderedElementsAre(NoteMatcher1, NoteMatcher2));
}
::testing::Matcher<const Diag &>
-WithTag(::testing::Matcher<DiagnosticTag> TagMatcher) {
+withTag(::testing::Matcher<DiagnosticTag> TagMatcher) {
return Field(&Diag::Tags, Contains(TagMatcher));
}
-MATCHER_P(HasRange, Range, "") { return arg.Range == Range; }
+MATCHER_P(hasRange, Range, "") { return arg.Range == Range; }
MATCHER_P2(Diag, Range, Message,
"Diag at " + llvm::to_string(Range) + " = [" + Message + "]") {
arg.Edits[0].range == Range && arg.Edits[0].newText == Replacement;
}
-MATCHER_P(FixMessage, Message, "") { return arg.Message == Message; }
+MATCHER_P(fixMessage, Message, "") { return arg.Message == Message; }
-MATCHER_P(EqualToLSPDiag, LSPDiag,
+MATCHER_P(equalToLSPDiag, LSPDiag,
"LSP diagnostic " + llvm::to_string(LSPDiag)) {
if (toJSON(arg) != toJSON(LSPDiag)) {
*result_listener << llvm::formatv("expected:\n{0:2}\ngot\n{1:2}",
return true;
}
-MATCHER_P(DiagSource, S, "") { return arg.Source == S; }
-MATCHER_P(DiagName, N, "") { return arg.Name == N; }
-MATCHER_P(DiagSeverity, S, "") { return arg.Severity == S; }
+MATCHER_P(diagSource, S, "") { return arg.Source == S; }
+MATCHER_P(diagName, N, "") { return arg.Name == N; }
+MATCHER_P(diagSeverity, S, "") { return arg.Severity == S; }
-MATCHER_P(EqualToFix, Fix, "LSP fix " + llvm::to_string(Fix)) {
+MATCHER_P(equalToFix, Fix, "LSP fix " + llvm::to_string(Fix)) {
if (arg.Message != Fix.Message)
return false;
if (arg.Edits.size() != Fix.Edits.size())
}
// Helper function to make tests shorter.
-Position pos(int line, int character) {
+Position pos(int Line, int Character) {
Position Res;
- Res.line = line;
- Res.character = character;
+ Res.line = Line;
+ Res.character = Character;
return Res;
}
AllOf(Diag(Test.range("range"),
"invalid range expression of type 'struct Container *'; "
"did you mean to dereference it with '*'?"),
- WithFix(Fix(Test.range("insertstar"), "*", "insert '*'"))),
+ withFix(Fix(Test.range("insertstar"), "*", "insert '*'"))),
// This range spans lines.
AllOf(Diag(Test.range("typo"),
"use of undeclared identifier 'goo'; did you mean 'foo'?"),
- DiagSource(Diag::Clang), DiagName("undeclared_var_use_suggest"),
- WithFix(
+ diagSource(Diag::Clang), diagName("undeclared_var_use_suggest"),
+ withFix(
Fix(Test.range("typo"), "foo", "change 'go\\…' to 'foo'")),
// This is a pretty normal range.
- WithNote(Diag(Test.range("decl"), "'foo' declared here"))),
+ withNote(Diag(Test.range("decl"), "'foo' declared here"))),
// This range is zero-width and insertion. Therefore make sure we are
// not expanding it into other tokens. Since we are not going to
// replace those.
AllOf(Diag(Test.range("semicolon"), "expected ';' after expression"),
- WithFix(Fix(Test.range("semicolon"), ";", "insert ';'"))),
+ withFix(Fix(Test.range("semicolon"), ";", "insert ';'"))),
// This range isn't provided by clang, we expand to the token.
Diag(Test.range("unk"), "use of undeclared identifier 'unknown'"),
Diag(Test.range("type"),
"no member named 'test' in namespace 'test'"),
AllOf(Diag(Test.range("macro"),
"use of undeclared identifier 'fod'; did you mean 'foo'?"),
- WithFix(Fix(Test.range("macroarg"), "foo",
+ withFix(Fix(Test.range("macroarg"), "foo",
"change 'fod' to 'foo'")))));
}
auto TU = TestTU::withCode(Test.code());
EXPECT_THAT(*TU.build().getDiagnostics(),
ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
- WithFix(Fix(Test.range(), "int",
+ withFix(Fix(Test.range(), "int",
"change 'void' to 'int'")))));
// Same code built as C gets different diagnostics.
TU.Filename = "Plain.c";
*TU.build().getDiagnostics(),
ElementsAre(AllOf(
Diag(Test.range(), "return type of 'main' is not 'int'"),
- WithFix(Fix(Test.range(), "int", "change return type to 'int'")))));
+ withFix(Fix(Test.range(), "int", "change return type to 'int'")))));
}
TEST(DiagnosticsTest, DiagnosticPreamble) {
EXPECT_THAT(*TU.build().getDiagnostics(),
ElementsAre(::testing::AllOf(
Diag(Test.range(), "'not-found.h' file not found"),
- DiagSource(Diag::Clang), DiagName("pp_file_not_found"))));
+ diagSource(Diag::Clang), diagName("pp_file_not_found"))));
}
TEST(DiagnosticsTest, DeduplicatedClangTidyDiagnostics) {
ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
Diag(Test.range(),
"floating point literal has suffix 'f', which is not uppercase"),
- DiagSource(Diag::ClangTidy)))));
+ diagSource(Diag::ClangTidy)))));
Test = Annotations(R"cpp(
template<typename T>
ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
Diag(Test.range(),
"floating point literal has suffix 'f', which is not uppercase"),
- DiagSource(Diag::ClangTidy)))));
+ diagSource(Diag::ClangTidy)))));
}
TEST(DiagnosticsTest, ClangTidy) {
AllOf(Diag(Test.range("deprecated"),
"inclusion of deprecated C++ header 'assert.h'; consider "
"using 'cassert' instead"),
- DiagSource(Diag::ClangTidy),
- DiagName("modernize-deprecated-headers"),
- WithFix(Fix(Test.range("deprecated"), "<cassert>",
+ diagSource(Diag::ClangTidy),
+ diagName("modernize-deprecated-headers"),
+ withFix(Fix(Test.range("deprecated"), "<cassert>",
"change '\"assert.h\"' to '<cassert>'"))),
Diag(Test.range("doubled"),
"suspicious usage of 'sizeof(sizeof(...))'"),
"side effects in the 1st macro argument 'X' are "
"repeated in "
"macro expansion"),
- DiagSource(Diag::ClangTidy),
- DiagName("bugprone-macro-repeated-side-effects"),
- WithNote(Diag(Test.range("macrodef"),
+ diagSource(Diag::ClangTidy),
+ diagName("bugprone-macro-repeated-side-effects"),
+ withNote(Diag(Test.range("macrodef"),
"macro 'SQUARE' defined here"))),
AllOf(Diag(Test.range("main"),
"use a trailing return type for this function"),
- DiagSource(Diag::ClangTidy),
- DiagName("modernize-use-trailing-return-type"),
+ diagSource(Diag::ClangTidy),
+ diagName("modernize-use-trailing-return-type"),
// Verify there's no "[check-name]" suffix in the message.
- WithFix(FixMessage(
+ withFix(fixMessage(
"use a trailing return type for this function"))),
Diag(Test.range("foo"),
"function 'foo' is within a recursive call chain"),
*TU.build().getDiagnostics(),
ifTidyChecks(Contains(
AllOf(Diag(Test.range(), "#includes are not sorted properly"),
- DiagSource(Diag::ClangTidy), DiagName("llvm-include-order")))));
+ diagSource(Diag::ClangTidy), diagName("llvm-include-order")))));
}
TEST(DiagnosticTest, TemplatesInHeaders) {
*TU.build().getDiagnostics(),
ElementsAre(AllOf(
Diag(Main.range(), "in template: base specifier must name a class"),
- WithNote(Diag(Header.range(), "error occurred here"),
+ withNote(Diag(Header.range(), "error occurred here"),
Diag(Main.range(), "in instantiation of template class "
"'Derived<int>' requested here")))));
}
*TU.build().getDiagnostics(),
ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
Diag(Main.range(), "use range-based for loop instead"),
- DiagSource(Diag::ClangTidy), DiagName("modernize-loop-convert")))));
+ diagSource(Diag::ClangTidy), diagName("modernize-loop-convert")))));
}
TEST(DiagnosticTest, RespectsDiagnosticConfig) {
ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
Diag(Main.range(), "result of integer division used in a floating "
"point context; possible loss of precision"),
- DiagSource(Diag::ClangTidy),
- DiagName("bugprone-integer-division")))));
+ diagSource(Diag::ClangTidy),
+ diagName("bugprone-integer-division")))));
}
TEST(DiagnosticTest, ClangTidyWarningAsError) {
ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
Diag(Main.range(), "result of integer division used in a floating "
"point context; possible loss of precision"),
- DiagSource(Diag::ClangTidy), DiagName("bugprone-integer-division"),
- DiagSeverity(DiagnosticsEngine::Error)))));
+ diagSource(Diag::ClangTidy), diagName("bugprone-integer-division"),
+ diagSeverity(DiagnosticsEngine::Error)))));
}
TidyProvider addClangArgs(std::vector<llvm::StringRef> ExtraArgs) {
// This is always emitted as a clang warning, not a clang-tidy diagnostic.
auto UnusedFooWarning =
AllOf(Diag(Main.range(), "unused function 'foo'"),
- DiagName("-Wunused-function"), DiagSource(Diag::Clang),
- DiagSeverity(DiagnosticsEngine::Warning));
+ diagName("-Wunused-function"), diagSource(Diag::Clang),
+ diagSeverity(DiagnosticsEngine::Warning));
// Check the -Wunused warning isn't initially on.
EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
TU.ExtraArgs = {"-Werror"};
TU.ClangTidyProvider = addClangArgs({"-Wunused"});
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(DiagSeverity(DiagnosticsEngine::Warning)));
+ ElementsAre(diagSeverity(DiagnosticsEngine::Warning)));
// But clang-tidy extra args won't *downgrade* errors to warnings either.
TU.ExtraArgs = {"-Wunused", "-Werror"};
TU.ClangTidyProvider = addClangArgs({"-Wunused"});
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(DiagSeverity(DiagnosticsEngine::Error)));
+ ElementsAre(diagSeverity(DiagnosticsEngine::Error)));
// FIXME: we're erroneously downgrading the whole group, this should be Error.
TU.ExtraArgs = {"-Wunused-function", "-Werror"};
TU.ClangTidyProvider = addClangArgs({"-Wunused"});
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(DiagSeverity(DiagnosticsEngine::Warning)));
+ ElementsAre(diagSeverity(DiagnosticsEngine::Warning)));
// This looks silly, but it's the typical result if a warning is enabled by a
// high-level .clang-tidy file and disabled by a low-level one.
TestTU TU = TestTU::withCode(Source.code());
EXPECT_THAT(
*TU.build().getDiagnostics(),
- ElementsAre(WithFix(Fix(
+ ElementsAre(withFix(Fix(
Source.range(),
"somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier",
"change 'omereallyreallyreallyreallyreallyreallyreallyreall…' to "
)cpp");
TU.Code = std::string(Source.code());
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(WithFix(
+ ElementsAre(withFix(
Fix(Source.range(), "ident", "change 'ide\\…' to 'ident'"))));
}
TU.ExtraArgs = {"-Wnewline-eof"};
EXPECT_THAT(
*TU.build().getDiagnostics(),
- ElementsAre(WithFix((Fix(Source.range(), "\n", "insert '\\n'")))));
+ ElementsAre(withFix((Fix(Source.range(), "\n", "insert '\\n'")))));
}
TEST(DiagnosticTest, ClangTidySuppressionCommentTrumpsWarningAsError) {
)cpp");
TU.Filename = "foo.h";
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(DiagName("pp_including_mainfile_in_preamble")));
+ ElementsAre(diagName("pp_including_mainfile_in_preamble")));
EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
}
TU.Filename = "foo.h";
// FIXME: should be no errors here.
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(DiagName("pp_including_mainfile_in_preamble")));
+ ElementsAre(diagName("pp_including_mainfile_in_preamble")));
EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
}
auto TU = TestTU::withCode(Test.code());
EXPECT_THAT(*TU.build().getDiagnostics(),
ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
- Not(WithFix(_)))));
+ Not(withFix(_)))));
}
TEST(DiagnosticsTest, PragmaSystemHeader) {
EXPECT_THAT(
LSPDiags,
- ElementsAre(Pair(EqualToLSPDiag(MainLSP), ElementsAre(EqualToFix(F))),
- Pair(EqualToLSPDiag(NoteInMainLSP), IsEmpty())));
+ ElementsAre(Pair(equalToLSPDiag(MainLSP), ElementsAre(equalToFix(F))),
+ Pair(equalToLSPDiag(NoteInMainLSP), IsEmpty())));
EXPECT_EQ(LSPDiags[0].first.code, "undeclared_var_use");
EXPECT_EQ(LSPDiags[0].first.source, "clang");
EXPECT_EQ(LSPDiags[1].first.code, "");
NoteInHeaderDRI.location.range = NoteInHeader.Range;
NoteInHeaderDRI.location.uri = HeaderFile;
MainLSP.relatedInformation = {NoteInMainDRI, NoteInHeaderDRI};
- EXPECT_THAT(LSPDiags, ElementsAre(Pair(EqualToLSPDiag(MainLSP),
- ElementsAre(EqualToFix(F)))));
+ EXPECT_THAT(LSPDiags, ElementsAre(Pair(equalToLSPDiag(MainLSP),
+ ElementsAre(equalToFix(F)))));
}
struct SymbolWithHeader {
TU.Code = Main.code().str() + "\n // error-ok";
EXPECT_THAT(
*TU.build().getDiagnostics(),
- ElementsAre(AllOf(DiagName(Case.first), HasRange(Main.range()),
- WithFix(Fix(Range{}, "#include \"x.h\"\n",
+ ElementsAre(AllOf(diagName(Case.first), hasRange(Main.range()),
+ withFix(Fix(Range{}, "#include \"x.h\"\n",
"Include \"x.h\" for symbol ns::X")))))
<< Case.second;
}
Annotations Main(Case.second);
TU.Code = Main.code().str() + "\n // error-ok";
EXPECT_THAT(*TU.build().getDiagnostics(),
- Contains(AllOf(DiagName(Case.first), HasRange(Main.range()),
- WithFix(Fix(Range{}, "#include \"x.h\"\n",
+ Contains(AllOf(diagName(Case.first), hasRange(Main.range()),
+ withFix(Fix(Range{}, "#include \"x.h\"\n",
"Include \"x.h\" for symbol X")))))
<< Case.second;
}
*TU.build().getDiagnostics(),
UnorderedElementsAre(
AllOf(Diag(Test.range("unqualified1"), "unknown type name 'X'"),
- DiagName("unknown_typename"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("unknown_typename"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol ns::X"))),
Diag(Test.range("unqualified2"), "use of undeclared identifier 'X'"),
AllOf(Diag(Test.range("qualified1"),
"no type named 'X' in namespace 'ns'"),
- DiagName("typename_nested_not_found"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("typename_nested_not_found"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol ns::X"))),
AllOf(Diag(Test.range("qualified2"),
"no member named 'X' in namespace 'ns'"),
- DiagName("no_member"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("no_member"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol ns::X"))),
AllOf(Diag(Test.range("global"),
"no type named 'Global' in the global namespace"),
- DiagName("typename_nested_not_found"),
- WithFix(Fix(Test.range("insert"), "#include \"global.h\"\n",
+ diagName("typename_nested_not_found"),
+ withFix(Fix(Test.range("insert"), "#include \"global.h\"\n",
"Include \"global.h\" for symbol Global"))),
AllOf(Diag(Test.range("template"),
"no template named 'Foo' in namespace 'ns'"),
- DiagName("no_member_template"),
- WithFix(Fix(Test.range("insert"), "#include \"foo.h\"\n",
+ diagName("no_member_template"),
+ withFix(Fix(Test.range("insert"), "#include \"foo.h\"\n",
"Include \"foo.h\" for symbol ns::Foo")))));
}
EXPECT_THAT(*TU.build().getDiagnostics(),
UnorderedElementsAre(AllOf(
Diag(Test.range("unqualified"), "unknown type name 'X'"),
- DiagName("unknown_typename"),
- WithFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
+ diagName("unknown_typename"),
+ withFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
"Include \"a.h\" for symbol na::X"),
Fix(Test.range("insert"), "#include \"b.h\"\n",
"Include \"b.h\" for symbol na::nb::X")))));
*TU.build().getDiagnostics(),
UnorderedElementsAre(
AllOf(Diag(Test.range(), "no member named 'scope' in namespace 'ns'"),
- DiagName("no_member"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("no_member"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol ns::scope::X_Y")))));
}
UnorderedElementsAre(
AllOf(Diag(Test.range("q1"), "use of undeclared identifier 'clangd'; "
"did you mean 'clang'?"),
- DiagName("undeclared_var_use_suggest"),
- WithFix(_, // change clangd to clang
+ diagName("undeclared_var_use_suggest"),
+ withFix(_, // change clangd to clang
Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol clang::clangd::X"))),
AllOf(Diag(Test.range("x"), "no type named 'X' in namespace 'clang'"),
- DiagName("typename_nested_not_found"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("typename_nested_not_found"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol clang::clangd::X"))),
AllOf(
Diag(Test.range("q2"), "use of undeclared identifier 'clangd'; "
"did you mean 'clang'?"),
- DiagName("undeclared_var_use_suggest"),
- WithFix(_, // change clangd to clang
+ diagName("undeclared_var_use_suggest"),
+ withFix(_, // change clangd to clang
Fix(Test.range("insert"), "#include \"y.h\"\n",
"Include \"y.h\" for symbol clang::clangd::ns::Y"))),
AllOf(Diag(Test.range("ns"),
"no member named 'ns' in namespace 'clang'"),
- DiagName("no_member"),
- WithFix(
+ diagName("no_member"),
+ withFix(
Fix(Test.range("insert"), "#include \"y.h\"\n",
"Include \"y.h\" for symbol clang::clangd::ns::Y")))));
}
EXPECT_THAT(*TU.build().getDiagnostics(),
UnorderedElementsAre(AllOf(
Diag(Test.range(), "no type named 'X' in namespace 'a'"),
- DiagName("typename_nested_not_found"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("typename_nested_not_found"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol a::X")))));
}
ElementsAre(AllOf(
Diag(Test.range(), "implicitly declaring library function 'printf' "
"with type 'int (const char *, ...)'"),
- WithFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
+ withFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
"Include <stdio.h> for symbol printf")))));
}
ElementsAre(AllOf(
Diag(Test.range(),
"implicit declaration of function 'foo' is invalid in C99"),
- WithFix(Fix(Range{}, "#include \"foo.h\"\n",
+ withFix(Fix(Range{}, "#include \"foo.h\"\n",
"Include \"foo.h\" for symbol foo")))));
}
UnorderedElementsAre(AllOf(
Diag(Main.range(), "in included file: C++ requires a "
"type specifier for all declarations"),
- WithNote(Diag(Header.range(), "error occurred here")))));
+ withNote(Diag(Header.range(), "error occurred here")))));
}
TEST(DiagsInHeaders, DiagInTransitiveInclude) {
UnorderedElementsAre(AllOf(
Diag(Main.range(), "in included file: C++ requires "
"a type specifier for all declarations"),
- WithNote(Diag(Header.range(), "error occurred here")))));
+ withNote(Diag(Header.range(), "error occurred here")))));
}
TEST(DiagsInHeaders, OnlyDefaultErrorOrFatal) {
UnorderedElementsAre(AllOf(
Diag(Main.range(),
"in included file: use of undeclared identifier 'NOOO'"),
- WithNote(Diag(Header.range(), "error occurred here")))));
+ withNote(Diag(Header.range(), "error occurred here")))));
}
TEST(DiagsInHeaders, ErrorFromMacroExpansion) {
EXPECT_THAT(*TU.build().getDiagnostics(),
UnorderedElementsAre(
AllOf(Diag(Test.range("unused"), "unused variable 'x'"),
- WithTag(DiagnosticTag::Unnecessary)),
+ withTag(DiagnosticTag::Unnecessary)),
AllOf(Diag(Test.range("deprecated"), "'bar' is deprecated"),
- WithTag(DiagnosticTag::Deprecated))));
+ withTag(DiagnosticTag::Deprecated))));
}
TEST(DiagnosticsTest, IncludeCleaner) {
*TU.build().getDiagnostics(),
UnorderedElementsAre(AllOf(
Diag(Test.range("diag"), "included header unused.h is not used"),
- WithTag(DiagnosticTag::Unnecessary), DiagSource(Diag::Clangd),
- WithFix(Fix(Test.range("fix"), "", "remove #include directive")))));
+ withTag(DiagnosticTag::Unnecessary), diagSource(Diag::Clangd),
+ withFix(Fix(Test.range("fix"), "", "remove #include directive")))));
Cfg.Diagnostics.SuppressAll = true;
WithContextValue SuppressAllWithCfg(Config::Key, std::move(Cfg));
EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
using testing::Not;
using testing::SizeIs;
-MATCHER_P(WithDetail, str, "") { return arg.detail == str; }
+MATCHER_P(withDetail, str, "") { return arg.detail == str; }
TEST(DumpASTTests, BasicInfo) {
std::pair</*Code=*/std::string, /*Expected=*/std::string> Cases[] = {
auto Node = dumpAST(
DynTypedNode::create(*AST.getASTContext().getTranslationUnitDecl()),
AST.getTokens(), AST.getASTContext());
- ASSERT_THAT(Node.children, Contains(WithDetail("varFromSource")));
- ASSERT_THAT(Node.children, Not(Contains(WithDetail("funcFromHeader"))));
+ ASSERT_THAT(Node.children, Contains(withDetail("varFromSource")));
+ ASSERT_THAT(Node.children, Not(Contains(withDetail("funcFromHeader"))));
EXPECT_THAT(Node.arcana, testing::StartsWith("TranslationUnitDecl "));
ASSERT_FALSE(Node.range.hasValue())
<< "Expected no range for translation unit";
/// An overload for convenience.
llvm::Optional<OpaqueType> fromCompletionResult(const NamedDecl *D) {
return OpaqueType::fromCompletionResult(
- ASTCtx(), CodeCompletionResult(D, CCP_Declaration));
+ astCtx(), CodeCompletionResult(D, CCP_Declaration));
}
/// A set of DeclNames whose type match each other computed by
using EquivClass = std::set<std::string>;
Matcher<std::map<std::string, EquivClass>>
- ClassesAre(llvm::ArrayRef<EquivClass> Classes) {
+ classesAre(llvm::ArrayRef<EquivClass> Classes) {
using MapEntry = std::map<std::string, EquivClass>::value_type;
std::vector<Matcher<MapEntry>> Elements;
buildEquivClasses(llvm::ArrayRef<llvm::StringRef> DeclNames) {
std::map<std::string, EquivClass> Classes;
for (llvm::StringRef Name : DeclNames) {
- auto Type = OpaqueType::fromType(ASTCtx(), typeOf(Name));
+ auto Type = OpaqueType::fromType(astCtx(), typeOf(Name));
Classes[std::string(Type->raw())].insert(std::string(Name));
}
return Classes;
}
- ASTContext &ASTCtx() { return AST->getASTContext(); }
+ ASTContext &astCtx() { return AST->getASTContext(); }
private:
// Set after calling build().
EXPECT_THAT(buildEquivClasses({"b", "i", "ui", "ll", "f", "d", "iptr", "bptr",
"user_type"}),
- ClassesAre({{"b"},
+ classesAre({{"b"},
{"i", "ui", "ll"},
{"f", "d"},
{"iptr"},
int* int_ptr;
)cpp");
- OpaqueType IntTy = *OpaqueType::fromType(ASTCtx(), typeOf("int_"));
+ OpaqueType IntTy = *OpaqueType::fromType(astCtx(), typeOf("int_"));
EXPECT_EQ(fromCompletionResult(decl("returns_int")), IntTy);
- OpaqueType IntPtrTy = *OpaqueType::fromType(ASTCtx(), typeOf("int_ptr"));
+ OpaqueType IntPtrTy = *OpaqueType::fromType(astCtx(), typeOf("int_ptr"));
EXPECT_EQ(fromCompletionResult(decl("returns_ptr")), IntPtrTy);
}
int* int_ptr_;
)cpp");
- auto IntPtrTy = *OpaqueType::fromType(ASTCtx(), typeOf("int_ptr_"));
+ auto IntPtrTy = *OpaqueType::fromType(astCtx(), typeOf("int_ptr_"));
EXPECT_EQ(fromCompletionResult(decl("returns_not_dependent")), IntPtrTy);
EXPECT_EQ(fromCompletionResult(decl("returns_dependent")), llvm::None);
using ::testing::Pair;
using ::testing::UnorderedElementsAre;
-MATCHER_P(RefRange, Range, "") {
+MATCHER_P(refRange, Range, "") {
return std::make_tuple(arg.Location.Start.line(), arg.Location.Start.column(),
arg.Location.End.line(), arg.Location.End.column()) ==
std::make_tuple(Range.start.line, Range.start.character,
Range.end.line, Range.end.character);
}
-MATCHER_P(FileURI, F, "") { return llvm::StringRef(arg.Location.FileURI) == F; }
-MATCHER_P(DeclURI, U, "") {
+MATCHER_P(fileURI, F, "") { return llvm::StringRef(arg.Location.FileURI) == F; }
+MATCHER_P(declURI, U, "") {
return llvm::StringRef(arg.CanonicalDeclaration.FileURI) == U;
}
-MATCHER_P(DefURI, U, "") {
+MATCHER_P(defURI, U, "") {
return llvm::StringRef(arg.Definition.FileURI) == U;
}
-MATCHER_P(QName, N, "") { return (arg.Scope + arg.Name).str() == N; }
-MATCHER_P(NumReferences, N, "") { return arg.References == N; }
+MATCHER_P(qName, N, "") { return (arg.Scope + arg.Name).str() == N; }
+MATCHER_P(numReferences, N, "") { return arg.References == N; }
MATCHER_P(hasOrign, O, "") { return bool(arg.Origin & O); }
namespace clang {
namespace clangd {
namespace {
::testing::Matcher<const RefSlab &>
-RefsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
+refsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
return ElementsAre(::testing::Pair(_, UnorderedElementsAreArray(Matchers)));
}
std::unique_ptr<SymbolSlab> numSlab(int Begin, int End) {
SymbolSlab::Builder Slab;
- for (int i = Begin; i <= End; i++)
- Slab.insert(symbol(std::to_string(i)));
+ for (int I = Begin; I <= End; I++)
+ Slab.insert(symbol(std::to_string(I)));
return std::make_unique<SymbolSlab>(std::move(Slab).build());
}
FS.update("f1", numSlab(1, 3), refSlab(SymbolID("1"), "f1.cc"), nullptr,
false);
EXPECT_THAT(runFuzzyFind(*FS.buildIndex(IndexType::Light), ""),
- UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
+ UnorderedElementsAre(qName("1"), qName("2"), qName("3")));
EXPECT_THAT(getRefs(*FS.buildIndex(IndexType::Light), SymbolID("1")),
- RefsAre({FileURI("f1.cc")}));
+ refsAre({fileURI("f1.cc")}));
}
TEST(FileSymbolsTest, Overlap) {
FS.update("f2", numSlab(3, 5), nullptr, nullptr, false);
for (auto Type : {IndexType::Light, IndexType::Heavy})
EXPECT_THAT(runFuzzyFind(*FS.buildIndex(Type), ""),
- UnorderedElementsAre(QName("1"), QName("2"), QName("3"),
- QName("4"), QName("5")));
+ UnorderedElementsAre(qName("1"), qName("2"), qName("3"),
+ qName("4"), qName("5")));
}
TEST(FileSymbolsTest, MergeOverlap) {
EXPECT_THAT(
runFuzzyFind(*FS.buildIndex(Type, DuplicateHandling::Merge), "x"),
UnorderedElementsAre(
- AllOf(QName("x"), DeclURI("file:///x1"), DefURI("file:///x2"))));
+ AllOf(qName("x"), declURI("file:///x1"), defURI("file:///x2"))));
}
TEST(FileSymbolsTest, SnapshotAliveAfterRemove) {
auto Symbols = FS.buildIndex(IndexType::Light);
EXPECT_THAT(runFuzzyFind(*Symbols, ""),
- UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
- EXPECT_THAT(getRefs(*Symbols, ID), RefsAre({FileURI("f1.cc")}));
+ UnorderedElementsAre(qName("1"), qName("2"), qName("3")));
+ EXPECT_THAT(getRefs(*Symbols, ID), refsAre({fileURI("f1.cc")}));
FS.update("f1", nullptr, nullptr, nullptr, false);
auto Empty = FS.buildIndex(IndexType::Light);
EXPECT_THAT(getRefs(*Empty, ID), ElementsAre());
EXPECT_THAT(runFuzzyFind(*Symbols, ""),
- UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
- EXPECT_THAT(getRefs(*Symbols, ID), RefsAre({FileURI("f1.cc")}));
+ UnorderedElementsAre(qName("1"), qName("2"), qName("3")));
+ EXPECT_THAT(getRefs(*Symbols, ID), refsAre({fileURI("f1.cc")}));
}
// Adds Basename.cpp, which includes Basename.h, which contains Code.
FileIndex M;
update(M, "f", "class string {};");
- EXPECT_THAT(runFuzzyFind(M, ""), ElementsAre(DeclURI("unittest:///f.h")));
+ EXPECT_THAT(runFuzzyFind(M, ""), ElementsAre(declURI("unittest:///f.h")));
}
TEST(FileIndexTest, IndexAST) {
Req.Query = "";
Req.Scopes = {"ns::"};
EXPECT_THAT(runFuzzyFind(M, Req),
- UnorderedElementsAre(QName("ns::f"), QName("ns::X")));
+ UnorderedElementsAre(qName("ns::f"), qName("ns::X")));
}
TEST(FileIndexTest, NoLocal) {
EXPECT_THAT(
runFuzzyFind(M, ""),
- UnorderedElementsAre(QName("ns"), QName("ns::f"), QName("ns::X")));
+ UnorderedElementsAre(qName("ns"), qName("ns::f"), qName("ns::X")));
}
TEST(FileIndexTest, IndexMultiASTAndDeduplicate) {
Req.Scopes = {"ns::"};
EXPECT_THAT(
runFuzzyFind(M, Req),
- UnorderedElementsAre(QName("ns::f"), QName("ns::X"), QName("ns::ff")));
+ UnorderedElementsAre(qName("ns::f"), qName("ns::X"), qName("ns::ff")));
}
TEST(FileIndexTest, ClassMembers) {
update(M, "f1", "class X { static int m1; int m2; static void f(); };");
EXPECT_THAT(runFuzzyFind(M, ""),
- UnorderedElementsAre(QName("X"), QName("X::m1"), QName("X::m2"),
- QName("X::f")));
+ UnorderedElementsAre(qName("X"), qName("X::m1"), qName("X::m2"),
+ qName("X::f")));
}
TEST(FileIndexTest, IncludeCollected) {
auto Symbols = runFuzzyFind(M, "");
EXPECT_THAT(Symbols,
- UnorderedElementsAre(QName("vector"), QName("make_vector")));
+ UnorderedElementsAre(qName("vector"), qName("make_vector")));
auto It = Symbols.begin();
Symbol Vector = *It++;
Symbol MakeVector = *It++;
Req.Scopes = {"", "ns_in_header::"};
EXPECT_THAT(runFuzzyFind(Index, Req),
- UnorderedElementsAre(QName("ns_in_header"),
- QName("ns_in_header::func_in_header")));
+ UnorderedElementsAre(qName("ns_in_header"),
+ qName("ns_in_header::func_in_header")));
}
TEST(FileIndexTest, Refs) {
Index.updateMain(testPath(Test2.Filename), AST);
EXPECT_THAT(getRefs(Index, Foo.ID),
- RefsAre({AllOf(RefRange(MainCode.range("foo")),
- FileURI("unittest:///test.cc")),
- AllOf(RefRange(MainCode.range("foo")),
- FileURI("unittest:///test2.cc"))}));
+ refsAre({AllOf(refRange(MainCode.range("foo")),
+ fileURI("unittest:///test.cc")),
+ AllOf(refRange(MainCode.range("foo")),
+ fileURI("unittest:///test2.cc"))}));
}
TEST(FileIndexTest, MacroRefs) {
auto HeaderMacro = findSymbol(Test.headerSymbols(), "HEADER_MACRO");
EXPECT_THAT(getRefs(Index, HeaderMacro.ID),
- RefsAre({AllOf(RefRange(MainCode.range("ref1")),
- FileURI("unittest:///test.cc"))}));
+ refsAre({AllOf(refRange(MainCode.range("ref1")),
+ fileURI("unittest:///test.cc"))}));
auto MainFileMacro = findSymbol(Test.headerSymbols(), "MAINFILE_MACRO");
EXPECT_THAT(getRefs(Index, MainFileMacro.ID),
- RefsAre({AllOf(RefRange(MainCode.range("def2")),
- FileURI("unittest:///test.cc")),
- AllOf(RefRange(MainCode.range("ref2")),
- FileURI("unittest:///test.cc"))}));
+ refsAre({AllOf(refRange(MainCode.range("def2")),
+ fileURI("unittest:///test.cc")),
+ AllOf(refRange(MainCode.range("ref2")),
+ fileURI("unittest:///test.cc"))}));
}
TEST(FileIndexTest, CollectMacros) {
FileIndex M;
update(M, "f", "#define CLANGD 1");
- EXPECT_THAT(runFuzzyFind(M, ""), Contains(QName("CLANGD")));
+ EXPECT_THAT(runFuzzyFind(M, ""), Contains(qName("CLANGD")));
}
TEST(FileIndexTest, Relations) {
// Expect to see references in main file, references in headers are excluded
// because we only index main AST.
EXPECT_THAT(getRefs(Index, findSymbol(TU.headerSymbols(), "Foo").ID),
- RefsAre({RefRange(Main.range())}));
+ refsAre({refRange(Main.range())}));
}
TEST(FileIndexTest, MergeMainFileSymbols) {
auto Symbols = runFuzzyFind(Index, "");
// Check foo is merged, foo in Cpp wins (as we see the definition there).
- EXPECT_THAT(Symbols, ElementsAre(AllOf(DeclURI("unittest:///foo.h"),
- DefURI("unittest:///foo.cpp"),
+ EXPECT_THAT(Symbols, ElementsAre(AllOf(declURI("unittest:///foo.h"),
+ defURI("unittest:///foo.cpp"),
hasOrign(SymbolOrigin::Merge))));
}
EXPECT_THAT(
runFuzzyFind(*FS.buildIndex(IndexType::Light, DuplicateHandling::Merge),
""),
- UnorderedElementsAre(AllOf(QName("1"), NumReferences(0u)),
- AllOf(QName("2"), NumReferences(0u)),
- AllOf(QName("3"), NumReferences(0u))));
+ UnorderedElementsAre(AllOf(qName("1"), numReferences(0u)),
+ AllOf(qName("2"), numReferences(0u)),
+ AllOf(qName("3"), numReferences(0u))));
}
TEST(FileSymbolsTest, CountReferencesWithRefSlabs) {
EXPECT_THAT(
runFuzzyFind(*FS.buildIndex(IndexType::Light, DuplicateHandling::Merge),
""),
- UnorderedElementsAre(AllOf(QName("1"), NumReferences(1u)),
- AllOf(QName("2"), NumReferences(1u)),
- AllOf(QName("3"), NumReferences(1u))));
+ UnorderedElementsAre(AllOf(qName("1"), numReferences(1u)),
+ AllOf(qName("2"), numReferences(1u)),
+ AllOf(qName("3"), numReferences(1u))));
}
TEST(FileIndexTest, StalePreambleSymbolsDeleted) {
M.updatePreamble(testPath(File.Filename), /*Version=*/"null",
AST.getASTContext(), AST.getPreprocessor(),
AST.getCanonicalIncludes());
- EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(QName("a")));
+ EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(qName("a")));
File.Filename = "f2.cpp";
File.HeaderCode = "int b;";
M.updatePreamble(testPath(File.Filename), /*Version=*/"null",
AST.getASTContext(), AST.getPreprocessor(),
AST.getCanonicalIncludes());
- EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(QName("b")));
+ EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(qName("b")));
}
// Verifies that concurrent calls to updateMain don't "lose" any updates.
{
auto Shard = ShardedIndex.getShard(AHeaderUri);
ASSERT_TRUE(Shard);
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(QName("1")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(qName("1")));
EXPECT_THAT(*Shard->Refs, IsEmpty());
EXPECT_THAT(
*Shard->Relations,
{
auto Shard = ShardedIndex.getShard(BHeaderUri);
ASSERT_TRUE(Shard);
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(QName("2")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(qName("2")));
EXPECT_THAT(*Shard->Refs, IsEmpty());
EXPECT_THAT(
*Shard->Relations,
{
auto Shard = ShardedIndex.getShard(BSourceUri);
ASSERT_TRUE(Shard);
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(QName("2")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(qName("2")));
EXPECT_THAT(*Shard->Refs, UnorderedElementsAre(Pair(Sym1.ID, _)));
EXPECT_THAT(*Shard->Relations, IsEmpty());
ASSERT_THAT(Shard->Sources->keys(),
using ::testing::UnorderedElementsAre;
// GMock helpers for matching SymbolInfos items.
-MATCHER_P(QName, Name, "") {
+MATCHER_P(qName, Name, "") {
if (arg.containerName.empty())
return arg.name == Name;
return (arg.containerName + "::" + arg.name) == Name;
}
-MATCHER_P(WithName, N, "") { return arg.name == N; }
-MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; }
-MATCHER_P(WithDetail, Detail, "") { return arg.detail == Detail; }
-MATCHER_P(SymRange, Range, "") { return arg.range == Range; }
+MATCHER_P(withName, N, "") { return arg.name == N; }
+MATCHER_P(withKind, Kind, "") { return arg.kind == Kind; }
+MATCHER_P(withDetail, Detail, "") { return arg.detail == Detail; }
+MATCHER_P(symRange, Range, "") { return arg.range == Range; }
// GMock helpers for matching DocumentSymbol.
-MATCHER_P(SymNameRange, Range, "") { return arg.selectionRange == Range; }
+MATCHER_P(symNameRange, Range, "") { return arg.selectionRange == Range; }
template <class... ChildMatchers>
-::testing::Matcher<DocumentSymbol> Children(ChildMatchers... ChildrenM) {
+::testing::Matcher<DocumentSymbol> children(ChildMatchers... ChildrenM) {
return Field(&DocumentSymbol::children, UnorderedElementsAre(ChildrenM...));
}
// indexSymbolKindToSymbolKind() currently maps macros
// to SymbolKind::String.
EXPECT_THAT(getSymbols(TU, "macro"),
- ElementsAre(AllOf(QName("MACRO"), WithKind(SymbolKind::String))));
+ ElementsAre(AllOf(qName("MACRO"), withKind(SymbolKind::String))));
}
TEST(WorkspaceSymbols, NoLocals) {
struct LocalClass {};
int local_var;
})cpp";
- EXPECT_THAT(getSymbols(TU, "l"), ElementsAre(QName("LocalClass")));
+ EXPECT_THAT(getSymbols(TU, "l"), ElementsAre(qName("LocalClass")));
EXPECT_THAT(getSymbols(TU, "p"), IsEmpty());
}
)cpp";
EXPECT_THAT(getSymbols(TU, "global"),
UnorderedElementsAre(
- AllOf(QName("GlobalStruct"), WithKind(SymbolKind::Struct)),
- AllOf(QName("global_func"), WithKind(SymbolKind::Function)),
- AllOf(QName("global_var"), WithKind(SymbolKind::Variable))));
+ AllOf(qName("GlobalStruct"), withKind(SymbolKind::Struct)),
+ AllOf(qName("global_func"), withKind(SymbolKind::Function)),
+ AllOf(qName("global_var"), withKind(SymbolKind::Variable))));
}
TEST(WorkspaceSymbols, Unnamed) {
#include "foo.h"
)cpp";
EXPECT_THAT(getSymbols(TU, "UnnamedStruct"),
- ElementsAre(AllOf(QName("UnnamedStruct"),
- WithKind(SymbolKind::Variable))));
+ ElementsAre(AllOf(qName("UnnamedStruct"),
+ withKind(SymbolKind::Variable))));
EXPECT_THAT(getSymbols(TU, "InUnnamed"),
- ElementsAre(AllOf(QName("(anonymous struct)::InUnnamed"),
- WithKind(SymbolKind::Field))));
+ ElementsAre(AllOf(qName("(anonymous struct)::InUnnamed"),
+ withKind(SymbolKind::Field))));
}
TEST(WorkspaceSymbols, InMainFile) {
static void test2() {}
)cpp";
EXPECT_THAT(getSymbols(TU, "test"),
- ElementsAre(QName("test"), QName("test2")));
+ ElementsAre(qName("test"), qName("test2")));
}
TEST(WorkspaceSymbols, Namespaces) {
)cpp";
EXPECT_THAT(getSymbols(TU, "a"),
UnorderedElementsAre(
- QName("ans1"), QName("ans1::ai1"), QName("ans1::ans2"),
- QName("ans1::ans2::ai2"), QName("ans1::ans2::ans3"),
- QName("ans1::ans2::ans3::ai3")));
- EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(QName("ans1")));
- EXPECT_THAT(getSymbols(TU, "::a"), ElementsAre(QName("ans1")));
+ qName("ans1"), qName("ans1::ai1"), qName("ans1::ans2"),
+ qName("ans1::ans2::ai2"), qName("ans1::ans2::ans3"),
+ qName("ans1::ans2::ans3::ai3")));
+ EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(qName("ans1")));
+ EXPECT_THAT(getSymbols(TU, "::a"), ElementsAre(qName("ans1")));
EXPECT_THAT(getSymbols(TU, "ans1::"),
- UnorderedElementsAre(QName("ans1::ai1"), QName("ans1::ans2"),
- QName("ans1::ans2::ai2"),
- QName("ans1::ans2::ans3"),
- QName("ans1::ans2::ans3::ai3")));
+ UnorderedElementsAre(qName("ans1::ai1"), qName("ans1::ans2"),
+ qName("ans1::ans2::ai2"),
+ qName("ans1::ans2::ans3"),
+ qName("ans1::ans2::ans3::ai3")));
EXPECT_THAT(getSymbols(TU, "ans2::"),
- UnorderedElementsAre(QName("ans1::ans2::ai2"),
- QName("ans1::ans2::ans3"),
- QName("ans1::ans2::ans3::ai3")));
- EXPECT_THAT(getSymbols(TU, "::ans1"), ElementsAre(QName("ans1")));
+ UnorderedElementsAre(qName("ans1::ans2::ai2"),
+ qName("ans1::ans2::ans3"),
+ qName("ans1::ans2::ans3::ai3")));
+ EXPECT_THAT(getSymbols(TU, "::ans1"), ElementsAre(qName("ans1")));
EXPECT_THAT(getSymbols(TU, "::ans1::"),
- UnorderedElementsAre(QName("ans1::ai1"), QName("ans1::ans2")));
- EXPECT_THAT(getSymbols(TU, "::ans1::ans2"), ElementsAre(QName("ans1::ans2")));
+ UnorderedElementsAre(qName("ans1::ai1"), qName("ans1::ans2")));
+ EXPECT_THAT(getSymbols(TU, "::ans1::ans2"), ElementsAre(qName("ans1::ans2")));
EXPECT_THAT(getSymbols(TU, "::ans1::ans2::"),
- ElementsAre(QName("ans1::ans2::ai2"), QName("ans1::ans2::ans3")));
+ ElementsAre(qName("ans1::ans2::ai2"), qName("ans1::ans2::ans3")));
// Ensure sub-sequence matching works.
EXPECT_THAT(getSymbols(TU, "ans1::ans3::ai"),
- UnorderedElementsAre(QName("ans1::ans2::ans3::ai3")));
+ UnorderedElementsAre(qName("ans1::ans2::ans3::ai3")));
}
TEST(WorkspaceSymbols, AnonymousNamespace) {
void test() {}
}
)cpp";
- EXPECT_THAT(getSymbols(TU, "test"), ElementsAre(QName("test")));
+ EXPECT_THAT(getSymbols(TU, "test"), ElementsAre(qName("test")));
}
TEST(WorkspaceSymbols, MultiFile) {
#include "foo2.h"
)cpp";
EXPECT_THAT(getSymbols(TU, "foo"),
- UnorderedElementsAre(QName("foo"), QName("foo2")));
+ UnorderedElementsAre(qName("foo"), qName("foo2")));
}
TEST(WorkspaceSymbols, GlobalNamespaceQueries) {
)cpp";
EXPECT_THAT(getSymbols(TU, "::"),
UnorderedElementsAre(
- AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
- AllOf(QName("foo"), WithKind(SymbolKind::Function)),
- AllOf(QName("ns"), WithKind(SymbolKind::Namespace))));
+ AllOf(qName("Foo"), withKind(SymbolKind::Class)),
+ AllOf(qName("foo"), withKind(SymbolKind::Function)),
+ AllOf(qName("ns"), withKind(SymbolKind::Namespace))));
EXPECT_THAT(getSymbols(TU, ":"), IsEmpty());
EXPECT_THAT(getSymbols(TU, ""),
- UnorderedElementsAre(QName("foo"), QName("Foo"), QName("Foo::a"),
- QName("ns"), QName("ns::foo2")));
+ UnorderedElementsAre(qName("foo"), qName("Foo"), qName("Foo::a"),
+ qName("ns"), qName("ns::foo2")));
}
TEST(WorkspaceSymbols, Enums) {
TU.Code = R"cpp(
#include "foo.h"
)cpp";
- EXPECT_THAT(getSymbols(TU, "Red"), ElementsAre(QName("Red")));
- EXPECT_THAT(getSymbols(TU, "::Red"), ElementsAre(QName("Red")));
- EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(QName("Green")));
- EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(QName("Green")));
+ EXPECT_THAT(getSymbols(TU, "Red"), ElementsAre(qName("Red")));
+ EXPECT_THAT(getSymbols(TU, "::Red"), ElementsAre(qName("Red")));
+ EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(qName("Green")));
+ EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(qName("Green")));
EXPECT_THAT(getSymbols(TU, "Color2::Yellow"),
- ElementsAre(QName("Color2::Yellow")));
- EXPECT_THAT(getSymbols(TU, "Yellow"), ElementsAre(QName("Color2::Yellow")));
+ ElementsAre(qName("Color2::Yellow")));
+ EXPECT_THAT(getSymbols(TU, "Yellow"), ElementsAre(qName("Color2::Yellow")));
- EXPECT_THAT(getSymbols(TU, "ns::Black"), ElementsAre(QName("ns::Black")));
- EXPECT_THAT(getSymbols(TU, "ns::Blue"), ElementsAre(QName("ns::Blue")));
+ EXPECT_THAT(getSymbols(TU, "ns::Black"), ElementsAre(qName("ns::Black")));
+ EXPECT_THAT(getSymbols(TU, "ns::Blue"), ElementsAre(qName("ns::Blue")));
EXPECT_THAT(getSymbols(TU, "ns::Color4::White"),
- ElementsAre(QName("ns::Color4::White")));
+ ElementsAre(qName("ns::Color4::White")));
}
TEST(WorkspaceSymbols, Ranking) {
TU.Code = R"cpp(
#include "foo.h"
)cpp";
- EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(QName("func"), QName("ns")));
+ EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(qName("func"), qName("ns")));
}
TEST(WorkspaceSymbols, RankingPartialNamespace) {
}
namespace ns2 { struct FooB {}; })cpp";
EXPECT_THAT(getSymbols(TU, "ns2::f"),
- ElementsAre(QName("ns2::FooB"), QName("ns1::ns2::Foo")));
+ ElementsAre(qName("ns2::FooB"), qName("ns1::ns2::Foo")));
}
TEST(WorkspaceSymbols, WithLimit) {
// Foo is higher ranked because of exact name match.
EXPECT_THAT(getSymbols(TU, "foo"),
UnorderedElementsAre(
- AllOf(QName("foo"), WithKind(SymbolKind::Variable)),
- AllOf(QName("foo2"), WithKind(SymbolKind::Variable))));
+ AllOf(qName("foo"), withKind(SymbolKind::Variable)),
+ AllOf(qName("foo2"), withKind(SymbolKind::Variable))));
- EXPECT_THAT(getSymbols(TU, "foo", 1), ElementsAre(QName("foo")));
+ EXPECT_THAT(getSymbols(TU, "foo", 1), ElementsAre(qName("foo")));
}
TEST(WorkspaceSymbols, TempSpecs) {
EXPECT_THAT(
getSymbols(TU, "Foo"),
UnorderedElementsAre(
- AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
- AllOf(QName("Foo<int, T>"), WithKind(SymbolKind::Class)),
- AllOf(QName("Foo<bool, int>"), WithKind(SymbolKind::Class)),
- AllOf(QName("Foo<bool, int, 3>"), WithKind(SymbolKind::Class))));
+ AllOf(qName("Foo"), withKind(SymbolKind::Class)),
+ AllOf(qName("Foo<int, T>"), withKind(SymbolKind::Class)),
+ AllOf(qName("Foo<bool, int>"), withKind(SymbolKind::Class)),
+ AllOf(qName("Foo<bool, int, 3>"), withKind(SymbolKind::Class))));
}
std::vector<DocumentSymbol> getSymbols(ParsedAST AST) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAreArray(
- {AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
- WithDetail("class"), Children()),
- AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
- WithDetail("class"),
- Children(
- AllOf(WithName("Foo"), WithKind(SymbolKind::Constructor),
- WithDetail("()"), Children()),
- AllOf(WithName("Foo"), WithKind(SymbolKind::Constructor),
- WithDetail("(int)"), Children()),
- AllOf(WithName("f"), WithKind(SymbolKind::Method),
- WithDetail("void ()"), Children()),
- AllOf(WithName("operator="), WithKind(SymbolKind::Method),
- WithDetail("Foo &(const Foo &)"), Children()),
- AllOf(WithName("~Foo"), WithKind(SymbolKind::Constructor),
- WithDetail(""), Children()),
- AllOf(WithName("Nested"), WithKind(SymbolKind::Class),
- WithDetail("class"),
- Children(AllOf(
- WithName("f"), WithKind(SymbolKind::Method),
- WithDetail("void ()"), Children()))))),
- AllOf(WithName("Friend"), WithKind(SymbolKind::Class),
- WithDetail("class"), Children()),
- AllOf(WithName("f1"), WithKind(SymbolKind::Function),
- WithDetail("void ()"), Children()),
- AllOf(WithName("f2"), WithKind(SymbolKind::Function),
- WithDetail("void ()"), Children()),
- AllOf(WithName("KInt"), WithKind(SymbolKind::Variable),
- WithDetail("const int"), Children()),
- AllOf(WithName("kStr"), WithKind(SymbolKind::Variable),
- WithDetail("const char *"), Children()),
- AllOf(WithName("f1"), WithKind(SymbolKind::Function),
- WithDetail("void ()"), Children()),
+ {AllOf(withName("Foo"), withKind(SymbolKind::Class),
+ withDetail("class"), children()),
+ AllOf(withName("Foo"), withKind(SymbolKind::Class),
+ withDetail("class"),
+ children(
+ AllOf(withName("Foo"), withKind(SymbolKind::Constructor),
+ withDetail("()"), children()),
+ AllOf(withName("Foo"), withKind(SymbolKind::Constructor),
+ withDetail("(int)"), children()),
+ AllOf(withName("f"), withKind(SymbolKind::Method),
+ withDetail("void ()"), children()),
+ AllOf(withName("operator="), withKind(SymbolKind::Method),
+ withDetail("Foo &(const Foo &)"), children()),
+ AllOf(withName("~Foo"), withKind(SymbolKind::Constructor),
+ withDetail(""), children()),
+ AllOf(withName("Nested"), withKind(SymbolKind::Class),
+ withDetail("class"),
+ children(AllOf(
+ withName("f"), withKind(SymbolKind::Method),
+ withDetail("void ()"), children()))))),
+ AllOf(withName("Friend"), withKind(SymbolKind::Class),
+ withDetail("class"), children()),
+ AllOf(withName("f1"), withKind(SymbolKind::Function),
+ withDetail("void ()"), children()),
+ AllOf(withName("f2"), withKind(SymbolKind::Function),
+ withDetail("void ()"), children()),
+ AllOf(withName("KInt"), withKind(SymbolKind::Variable),
+ withDetail("const int"), children()),
+ AllOf(withName("kStr"), withKind(SymbolKind::Variable),
+ withDetail("const char *"), children()),
+ AllOf(withName("f1"), withKind(SymbolKind::Function),
+ withDetail("void ()"), children()),
AllOf(
- WithName("foo"), WithKind(SymbolKind::Namespace), WithDetail(""),
- Children(AllOf(WithName("int32"), WithKind(SymbolKind::Class),
- WithDetail("type alias"), Children()),
- AllOf(WithName("int32_t"), WithKind(SymbolKind::Class),
- WithDetail("type alias"), Children()),
- AllOf(WithName("v1"), WithKind(SymbolKind::Variable),
- WithDetail("int"), Children()),
- AllOf(WithName("bar"), WithKind(SymbolKind::Namespace),
- WithDetail(""),
- Children(AllOf(WithName("v2"),
- WithKind(SymbolKind::Variable),
- WithDetail("int"), Children()))),
- AllOf(WithName("baz"), WithKind(SymbolKind::Namespace),
- WithDetail(""), Children()),
- AllOf(WithName("v2"), WithKind(SymbolKind::Namespace),
- WithDetail(""))))}));
+ withName("foo"), withKind(SymbolKind::Namespace), withDetail(""),
+ children(AllOf(withName("int32"), withKind(SymbolKind::Class),
+ withDetail("type alias"), children()),
+ AllOf(withName("int32_t"), withKind(SymbolKind::Class),
+ withDetail("type alias"), children()),
+ AllOf(withName("v1"), withKind(SymbolKind::Variable),
+ withDetail("int"), children()),
+ AllOf(withName("bar"), withKind(SymbolKind::Namespace),
+ withDetail(""),
+ children(AllOf(withName("v2"),
+ withKind(SymbolKind::Variable),
+ withDetail("int"), children()))),
+ AllOf(withName("baz"), withKind(SymbolKind::Namespace),
+ withDetail(""), children()),
+ AllOf(withName("v2"), withKind(SymbolKind::Namespace),
+ withDetail(""))))}));
}
TEST(DocumentSymbols, DeclarationDefinition) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
- WithDetail("class"),
- Children(AllOf(WithName("f"), WithKind(SymbolKind::Method),
- WithDetail("void ()"),
- SymNameRange(Main.range("decl"))))),
- AllOf(WithName("Foo::f"), WithKind(SymbolKind::Method),
- WithDetail("void ()"), SymNameRange(Main.range("def")))));
+ AllOf(withName("Foo"), withKind(SymbolKind::Class),
+ withDetail("class"),
+ children(AllOf(withName("f"), withKind(SymbolKind::Method),
+ withDetail("void ()"),
+ symNameRange(Main.range("decl"))))),
+ AllOf(withName("Foo::f"), withKind(SymbolKind::Method),
+ withDetail("void ()"), symNameRange(Main.range("def")))));
}
TEST(DocumentSymbols, Concepts) {
TU.Code = "template <typename T> concept C = requires(T t) { t.foo(); };";
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(AllOf(WithName("C"), WithDetail("concept"))));
+ ElementsAre(AllOf(withName("C"), withDetail("concept"))));
}
TEST(DocumentSymbols, ExternSymbol) {
})cpp";
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(WithName("foo"), WithName("Foo"),
- AllOf(WithName("ns"),
- Children(WithName("bar"), WithName("Bar")))));
+ ElementsAre(withName("foo"), withName("Foo"),
+ AllOf(withName("ns"),
+ children(withName("bar"), withName("Bar")))));
}
TEST(DocumentSymbols, ExportContext) {
})cpp";
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(WithName("foo"), WithName("Foo")));
+ ElementsAre(withName("foo"), withName("Foo")));
}
TEST(DocumentSymbols, NoLocals) {
struct LocalClass {};
int local_var;
})cpp";
- EXPECT_THAT(getSymbols(TU.build()), ElementsAre(WithName("test")));
+ EXPECT_THAT(getSymbols(TU.build()), ElementsAre(withName("test")));
}
TEST(DocumentSymbols, Unnamed) {
)cpp";
EXPECT_THAT(
getSymbols(TU.build()),
- ElementsAre(AllOf(WithName("(anonymous struct)"),
- WithKind(SymbolKind::Struct), WithDetail("struct"),
- Children(AllOf(WithName("InUnnamed"),
- WithKind(SymbolKind::Field),
- WithDetail("int"), Children()))),
- AllOf(WithName("UnnamedStruct"),
- WithKind(SymbolKind::Variable),
- WithDetail("struct (unnamed)"), Children())));
+ ElementsAre(AllOf(withName("(anonymous struct)"),
+ withKind(SymbolKind::Struct), withDetail("struct"),
+ children(AllOf(withName("InUnnamed"),
+ withKind(SymbolKind::Field),
+ withDetail("int"), children()))),
+ AllOf(withName("UnnamedStruct"),
+ withKind(SymbolKind::Variable),
+ withDetail("struct (unnamed)"), children())));
}
TEST(DocumentSymbols, InHeaderFile) {
}
)cpp";
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(WithName("i"), WithName("test")));
+ ElementsAre(withName("i"), withName("test")));
}
TEST(DocumentSymbols, Template) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("Tmpl"), WithKind(SymbolKind::Struct),
- WithDetail("template struct"),
- Children(AllOf(WithName("x"), WithKind(SymbolKind::Field),
- WithDetail("T")))),
- AllOf(WithName("Tmpl<int>"), WithKind(SymbolKind::Struct),
- WithDetail("struct"),
- Children(AllOf(WithName("y"), WithDetail("int")))),
- AllOf(WithName("Tmpl<float>"), WithKind(SymbolKind::Struct),
- WithDetail("struct"), Children()),
- AllOf(WithName("Tmpl<double>"), WithKind(SymbolKind::Struct),
- WithDetail("struct"), Children()),
- AllOf(WithName("funcTmpl"), WithDetail("template int (U)"),
- Children()),
- AllOf(WithName("funcTmpl<int>"), WithDetail("int (double)"),
- Children()),
- AllOf(WithName("varTmpl"), WithDetail("template int"), Children()),
- AllOf(WithName("varTmpl<int>"), WithDetail("double"), Children())));
+ AllOf(withName("Tmpl"), withKind(SymbolKind::Struct),
+ withDetail("template struct"),
+ children(AllOf(withName("x"), withKind(SymbolKind::Field),
+ withDetail("T")))),
+ AllOf(withName("Tmpl<int>"), withKind(SymbolKind::Struct),
+ withDetail("struct"),
+ children(AllOf(withName("y"), withDetail("int")))),
+ AllOf(withName("Tmpl<float>"), withKind(SymbolKind::Struct),
+ withDetail("struct"), children()),
+ AllOf(withName("Tmpl<double>"), withKind(SymbolKind::Struct),
+ withDetail("struct"), children()),
+ AllOf(withName("funcTmpl"), withDetail("template int (U)"),
+ children()),
+ AllOf(withName("funcTmpl<int>"), withDetail("int (double)"),
+ children()),
+ AllOf(withName("varTmpl"), withDetail("template int"), children()),
+ AllOf(withName("varTmpl<int>"), withDetail("double"), children())));
}
TEST(DocumentSymbols, Namespaces) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAreArray<::testing::Matcher<DocumentSymbol>>(
- {AllOf(WithName("ans1"),
- Children(AllOf(WithName("ai1"), Children()),
- AllOf(WithName("ans2"), Children(WithName("ai2"))))),
- AllOf(WithName("(anonymous namespace)"), Children(WithName("test"))),
- AllOf(WithName("na"),
- Children(AllOf(WithName("nb"), Children(WithName("Foo"))))),
- AllOf(WithName("na"),
- Children(AllOf(WithName("nb"), Children(WithName("Bar")))))}));
+ {AllOf(withName("ans1"),
+ children(AllOf(withName("ai1"), children()),
+ AllOf(withName("ans2"), children(withName("ai2"))))),
+ AllOf(withName("(anonymous namespace)"), children(withName("test"))),
+ AllOf(withName("na"),
+ children(AllOf(withName("nb"), children(withName("Foo"))))),
+ AllOf(withName("na"),
+ children(AllOf(withName("nb"), children(withName("Bar")))))}));
}
TEST(DocumentSymbols, Enums) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("(anonymous enum)"), WithDetail("enum"),
- Children(AllOf(WithName("Red"), WithDetail("(unnamed)")))),
- AllOf(WithName("Color"), WithDetail("enum"),
- Children(AllOf(WithName("Green"), WithDetail("Color")))),
- AllOf(WithName("Color2"), WithDetail("enum"),
- Children(AllOf(WithName("Yellow"), WithDetail("Color2")))),
- AllOf(WithName("ns"),
- Children(AllOf(WithName("(anonymous enum)"), WithDetail("enum"),
- Children(AllOf(WithName("Black"),
- WithDetail("(unnamed)"))))))));
+ AllOf(withName("(anonymous enum)"), withDetail("enum"),
+ children(AllOf(withName("Red"), withDetail("(unnamed)")))),
+ AllOf(withName("Color"), withDetail("enum"),
+ children(AllOf(withName("Green"), withDetail("Color")))),
+ AllOf(withName("Color2"), withDetail("enum"),
+ children(AllOf(withName("Yellow"), withDetail("Color2")))),
+ AllOf(withName("ns"),
+ children(AllOf(withName("(anonymous enum)"), withDetail("enum"),
+ children(AllOf(withName("Black"),
+ withDetail("(unnamed)"))))))));
}
TEST(DocumentSymbols, Macro) {
#define DEFINE_FLAG(X) bool FLAGS_##X; bool FLAGS_no##X
DEFINE_FLAG(pretty);
)cpp",
- AllOf(WithName("DEFINE_FLAG"), WithDetail("(pretty)"),
- Children(WithName("FLAGS_pretty"), WithName("FLAGS_nopretty"))),
+ AllOf(withName("DEFINE_FLAG"), withDetail("(pretty)"),
+ children(withName("FLAGS_pretty"), withName("FLAGS_nopretty"))),
},
{
R"cpp(
#define ID(X) X
namespace ID(ns) { int ID(y); }
)cpp",
- AllOf(WithName("ID"), WithDetail("(ns)"),
- Children(AllOf(WithName("ns"),
- Children(AllOf(WithName("ID"), WithDetail("(y)"),
- Children(WithName("y"))))))),
+ AllOf(withName("ID"), withDetail("(ns)"),
+ children(AllOf(withName("ns"),
+ children(AllOf(withName("ID"), withDetail("(y)"),
+ children(withName("y"))))))),
},
{
R"cpp(
#define TEST(A, B) class A##_##B { void go(); }; void A##_##B::go()
TEST(DocumentSymbols, Macro) { }
)cpp",
- AllOf(WithName("TEST"), WithDetail("(DocumentSymbols, Macro)"),
- Children(AllOf(WithName("DocumentSymbols_Macro"),
- Children(WithName("go"))),
- WithName("DocumentSymbols_Macro::go"))),
+ AllOf(withName("TEST"), withDetail("(DocumentSymbols, Macro)"),
+ children(AllOf(withName("DocumentSymbols_Macro"),
+ children(withName("go"))),
+ withName("DocumentSymbols_Macro::go"))),
},
{
R"cpp(
NAMESPACE(a, NAMESPACE(b, int x;))
)cpp",
AllOf(
- WithName("NAMESPACE"), WithDetail("(a, NAMESPACE(b, int x;))"),
- Children(AllOf(
- WithName("a"),
- Children(AllOf(WithName("NAMESPACE"),
+ withName("NAMESPACE"), withDetail("(a, NAMESPACE(b, int x;))"),
+ children(AllOf(
+ withName("a"),
+ children(AllOf(withName("NAMESPACE"),
// FIXME: nested expansions not in TokenBuffer
- WithDetail(""),
- Children(AllOf(WithName("b"),
- Children(WithName("x"))))))))),
+ withDetail(""),
+ children(AllOf(withName("b"),
+ children(withName("x"))))))))),
},
{
R"cpp(
#define OUTER(X) INNER(X)
OUTER(foo);
)cpp",
- AllOf(WithName("OUTER"), WithDetail("(foo)"),
- Children(WithName("foo"))),
+ AllOf(withName("OUTER"), withDetail("(foo)"),
+ children(withName("foo"))),
},
};
for (const Test &T : Tests) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("FF"), WithDetail("(abc)"),
- Children(AllOf(WithName("abc_Test"), WithDetail("class"),
- SymNameRange(Main.range("expansion1"))))),
- AllOf(WithName("FF2"), WithDetail("()"),
- SymNameRange(Main.range("expansion2")),
- SymRange(Main.range("expansion2parens")),
- Children(AllOf(WithName("Test"), WithDetail("class"),
- SymNameRange(Main.range("expansion2"))))),
- AllOf(WithName("FF3"), WithDetail("()"),
- SymRange(Main.range("fullDef")),
- Children(AllOf(WithName("waldo"), WithDetail("void ()"),
- SymRange(Main.range("fullDef")))))));
+ AllOf(withName("FF"), withDetail("(abc)"),
+ children(AllOf(withName("abc_Test"), withDetail("class"),
+ symNameRange(Main.range("expansion1"))))),
+ AllOf(withName("FF2"), withDetail("()"),
+ symNameRange(Main.range("expansion2")),
+ symRange(Main.range("expansion2parens")),
+ children(AllOf(withName("Test"), withDetail("class"),
+ symNameRange(Main.range("expansion2"))))),
+ AllOf(withName("FF3"), withDetail("()"),
+ symRange(Main.range("fullDef")),
+ children(AllOf(withName("waldo"), withDetail("void ()"),
+ symRange(Main.range("fullDef")))))));
}
TEST(DocumentSymbols, FuncTemplates) {
TU.Code = Source.code().str();
// Make sure we only see the template declaration, not instantiations.
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(AllOf(WithName("foo"), WithDetail("template T ()")),
- AllOf(WithName("x"), WithDetail("int")),
- AllOf(WithName("y"), WithDetail("double"))));
+ ElementsAre(AllOf(withName("foo"), withDetail("template T ()")),
+ AllOf(withName("x"), withDetail("int")),
+ AllOf(withName("y"), withDetail("double"))));
}
TEST(DocumentSymbols, UsingDirectives) {
)cpp");
TU.Code = Source.code().str();
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(WithName("ns"), WithName("ns_alias"),
- WithName("using namespace ::ns"),
- WithName("using namespace ns_alias")));
+ ElementsAre(withName("ns"), withName("ns_alias"),
+ withName("using namespace ::ns"),
+ withName("using namespace ns_alias")));
}
TEST(DocumentSymbols, TempSpecs) {
// Foo is higher ranked because of exact name match.
EXPECT_THAT(getSymbols(TU.build()),
UnorderedElementsAre(
- AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
- WithDetail("template class")),
- AllOf(WithName("Foo<int, T>"), WithKind(SymbolKind::Class),
- WithDetail("template class")),
- AllOf(WithName("Foo<bool, int>"), WithKind(SymbolKind::Class),
- WithDetail("class")),
- AllOf(WithName("Foo<bool, int, 3>"),
- WithKind(SymbolKind::Class), WithDetail("class"))));
+ AllOf(withName("Foo"), withKind(SymbolKind::Class),
+ withDetail("template class")),
+ AllOf(withName("Foo<int, T>"), withKind(SymbolKind::Class),
+ withDetail("template class")),
+ AllOf(withName("Foo<bool, int>"), withKind(SymbolKind::Class),
+ withDetail("class")),
+ AllOf(withName("Foo<bool, int, 3>"),
+ withKind(SymbolKind::Class), withDetail("class"))));
}
TEST(DocumentSymbols, Qualifiers) {
// All the qualifiers should be preserved exactly as written.
EXPECT_THAT(getSymbols(TU.build()),
UnorderedElementsAre(
- WithName("foo"), WithName("foo::bar::Cls"),
- WithName("foo::bar::func1"), WithName("::foo::bar::func2"),
- WithName("using namespace foo"), WithName("bar::func3"),
- WithName("alias"), WithName("::alias::func4")));
+ withName("foo"), withName("foo::bar::Cls"),
+ withName("foo::bar::func1"), withName("::foo::bar::func2"),
+ withName("using namespace foo"), withName("bar::func3"),
+ withName("alias"), withName("::alias::func4")));
}
TEST(DocumentSymbols, QualifiersWithTemplateArgs) {
)cpp";
EXPECT_THAT(getSymbols(TU.build()),
UnorderedElementsAre(
- AllOf(WithName("Foo"), WithDetail("template class")),
- AllOf(WithName("Foo<int, double>"), WithDetail("class")),
- AllOf(WithName("int_type"), WithDetail("type alias")),
- AllOf(WithName("Foo<int_type, double>::method1"),
- WithDetail("int ()")),
- AllOf(WithName("Foo<int>::method2"), WithDetail("int ()")),
- AllOf(WithName("Foo_type"), WithDetail("type alias")),
- AllOf(WithName("Foo_type::method3"), WithDetail("int ()"))));
+ AllOf(withName("Foo"), withDetail("template class")),
+ AllOf(withName("Foo<int, double>"), withDetail("class")),
+ AllOf(withName("int_type"), withDetail("type alias")),
+ AllOf(withName("Foo<int_type, double>::method1"),
+ withDetail("int ()")),
+ AllOf(withName("Foo<int>::method2"), withDetail("int ()")),
+ AllOf(withName("Foo_type"), withDetail("type alias")),
+ AllOf(withName("Foo_type::method3"), withDetail("int ()"))));
}
TEST(DocumentSymbolsTest, Ranges) {
EXPECT_THAT(
getSymbols(TU.build()),
UnorderedElementsAre(
- AllOf(WithName("foo"), WithKind(SymbolKind::Function),
- WithDetail("int (bool)"), SymRange(Main.range("foo"))),
- AllOf(WithName("GLOBAL_VARIABLE"), WithKind(SymbolKind::Variable),
- WithDetail("char"), SymRange(Main.range("variable"))),
+ AllOf(withName("foo"), withKind(SymbolKind::Function),
+ withDetail("int (bool)"), symRange(Main.range("foo"))),
+ AllOf(withName("GLOBAL_VARIABLE"), withKind(SymbolKind::Variable),
+ withDetail("char"), symRange(Main.range("variable"))),
AllOf(
- WithName("ns"), WithKind(SymbolKind::Namespace),
- SymRange(Main.range("ns")),
- Children(AllOf(
- WithName("Bar"), WithKind(SymbolKind::Class),
- WithDetail("class"), SymRange(Main.range("bar")),
- Children(
- AllOf(WithName("Bar"), WithKind(SymbolKind::Constructor),
- WithDetail("()"), SymRange(Main.range("ctor"))),
- AllOf(WithName("~Bar"), WithKind(SymbolKind::Constructor),
- WithDetail(""), SymRange(Main.range("dtor"))),
- AllOf(WithName("Baz"), WithKind(SymbolKind::Field),
- WithDetail("unsigned int"),
- SymRange(Main.range("field"))),
- AllOf(WithName("getBaz"), WithKind(SymbolKind::Method),
- WithDetail("unsigned int ()"),
- SymRange(Main.range("getbaz"))))))),
- AllOf(WithName("ForwardClassDecl"), WithKind(SymbolKind::Class),
- WithDetail("class"), SymRange(Main.range("forwardclass"))),
- AllOf(WithName("StructDefinition"), WithKind(SymbolKind::Struct),
- WithDetail("struct"), SymRange(Main.range("struct")),
- Children(AllOf(WithName("Pointer"), WithKind(SymbolKind::Field),
- WithDetail("int *"),
- SymRange(Main.range("structfield"))))),
- AllOf(WithName("StructDeclaration"), WithKind(SymbolKind::Struct),
- WithDetail("struct"), SymRange(Main.range("forwardstruct"))),
- AllOf(WithName("forwardFunctionDecl"), WithKind(SymbolKind::Function),
- WithDetail("void (int)"),
- SymRange(Main.range("forwardfunc")))));
+ withName("ns"), withKind(SymbolKind::Namespace),
+ symRange(Main.range("ns")),
+ children(AllOf(
+ withName("Bar"), withKind(SymbolKind::Class),
+ withDetail("class"), symRange(Main.range("bar")),
+ children(
+ AllOf(withName("Bar"), withKind(SymbolKind::Constructor),
+ withDetail("()"), symRange(Main.range("ctor"))),
+ AllOf(withName("~Bar"), withKind(SymbolKind::Constructor),
+ withDetail(""), symRange(Main.range("dtor"))),
+ AllOf(withName("Baz"), withKind(SymbolKind::Field),
+ withDetail("unsigned int"),
+ symRange(Main.range("field"))),
+ AllOf(withName("getBaz"), withKind(SymbolKind::Method),
+ withDetail("unsigned int ()"),
+ symRange(Main.range("getbaz"))))))),
+ AllOf(withName("ForwardClassDecl"), withKind(SymbolKind::Class),
+ withDetail("class"), symRange(Main.range("forwardclass"))),
+ AllOf(withName("StructDefinition"), withKind(SymbolKind::Struct),
+ withDetail("struct"), symRange(Main.range("struct")),
+ children(AllOf(withName("Pointer"), withKind(SymbolKind::Field),
+ withDetail("int *"),
+ symRange(Main.range("structfield"))))),
+ AllOf(withName("StructDeclaration"), withKind(SymbolKind::Struct),
+ withDetail("struct"), symRange(Main.range("forwardstruct"))),
+ AllOf(withName("forwardFunctionDecl"), withKind(SymbolKind::Function),
+ withDetail("void (int)"),
+ symRange(Main.range("forwardfunc")))));
}
TEST(DocumentSymbolsTest, DependentType) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("plus"),
- WithDetail("template auto (T, T) -> decltype(x + y)")),
- AllOf(WithName("Pair"), WithDetail("template class")),
- AllOf(WithName("Context"), WithDetail("template struct"),
- Children(AllOf(
- WithName("Pair<type-parameter-0-0, type-parameter-0-1>"),
- WithDetail("<dependent type>"))))));
+ AllOf(withName("plus"),
+ withDetail("template auto (T, T) -> decltype(x + y)")),
+ AllOf(withName("Pair"), withDetail("template class")),
+ AllOf(withName("Context"), withDetail("template struct"),
+ children(AllOf(
+ withName("Pair<type-parameter-0-0, type-parameter-0-1>"),
+ withDetail("<dependent type>"))))));
}
TEST(DocumentSymbolsTest, ObjCCategoriesAndClassExtensions) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("Cat"), SymRange(Main.range("Cat")),
- Children(AllOf(WithName("+sharedCat"),
- WithKind(SymbolKind::Method)))),
- AllOf(WithName("Cat(Sneaky)"), SymRange(Main.range("SneakyCat")),
- Children(
- AllOf(WithName("-sneak:"), WithKind(SymbolKind::Method)))),
+ AllOf(withName("Cat"), symRange(Main.range("Cat")),
+ children(AllOf(withName("+sharedCat"),
+ withKind(SymbolKind::Method)))),
+ AllOf(withName("Cat(Sneaky)"), symRange(Main.range("SneakyCat")),
+ children(
+ AllOf(withName("-sneak:"), withKind(SymbolKind::Method)))),
AllOf(
- WithName("Cat()"), SymRange(Main.range("MeowCat")),
- Children(AllOf(WithName("-meow"), WithKind(SymbolKind::Method)))),
- AllOf(WithName("Cat()"), SymRange(Main.range("PurCat")),
- Children(
- AllOf(WithName("-pur"), WithKind(SymbolKind::Method))))));
+ withName("Cat()"), symRange(Main.range("MeowCat")),
+ children(AllOf(withName("-meow"), withKind(SymbolKind::Method)))),
+ AllOf(withName("Cat()"), symRange(Main.range("PurCat")),
+ children(
+ AllOf(withName("-pur"), withKind(SymbolKind::Method))))));
}
TEST(DocumentSymbolsTest, PragmaMarkGroups) {
EXPECT_THAT(
getSymbols(TU.build()),
UnorderedElementsAre(
- AllOf(WithName("Dog"), SymRange(Main.range("DogDef"))),
- AllOf(WithName("Dog"), SymRange(Main.range("DogImpl")),
- Children(AllOf(WithName("+sharedDoggo"),
- WithKind(SymbolKind::Method)),
- AllOf(WithName("Overrides"),
- SymRange(Main.range("Overrides")),
- Children(AllOf(WithName("-init"),
- WithKind(SymbolKind::Method)),
- AllOf(WithName("-bark"),
- WithKind(SymbolKind::Method)))),
- AllOf(WithName("Dog Specifics"),
- SymRange(Main.range("Specifics")),
- Children(AllOf(WithName("-isAGoodBoy"),
- WithKind(SymbolKind::Method)))))),
- AllOf(WithName("End"), SymRange(Main.range("End")))));
+ AllOf(withName("Dog"), symRange(Main.range("DogDef"))),
+ AllOf(withName("Dog"), symRange(Main.range("DogImpl")),
+ children(AllOf(withName("+sharedDoggo"),
+ withKind(SymbolKind::Method)),
+ AllOf(withName("Overrides"),
+ symRange(Main.range("Overrides")),
+ children(AllOf(withName("-init"),
+ withKind(SymbolKind::Method)),
+ AllOf(withName("-bark"),
+ withKind(SymbolKind::Method)))),
+ AllOf(withName("Dog Specifics"),
+ symRange(Main.range("Specifics")),
+ children(AllOf(withName("-isAGoodBoy"),
+ withKind(SymbolKind::Method)))))),
+ AllOf(withName("End"), symRange(Main.range("End")))));
}
TEST(DocumentSymbolsTest, PragmaMarkGroupsNesting) {
EXPECT_THAT(
getSymbols(TU.build()),
UnorderedElementsAre(AllOf(
- WithName("Foo"),
- Children(AllOf(WithName("Foo"),
- Children(AllOf(WithName("Bar"),
- Children(AllOf(WithName("bar"),
- Children(WithName(
+ withName("Foo"),
+ children(AllOf(withName("Foo"),
+ children(AllOf(withName("Bar"),
+ children(AllOf(withName("bar"),
+ children(withName(
"NotTopDecl"))))))),
- WithName("bar")))));
+ withName("bar")))));
}
TEST(DocumentSymbolsTest, PragmaMarkGroupsNoNesting) {
)cpp");
TU.Code = Main.code().str();
EXPECT_THAT(getSymbols(TU.build()),
- UnorderedElementsAre(WithName("Helpers"), WithName("helpA"),
- WithName("(unnamed group)"),
- WithName("Core"), WithName("coreMethod")));
+ UnorderedElementsAre(withName("Helpers"), withName("helpA"),
+ withName("(unnamed group)"),
+ withName("Core"), withName("coreMethod")));
}
} // namespace
EXPECT_FALSE(PathResult.hasValue());
}
-MATCHER_P(DeclNamed, Name, "") {
+MATCHER_P(declNamed, Name, "") {
if (const NamedDecl *ND = dyn_cast<NamedDecl>(arg))
if (ND->getQualifiedNameAsString() == Name)
return true;
auto AST = TU.build();
EXPECT_THAT(getIndexableLocalDecls(AST),
testing::UnorderedElementsAre(
- DeclNamed("MainF1"), DeclNamed("Foo"), DeclNamed("ns::Foo"),
- DeclNamed("ns::Foo::method"), DeclNamed("ns::Foo::field")));
+ declNamed("MainF1"), declNamed("Foo"), declNamed("ns::Foo"),
+ declNamed("ns::Foo::method"), declNamed("ns::Foo::field")));
}
TEST(HeaderSourceSwitchTest, FromHeaderToSource) {
std::unique_ptr<CompilerInstance> Clang;
};
-MATCHER_P(Written, Name, "") { return arg.Written == Name; }
-MATCHER_P(Resolved, Name, "") { return arg.Resolved == Name; }
-MATCHER_P(IncludeLine, N, "") { return arg.HashLine == N; }
-MATCHER_P(Directive, D, "") { return arg.Directive == D; }
-MATCHER_P(HasPragmaKeep, H, "") { return arg.BehindPragmaKeep == H; }
+MATCHER_P(written, Name, "") { return arg.Written == Name; }
+MATCHER_P(resolved, Name, "") { return arg.Resolved == Name; }
+MATCHER_P(includeLine, N, "") { return arg.HashLine == N; }
+MATCHER_P(directive, D, "") { return arg.Directive == D; }
+MATCHER_P(hasPragmaKeep, H, "") { return arg.BehindPragmaKeep == H; }
MATCHER_P2(Distance, File, D, "") {
if (arg.getFirst() != File)
auto Includes = collectIncludes();
EXPECT_THAT(Includes.MainFileIncludes,
UnorderedElementsAre(
- AllOf(Written("\"sub/bar.h\""), Resolved(BarHeader))));
+ AllOf(written("\"sub/bar.h\""), resolved(BarHeader))));
EXPECT_THAT(Includes.includeDepth(getID(MainFile, Includes)),
UnorderedElementsAre(Distance(getID(MainFile, Includes), 0u),
Distance(getID(BarHeader, Includes), 1u)));
auto Includes = collectIncludes();
EXPECT_THAT(
Includes.MainFileIncludes,
- UnorderedElementsAre(AllOf(Written("\"bar.h\""), Resolved(BarHeader))));
+ UnorderedElementsAre(AllOf(written("\"bar.h\""), resolved(BarHeader))));
EXPECT_THAT(Includes.includeDepth(getID(MainFile, Includes)),
UnorderedElementsAre(Distance(getID(MainFile, Includes), 0u),
Distance(getID(BarHeader, Includes), 1u),
)cpp");
TU.HeaderFilename = "a.h"; // suppress "not found".
EXPECT_THAT(TU.build().getIncludeStructure().MainFileIncludes,
- ElementsAre(IncludeLine(1), IncludeLine(3), IncludeLine(5)));
+ ElementsAre(includeLine(1), includeLine(3), includeLine(5)));
}
TEST_F(HeadersTest, UnResolvedInclusion) {
)cpp";
EXPECT_THAT(collectIncludes().MainFileIncludes,
- UnorderedElementsAre(AllOf(Written("\"foo.h\""), Resolved(""))));
+ UnorderedElementsAre(AllOf(written("\"foo.h\""), resolved(""))));
EXPECT_THAT(collectIncludes().IncludeChildren, IsEmpty());
}
// ms-compatibility changes meaning of #import, make sure it is turned off.
CDB.ExtraClangFlags.push_back("-fno-ms-compatibility");
EXPECT_THAT(collectIncludes().MainFileIncludes,
- UnorderedElementsAre(Directive(tok::pp_include),
- Directive(tok::pp_import),
- Directive(tok::pp_include_next)));
+ UnorderedElementsAre(directive(tok::pp_include),
+ directive(tok::pp_import),
+ directive(tok::pp_include_next)));
}
TEST_F(HeadersTest, IWYUPragmaKeep) {
EXPECT_THAT(
collectIncludes().MainFileIncludes,
- UnorderedElementsAre(AllOf(Written("\"foo.h\""), HasPragmaKeep(false)),
- AllOf(Written("\"bar.h\""), HasPragmaKeep(true))));
+ UnorderedElementsAre(AllOf(written("\"foo.h\""), hasPragmaKeep(false)),
+ AllOf(written("\"bar.h\""), hasPragmaKeep(true))));
}
TEST_F(HeadersTest, InsertInclude) {
// Including through non-builtin file has no effects.
FS.Files[MainFile] = "#include \"__preamble_patch__.h\"\n\n";
EXPECT_THAT(collectIncludes().MainFileIncludes,
- Not(Contains(Written("<a.h>"))));
+ Not(Contains(written("<a.h>"))));
// Now include through built-in file.
CDB.ExtraClangFlags = {"-include", testPath(HeaderFile)};
EXPECT_THAT(collectIncludes().MainFileIncludes,
- Contains(AllOf(IncludeLine(2), Written("<a.h>"))));
+ Contains(AllOf(includeLine(2), written("<a.h>"))));
}
TEST_F(HeadersTest, SelfContainedHeaders) {
)cpp");
auto AST = TU.build();
- auto &vector_nonstd = findDecl(AST, "vector");
- auto *vec =
+ auto &VectorNonstd = findDecl(AST, "vector");
+ auto *Vec =
cast<VarDecl>(findDecl(AST, "vec")).getType()->getAsCXXRecordDecl();
- auto *nest =
+ auto *Nest =
cast<VarDecl>(findDecl(AST, "nest")).getType()->getAsCXXRecordDecl();
- auto *sec =
+ auto *Sec =
cast<VarDecl>(findDecl(AST, "sec")).getType()->getAsCXXRecordDecl();
- stdlib::Recognizer recognizer;
+ stdlib::Recognizer Recognizer;
- EXPECT_EQ(recognizer(&vector_nonstd), llvm::None);
- EXPECT_EQ(recognizer(vec), stdlib::Symbol::named("std::", "vector"));
- EXPECT_EQ(recognizer(nest), stdlib::Symbol::named("std::", "vector"));
- EXPECT_EQ(recognizer(sec), llvm::None);
+ EXPECT_EQ(Recognizer(&VectorNonstd), llvm::None);
+ EXPECT_EQ(Recognizer(Vec), stdlib::Symbol::named("std::", "vector"));
+ EXPECT_EQ(Recognizer(Nest), stdlib::Symbol::named("std::", "vector"));
+ EXPECT_EQ(Recognizer(Sec), llvm::None);
}
} // namespace
}
}
-MATCHER_P(WrittenInclusion, Written, "") {
+MATCHER_P(writtenInclusion, Written, "") {
if (arg.Written != Written)
*result_listener << arg.Written;
return arg.Written == Written;
auto AST = TU.build();
auto Unused = computeUnusedIncludes(AST);
- EXPECT_THAT(Unused, ElementsAre(Pointee(WrittenInclusion("<queue>"))));
+ EXPECT_THAT(Unused, ElementsAre(Pointee(writtenInclusion("<queue>"))));
}
TEST(IncludeCleaner, GetUnusedHeaders) {
std::string toUri(llvm::StringRef Path) { return URI::create(Path).toString(); }
-MATCHER(IsTU, "") { return arg.Flags & IncludeGraphNode::SourceFlag::IsTU; }
+MATCHER(isTU, "") { return arg.Flags & IncludeGraphNode::SourceFlag::IsTU; }
-MATCHER_P(HasDigest, Digest, "") { return arg.Digest == Digest; }
+MATCHER_P(hasDigest, Digest, "") { return arg.Digest == Digest; }
-MATCHER_P(HasName, Name, "") { return arg.Name == Name; }
+MATCHER_P(hasName, Name, "") { return arg.Name == Name; }
-MATCHER(HasSameURI, "") {
+MATCHER(hasSameURI, "") {
llvm::StringRef URI = ::testing::get<0>(arg);
const std::string &Path = ::testing::get<1>(arg);
return toUri(Path) == URI;
}
::testing::Matcher<const IncludeGraphNode &>
-IncludesAre(const std::vector<std::string> &Includes) {
+includesAre(const std::vector<std::string> &Includes) {
return ::testing::Field(&IncludeGraphNode::DirectIncludes,
- UnorderedPointwise(HasSameURI(), Includes));
+ UnorderedPointwise(hasSameURI(), Includes));
}
void checkNodesAreInitialized(const IndexFileIn &IndexFile,
EXPECT_THAT(Nodes,
UnorderedElementsAre(
Pair(toUri(MainFilePath),
- AllOf(IsTU(), IncludesAre({Level1HeaderPath}),
- HasDigest(digest(MainCode)))),
+ AllOf(isTU(), includesAre({Level1HeaderPath}),
+ hasDigest(digest(MainCode)))),
Pair(toUri(Level1HeaderPath),
- AllOf(Not(IsTU()), IncludesAre({Level2HeaderPath}),
- HasDigest(digest(Level1HeaderCode)))),
+ AllOf(Not(isTU()), includesAre({Level2HeaderPath}),
+ hasDigest(digest(Level1HeaderCode)))),
Pair(toUri(Level2HeaderPath),
- AllOf(Not(IsTU()), IncludesAre({}),
- HasDigest(digest(Level2HeaderCode))))));
+ AllOf(Not(isTU()), includesAre({}),
+ hasDigest(digest(Level2HeaderCode))))));
}
TEST_F(IndexActionTest, IncludeGraphSelfInclude) {
EXPECT_THAT(
Nodes,
UnorderedElementsAre(
- Pair(toUri(MainFilePath), AllOf(IsTU(), IncludesAre({HeaderPath}),
- HasDigest(digest(MainCode)))),
- Pair(toUri(HeaderPath), AllOf(Not(IsTU()), IncludesAre({HeaderPath}),
- HasDigest(digest(HeaderCode))))));
+ Pair(toUri(MainFilePath), AllOf(isTU(), includesAre({HeaderPath}),
+ hasDigest(digest(MainCode)))),
+ Pair(toUri(HeaderPath), AllOf(Not(isTU()), includesAre({HeaderPath}),
+ hasDigest(digest(HeaderCode))))));
}
TEST_F(IndexActionTest, IncludeGraphSkippedFile) {
EXPECT_THAT(
Nodes, UnorderedElementsAre(
Pair(toUri(MainFilePath),
- AllOf(IsTU(), IncludesAre({HeaderPath, CommonHeaderPath}),
- HasDigest(digest(MainCode)))),
+ AllOf(isTU(), includesAre({HeaderPath, CommonHeaderPath}),
+ hasDigest(digest(MainCode)))),
Pair(toUri(HeaderPath),
- AllOf(Not(IsTU()), IncludesAre({CommonHeaderPath}),
- HasDigest(digest(HeaderCode)))),
+ AllOf(Not(isTU()), includesAre({CommonHeaderPath}),
+ hasDigest(digest(HeaderCode)))),
Pair(toUri(CommonHeaderPath),
- AllOf(Not(IsTU()), IncludesAre({}),
- HasDigest(digest(CommonHeaderCode))))));
+ AllOf(Not(isTU()), includesAre({}),
+ hasDigest(digest(CommonHeaderCode))))));
}
TEST_F(IndexActionTest, IncludeGraphDynamicInclude) {
Nodes,
UnorderedElementsAre(
Pair(toUri(MainFilePath),
- AllOf(IsTU(), IncludesAre({MainFilePath, HeaderPath}),
- HasDigest(digest(MainCode)))),
- Pair(toUri(HeaderPath), AllOf(Not(IsTU()), IncludesAre({}),
- HasDigest(digest(HeaderCode))))));
+ AllOf(isTU(), includesAre({MainFilePath, HeaderPath}),
+ hasDigest(digest(MainCode)))),
+ Pair(toUri(HeaderPath), AllOf(Not(isTU()), includesAre({}),
+ hasDigest(digest(HeaderCode))))));
}
TEST_F(IndexActionTest, NoWarnings) {
MainFilePath, {"-ferror-limit=1", "-Wparentheses", "-Werror"});
ASSERT_TRUE(IndexFile.Sources);
ASSERT_NE(0u, IndexFile.Sources->size());
- EXPECT_THAT(*IndexFile.Symbols, ElementsAre(HasName("foo"), HasName("bar")));
+ EXPECT_THAT(*IndexFile.Symbols, ElementsAre(hasName("foo"), hasName("bar")));
}
TEST_F(IndexActionTest, SkipFiles) {
};
IndexFileIn IndexFile = runIndexingAction(MainFilePath, {"-std=c++14"});
EXPECT_THAT(*IndexFile.Symbols,
- UnorderedElementsAre(HasName("S"), HasName("s"), HasName("f1"),
- HasName("unskippable1")));
+ UnorderedElementsAre(hasName("S"), hasName("s"), hasName("f1"),
+ hasName("unskippable1")));
for (const auto &Pair : *IndexFile.Refs)
for (const auto &Ref : Pair.second)
EXPECT_THAT(Ref.Location.FileURI, EndsWith("good.h"));
}
})cpp");
IndexFileIn IndexFile = runIndexingAction(MainFilePath, {"-std=c++14"});
- EXPECT_THAT(*IndexFile.Symbols, testing::Contains(HasName("foo")));
- EXPECT_THAT(*IndexFile.Symbols, testing::Contains(HasName("Bar")));
- EXPECT_THAT(*IndexFile.Symbols, Not(testing::Contains(HasName("Baz"))));
+ EXPECT_THAT(*IndexFile.Symbols, testing::Contains(hasName("foo")));
+ EXPECT_THAT(*IndexFile.Symbols, testing::Contains(hasName("Bar")));
+ EXPECT_THAT(*IndexFile.Symbols, Not(testing::Contains(hasName("Baz"))));
}
} // namespace
} // namespace clangd
namespace clangd {
namespace {
-MATCHER_P(Named, N, "") { return arg.Name == N; }
-MATCHER_P(RefRange, Range, "") {
+MATCHER_P(named, N, "") { return arg.Name == N; }
+MATCHER_P(refRange, Range, "") {
return std::make_tuple(arg.Location.Start.line(), arg.Location.Start.column(),
arg.Location.End.line(), arg.Location.End.column()) ==
std::make_tuple(Range.start.line, Range.start.character,
Range.end.line, Range.end.character);
}
-MATCHER_P(FileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
+MATCHER_P(fileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
TEST(SymbolLocation, Position) {
using Position = SymbolLocation::Position;
B.insert(symbol("X"));
EXPECT_EQ(nullptr, B.find(SymbolID("W")));
for (const char *Sym : {"X", "Y", "Z"})
- EXPECT_THAT(B.find(SymbolID(Sym)), Pointee(Named(Sym)));
+ EXPECT_THAT(B.find(SymbolID(Sym)), Pointee(named(Sym)));
SymbolSlab S = std::move(B).build();
- EXPECT_THAT(S, UnorderedElementsAre(Named("X"), Named("Y"), Named("Z")));
+ EXPECT_THAT(S, UnorderedElementsAre(named("X"), named("Y"), named("Z")));
EXPECT_EQ(S.end(), S.find(SymbolID("W")));
for (const char *Sym : {"X", "Y", "Z"})
- EXPECT_THAT(*S.find(SymbolID(Sym)), Named(Sym));
+ EXPECT_THAT(*S.find(SymbolID(Sym)), named(Sym));
}
TEST(RelationSlab, Lookup) {
EXPECT_THAT(
std::move(Results).build(),
ElementsAre(Pair(
- _, UnorderedElementsAre(AllOf(RefRange(Test1Code.range("Foo")),
- FileURI("unittest:///test.cc")),
- AllOf(RefRange(Test2Code.range("Foo")),
- FileURI("unittest:///test2.cc"))))));
+ _, UnorderedElementsAre(AllOf(refRange(Test1Code.range("Foo")),
+ fileURI("unittest:///test.cc")),
+ AllOf(refRange(Test2Code.range("Foo")),
+ fileURI("unittest:///test2.cc"))))));
Request.Limit = 1;
RefSlab::Builder Results2;
Merge.refs(Request, [&](const Ref &O) { Results3.insert(Foo.ID, O); }));
EXPECT_THAT(std::move(Results3).build(),
ElementsAre(Pair(_, UnorderedElementsAre(AllOf(
- RefRange(Test2Code.range("Foo")),
- FileURI("unittest:///test2.cc"))))));
+ refRange(Test2Code.range("Foo")),
+ fileURI("unittest:///test2.cc"))))));
}
TEST(MergeIndexTest, IndexedFiles) {
std::string input() const { return InBuf; }
std::string output() { return Out.str(); }
- std::string input_mirror() { return Mirror.str(); }
+ std::string inputMirror() { return Mirror.str(); }
};
// Echo is a simple server running on a transport:
"Content-Length: 77\r\n\r\n"
R"({"error":{"code":88,"message":"trouble at mill"},"id":"wxyz","jsonrpc":"2.0"})";
EXPECT_EQ(output(), WantOutput);
- EXPECT_EQ(trim(input_mirror()), trim(input()));
+ EXPECT_EQ(trim(inputMirror()), trim(input()));
}
// Runs an Echo session using the "delimited" input and pretty-printed output
"jsonrpc": "2.0"
})";
EXPECT_EQ(output(), WantOutput);
- EXPECT_EQ(trim(input_mirror()), trim(input()));
+ EXPECT_EQ(trim(inputMirror()), trim(input()));
}
// IO errors such as EOF ane reported.
EXPECT_EQ(trim(E.log()), "Notification call: 1234");
EXPECT_TRUE(bool(Err)); // Ran into EOF with no handler signalling done.
consumeError(std::move(Err));
- EXPECT_EQ(trim(input_mirror()), trim(input()));
+ EXPECT_EQ(trim(inputMirror()), trim(input()));
}
#endif
using ::testing::IsEmpty;
using ::testing::UnorderedElementsAreArray;
-MATCHER_P(DeclNamed, Name, "") {
+MATCHER_P(declNamed, Name, "") {
if (NamedDecl *ND = dyn_cast<NamedDecl>(arg))
if (ND->getName() == Name)
return true;
return false;
}
-MATCHER_P(DeclKind, Kind, "") {
+MATCHER_P(declKind, Kind, "") {
if (NamedDecl *ND = dyn_cast<NamedDecl>(arg))
if (ND->getDeclKindName() == llvm::StringRef(Kind))
return true;
// Matches if the Decl has template args equal to ArgName. If the decl is a
// NamedDecl and ArgName is an empty string it also matches.
-MATCHER_P(WithTemplateArgs, ArgName, "") {
+MATCHER_P(withTemplateArgs, ArgName, "") {
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(arg)) {
if (const auto *Args = FD->getTemplateSpecializationArgs()) {
std::string SpecializationArgs;
return false;
}
-MATCHER_P(RangeIs, R, "") {
+MATCHER_P(rangeIs, R, "") {
return arg.beginOffset() == R.Begin && arg.endOffset() == R.End;
}
-MATCHER_P(PragmaTrivia, P, "") { return arg.Trivia == P; }
+MATCHER_P(pragmaTrivia, P, "") { return arg.Trivia == P; }
-MATCHER(EqInc, "") {
+MATCHER(eqInc, "") {
Inclusion Actual = testing::get<0>(arg);
Inclusion Expected = testing::get<1>(arg);
return std::tie(Actual.HashLine, Actual.Written) ==
auto AST = TU.build();
EXPECT_THAT(AST.getLocalTopLevelDecls(),
testing::UnorderedElementsAreArray(
- {AllOf(DeclNamed("main"), DeclKind("Function")),
- AllOf(DeclNamed("X"), DeclKind("VarTemplate"))}));
+ {AllOf(declNamed("main"), declKind("Function")),
+ AllOf(declNamed("X"), declKind("VarTemplate"))}));
}
TEST(ParsedASTTest, DoesNotGetIncludedTopDecls) {
}
)cpp";
auto AST = TU.build();
- EXPECT_THAT(AST.getLocalTopLevelDecls(), ElementsAre(DeclNamed("main")));
+ EXPECT_THAT(AST.getLocalTopLevelDecls(), ElementsAre(declNamed("main")));
}
TEST(ParsedASTTest, DoesNotGetImplicitTemplateTopDecls) {
auto AST = TU.build();
EXPECT_THAT(AST.getLocalTopLevelDecls(),
- ElementsAre(DeclNamed("f"), DeclNamed("s")));
+ ElementsAre(declNamed("f"), declNamed("s")));
}
TEST(ParsedASTTest,
auto AST = TU.build();
EXPECT_THAT(
AST.getLocalTopLevelDecls(),
- ElementsAreArray({AllOf(DeclNamed("f"), WithTemplateArgs("")),
- AllOf(DeclNamed("f"), WithTemplateArgs("<bool>")),
- AllOf(DeclNamed("f"), WithTemplateArgs("<double>")),
- AllOf(DeclNamed("V"), WithTemplateArgs("")),
- AllOf(DeclNamed("V"), WithTemplateArgs("<T *>")),
- AllOf(DeclNamed("V"), WithTemplateArgs("<bool>")),
- AllOf(DeclNamed("foo"), WithTemplateArgs("")),
- AllOf(DeclNamed("i"), WithTemplateArgs("")),
- AllOf(DeclNamed("d"), WithTemplateArgs("")),
- AllOf(DeclNamed("foo"), WithTemplateArgs("<T *>")),
- AllOf(DeclNamed("foo"), WithTemplateArgs("<bool>"))}));
+ ElementsAreArray({AllOf(declNamed("f"), withTemplateArgs("")),
+ AllOf(declNamed("f"), withTemplateArgs("<bool>")),
+ AllOf(declNamed("f"), withTemplateArgs("<double>")),
+ AllOf(declNamed("V"), withTemplateArgs("")),
+ AllOf(declNamed("V"), withTemplateArgs("<T *>")),
+ AllOf(declNamed("V"), withTemplateArgs("<bool>")),
+ AllOf(declNamed("foo"), withTemplateArgs("")),
+ AllOf(declNamed("i"), withTemplateArgs("")),
+ AllOf(declNamed("d"), withTemplateArgs("")),
+ AllOf(declNamed("foo"), withTemplateArgs("<T *>")),
+ AllOf(declNamed("foo"), withTemplateArgs("<bool>"))}));
}
TEST(ParsedASTTest, IgnoresDelayedTemplateParsing) {
testing::UnorderedElementsAreArray(TestCase.points()));
}
-MATCHER_P(WithFileName, Inc, "") { return arg.FileName == Inc; }
+MATCHER_P(withFileName, Inc, "") { return arg.FileName == Inc; }
TEST(ParsedASTTest, ReplayPreambleForTidyCheckers) {
struct Inclusion {
EXPECT_EQ(Inc.HashOffset, HashLocs[I]);
auto IncRange = IncludeRanges[I];
- EXPECT_THAT(Inc.IncTok.range(SM), RangeIs(IncRange));
+ EXPECT_THAT(Inc.IncTok.range(SM), rangeIs(IncRange));
EXPECT_EQ(Inc.IncTok.kind(), tok::identifier);
EXPECT_EQ(Inc.IncDirective,
Code.substr(IncRange.Begin, IncRange.End - IncRange.Begin));
// Ensure source location information is correct, including resolved paths.
EXPECT_THAT(PatchedAST->getIncludeStructure().MainFileIncludes,
testing::Pointwise(
- EqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
+ eqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
// Ensure file proximity signals are correct.
auto &SM = PatchedAST->getSourceManager();
auto &FM = SM.getFileManager();
// Ensure source location information is correct.
EXPECT_THAT(PatchedAST->getIncludeStructure().MainFileIncludes,
testing::Pointwise(
- EqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
+ eqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
// Ensure file proximity signals are correct.
auto &SM = ExpectedAST.getSourceManager();
auto &FM = SM.getFileManager();
.isFileMultipleIncludeGuarded(MainFE);
}
-MATCHER_P(Diag, Desc, "") {
+MATCHER_P(diag, Desc, "") {
return llvm::StringRef(arg.Message).contains(Desc);
}
)cpp";
auto AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_FALSE(mainIsGuarded(AST));
TU.Code = R"cpp(
#include "self.h" // error-ok
)cpp";
AST = TU.build();
- EXPECT_THAT(*AST.getDiagnostics(), ElementsAre(Diag("nested too deeply")));
+ EXPECT_THAT(*AST.getDiagnostics(), ElementsAre(diag("nested too deeply")));
EXPECT_FALSE(mainIsGuarded(AST));
TU.Code = R"cpp(
)cpp";
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_TRUE(mainIsGuarded(AST));
TU.Code = R"cpp(
)cpp";
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_FALSE(mainIsGuarded(AST));
TU.Code = R"cpp(
)cpp";
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_FALSE(mainIsGuarded(AST));
TU.Code = R"cpp(
)cpp";
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_TRUE(mainIsGuarded(AST));
TU.Code = R"cpp(
)cpp";
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_TRUE(mainIsGuarded(AST));
}
// The diagnostic is unfortunate in this case, but correct per our model.
// Ultimately the include is skipped and the code is parsed correctly though.
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("in included file: main file cannot be included "
+ ElementsAre(diag("in included file: main file cannot be included "
"recursively when building a preamble")));
EXPECT_FALSE(mainIsGuarded(AST));
// Interface is pragma once guarded, same thing.
TU.AdditionalFiles = {{"iface.h", once(Interface)}};
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("in included file: main file cannot be included "
+ ElementsAre(diag("in included file: main file cannot be included "
"recursively when building a preamble")));
EXPECT_FALSE(mainIsGuarded(AST));
}
)cpp";
auto AST = TU.build();
- EXPECT_THAT(AST.getMarks(), ElementsAre(PragmaTrivia(" In Preamble"),
- PragmaTrivia(" - Something Impl"),
- PragmaTrivia(" End")));
+ EXPECT_THAT(AST.getMarks(), ElementsAre(pragmaTrivia(" In Preamble"),
+ pragmaTrivia(" - Something Impl"),
+ pragmaTrivia(" End")));
}
} // namespace
EXPECT_FLOAT_EQ(Relevance.SemaFileProximityScore, 1.0f)
<< "Current file and header";
- auto constructShadowDeclCompletionResult = [&](const std::string DeclName) {
+ auto ConstructShadowDeclCompletionResult = [&](const std::string DeclName) {
auto *Shadow =
*dyn_cast<UsingDecl>(&findDecl(AST, [&](const NamedDecl &ND) {
if (const UsingDecl *Using = dyn_cast<UsingDecl>(&ND))
};
Relevance = {};
- Relevance.merge(constructShadowDeclCompletionResult("Bar"));
+ Relevance.merge(ConstructShadowDeclCompletionResult("Bar"));
EXPECT_FLOAT_EQ(Relevance.SemaFileProximityScore, 1.0f)
<< "Using declaration in main file";
- Relevance.merge(constructShadowDeclCompletionResult("FLAGS_FOO"));
+ Relevance.merge(ConstructShadowDeclCompletionResult("FLAGS_FOO"));
EXPECT_FLOAT_EQ(Relevance.SemaFileProximityScore, 1.0f)
<< "Using declaration in main file";
...
)";
-MATCHER_P(ID, I, "") { return arg.ID == cantFail(SymbolID::fromStr(I)); }
-MATCHER_P(QName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
+MATCHER_P(id, I, "") { return arg.ID == cantFail(SymbolID::fromStr(I)); }
+MATCHER_P(qName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
MATCHER_P2(IncludeHeaderWithRef, IncludeHeader, References, "") {
return (arg.IncludeHeader == IncludeHeader) && (arg.References == References);
}
ASSERT_TRUE(bool(ParsedYAML->Symbols));
EXPECT_THAT(
*ParsedYAML->Symbols,
- UnorderedElementsAre(ID("057557CEBF6E6B2D"), ID("057557CEBF6E6B2E")));
+ UnorderedElementsAre(id("057557CEBF6E6B2D"), id("057557CEBF6E6B2E")));
auto Sym1 = *ParsedYAML->Symbols->find(
cantFail(SymbolID::fromStr("057557CEBF6E6B2D")));
auto Sym2 = *ParsedYAML->Symbols->find(
cantFail(SymbolID::fromStr("057557CEBF6E6B2E")));
- EXPECT_THAT(Sym1, QName("clang::Foo1"));
+ EXPECT_THAT(Sym1, qName("clang::Foo1"));
EXPECT_EQ(Sym1.Signature, "");
EXPECT_EQ(Sym1.Documentation, "Foo doc");
EXPECT_EQ(Sym1.ReturnType, "int");
UnorderedElementsAre(IncludeHeaderWithRef("include1", 7u),
IncludeHeaderWithRef("include2", 3u)));
- EXPECT_THAT(Sym2, QName("clang::Foo2"));
+ EXPECT_THAT(Sym2, qName("clang::Foo2"));
EXPECT_EQ(Sym2.Signature, "-sig");
EXPECT_EQ(Sym2.ReturnType, "");
EXPECT_EQ(llvm::StringRef(Sym2.CanonicalDeclaration.FileURI),
EXPECT_EQ(IGNDeserialized.Flags, IncludeGraphNode::SourceFlag(1));
}
-std::vector<std::string> YAMLFromSymbols(const SymbolSlab &Slab) {
+std::vector<std::string> yamlFromSymbols(const SymbolSlab &Slab) {
std::vector<std::string> Result;
for (const auto &Sym : Slab)
Result.push_back(toYAML(Sym));
return Result;
}
-std::vector<std::string> YAMLFromRefs(const RefSlab &Slab) {
+std::vector<std::string> yamlFromRefs(const RefSlab &Slab) {
std::vector<std::string> Result;
for (const auto &Refs : Slab)
Result.push_back(toYAML(Refs));
return Result;
}
-std::vector<std::string> YAMLFromRelations(const RelationSlab &Slab) {
+std::vector<std::string> yamlFromRelations(const RelationSlab &Slab) {
std::vector<std::string> Result;
for (const auto &Rel : Slab)
Result.push_back(toYAML(Rel));
ASSERT_TRUE(In2->Relations);
// Assert the YAML serializations match, for nice comparisons and diffs.
- EXPECT_THAT(YAMLFromSymbols(*In2->Symbols),
- UnorderedElementsAreArray(YAMLFromSymbols(*In->Symbols)));
- EXPECT_THAT(YAMLFromRefs(*In2->Refs),
- UnorderedElementsAreArray(YAMLFromRefs(*In->Refs)));
- EXPECT_THAT(YAMLFromRelations(*In2->Relations),
- UnorderedElementsAreArray(YAMLFromRelations(*In->Relations)));
+ EXPECT_THAT(yamlFromSymbols(*In2->Symbols),
+ UnorderedElementsAreArray(yamlFromSymbols(*In->Symbols)));
+ EXPECT_THAT(yamlFromRefs(*In2->Refs),
+ UnorderedElementsAreArray(yamlFromRefs(*In->Refs)));
+ EXPECT_THAT(yamlFromRelations(*In2->Relations),
+ UnorderedElementsAreArray(yamlFromRelations(*In->Relations)));
}
TEST(SerializationTest, SrcsTest) {
ASSERT_TRUE(In->Sources);
ASSERT_TRUE(In->Sources->count(IGN.URI));
// Assert the YAML serializations match, for nice comparisons and diffs.
- EXPECT_THAT(YAMLFromSymbols(*In->Symbols),
- UnorderedElementsAreArray(YAMLFromSymbols(*In->Symbols)));
- EXPECT_THAT(YAMLFromRefs(*In->Refs),
- UnorderedElementsAreArray(YAMLFromRefs(*In->Refs)));
+ EXPECT_THAT(yamlFromSymbols(*In->Symbols),
+ UnorderedElementsAreArray(yamlFromSymbols(*In->Symbols)));
+ EXPECT_THAT(yamlFromRefs(*In->Refs),
+ UnorderedElementsAreArray(yamlFromRefs(*In->Refs)));
auto IGNDeserialized = In->Sources->lookup(IGN.URI);
EXPECT_EQ(IGNDeserialized.Digest, IGN.Digest);
EXPECT_EQ(IGNDeserialized.DirectIncludes, IGN.DirectIncludes);
return arg.line == int(Line) && arg.character == int(Col);
}
-MATCHER_P(MacroName, Name, "") { return arg.Name == Name; }
+MATCHER_P(macroName, Name, "") { return arg.Name == Name; }
/// A helper to make tests easier to read.
Position position(int Line, int Character) {
ASSERT_TRUE(Id);
auto Result = locateMacroAt(*Id, AST.getPreprocessor());
ASSERT_TRUE(Result);
- EXPECT_THAT(*Result, MacroName("MACRO"));
+ EXPECT_THAT(*Result, macroName("MACRO"));
}
TEST(SourceCodeTests, WorksAtBeginOfFile) {
ASSERT_TRUE(Id);
auto Result = locateMacroAt(*Id, AST.getPreprocessor());
ASSERT_TRUE(Result);
- EXPECT_THAT(*Result, MacroName("MACRO"));
+ EXPECT_THAT(*Result, macroName("MACRO"));
}
TEST(SourceCodeTests, IsInsideMainFile) {
using ::testing::UnorderedElementsAreArray;
// GMock helpers for matching Symbol.
-MATCHER_P(Labeled, Label, "") {
+MATCHER_P(labeled, Label, "") {
return (arg.Name + arg.Signature).str() == Label;
}
-MATCHER_P(ReturnType, D, "") { return arg.ReturnType == D; }
-MATCHER_P(Doc, D, "") { return arg.Documentation == D; }
-MATCHER_P(Snippet, S, "") {
+MATCHER_P(returnType, D, "") { return arg.ReturnType == D; }
+MATCHER_P(doc, D, "") { return arg.Documentation == D; }
+MATCHER_P(snippet, S, "") {
return (arg.Name + arg.CompletionSnippetSuffix).str() == S;
}
-MATCHER_P(QName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
-MATCHER_P(HasName, Name, "") { return arg.Name == Name; }
-MATCHER_P(TemplateArgs, TemplArgs, "") {
+MATCHER_P(qName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
+MATCHER_P(hasName, Name, "") { return arg.Name == Name; }
+MATCHER_P(templateArgs, TemplArgs, "") {
return arg.TemplateSpecializationArgs == TemplArgs;
}
-MATCHER_P(DeclURI, P, "") {
+MATCHER_P(declURI, P, "") {
return StringRef(arg.CanonicalDeclaration.FileURI) == P;
}
-MATCHER_P(DefURI, P, "") { return StringRef(arg.Definition.FileURI) == P; }
-MATCHER(IncludeHeader, "") { return !arg.IncludeHeaders.empty(); }
-MATCHER_P(IncludeHeader, P, "") {
+MATCHER_P(defURI, P, "") { return StringRef(arg.Definition.FileURI) == P; }
+MATCHER(includeHeader, "") { return !arg.IncludeHeaders.empty(); }
+MATCHER_P(includeHeader, P, "") {
return (arg.IncludeHeaders.size() == 1) &&
(arg.IncludeHeaders.begin()->IncludeHeader == P);
}
-MATCHER_P2(IncludeHeaderWithRef, IncludeHeader, References, "") {
- return (arg.IncludeHeader == IncludeHeader) && (arg.References == References);
+MATCHER_P2(IncludeHeaderWithRef, includeHeader, References, "") {
+ return (arg.IncludeHeader == includeHeader) && (arg.References == References);
}
bool rangesMatch(const SymbolLocation &Loc, const Range &R) {
return std::make_tuple(Loc.Start.line(), Loc.Start.column(), Loc.End.line(),
std::make_tuple(R.start.line, R.start.character, R.end.line,
R.end.character);
}
-MATCHER_P(DeclRange, Pos, "") {
+MATCHER_P(declRange, Pos, "") {
return rangesMatch(arg.CanonicalDeclaration, Pos);
}
-MATCHER_P(DefRange, Pos, "") { return rangesMatch(arg.Definition, Pos); }
-MATCHER_P(RefCount, R, "") { return int(arg.References) == R; }
-MATCHER_P(ForCodeCompletion, IsIndexedForCodeCompletion, "") {
+MATCHER_P(defRange, Pos, "") { return rangesMatch(arg.Definition, Pos); }
+MATCHER_P(refCount, R, "") { return int(arg.References) == R; }
+MATCHER_P(forCodeCompletion, IsIndexedForCodeCompletion, "") {
return static_cast<bool>(arg.Flags & Symbol::IndexedForCodeCompletion) ==
IsIndexedForCodeCompletion;
}
-MATCHER(Deprecated, "") { return arg.Flags & Symbol::Deprecated; }
-MATCHER(ImplementationDetail, "") {
+MATCHER(deprecated, "") { return arg.Flags & Symbol::Deprecated; }
+MATCHER(implementationDetail, "") {
return arg.Flags & Symbol::ImplementationDetail;
}
-MATCHER(VisibleOutsideFile, "") {
+MATCHER(visibleOutsideFile, "") {
return static_cast<bool>(arg.Flags & Symbol::VisibleOutsideFile);
}
-MATCHER(RefRange, "") {
+MATCHER(refRange, "") {
const Ref &Pos = ::testing::get<0>(arg);
const Range &Range = ::testing::get<1>(arg);
return rangesMatch(Pos.Location, Range);
return arg == Relation{Subject.ID, RelationKind::OverriddenBy, Object.ID};
}
::testing::Matcher<const std::vector<Ref> &>
-HaveRanges(const std::vector<Range> Ranges) {
- return ::testing::UnorderedPointwise(RefRange(), Ranges);
+haveRanges(const std::vector<Range> Ranges) {
+ return ::testing::UnorderedPointwise(refRange(), Ranges);
}
class ShouldCollectSymbolTest : public ::testing::Test {
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols,
UnorderedElementsAreArray(
- {AllOf(QName("Foo"), ForCodeCompletion(true)),
- AllOf(QName("Foo::Foo"), ForCodeCompletion(false)),
- AllOf(QName("Foo::Foo"), ForCodeCompletion(false)),
- AllOf(QName("Foo::f"), ForCodeCompletion(false)),
- AllOf(QName("Foo::~Foo"), ForCodeCompletion(false)),
- AllOf(QName("Foo::operator="), ForCodeCompletion(false)),
- AllOf(QName("Foo::Nested"), ForCodeCompletion(false)),
- AllOf(QName("Foo::Nested::f"), ForCodeCompletion(false)),
- AllOf(QName("ClassInLambda"), ForCodeCompletion(false)),
- AllOf(QName("Friend"), ForCodeCompletion(true)),
- AllOf(QName("f1"), ForCodeCompletion(true)),
- AllOf(QName("f2"), ForCodeCompletion(true)),
- AllOf(QName("KInt"), ForCodeCompletion(true)),
- AllOf(QName("kStr"), ForCodeCompletion(true)),
- AllOf(QName("foo"), ForCodeCompletion(true)),
- AllOf(QName("foo::bar"), ForCodeCompletion(true)),
- AllOf(QName("foo::int32"), ForCodeCompletion(true)),
- AllOf(QName("foo::int32_t"), ForCodeCompletion(true)),
- AllOf(QName("foo::v1"), ForCodeCompletion(true)),
- AllOf(QName("foo::bar::v2"), ForCodeCompletion(true)),
- AllOf(QName("foo::v2"), ForCodeCompletion(true)),
- AllOf(QName("foo::baz"), ForCodeCompletion(true))}));
+ {AllOf(qName("Foo"), forCodeCompletion(true)),
+ AllOf(qName("Foo::Foo"), forCodeCompletion(false)),
+ AllOf(qName("Foo::Foo"), forCodeCompletion(false)),
+ AllOf(qName("Foo::f"), forCodeCompletion(false)),
+ AllOf(qName("Foo::~Foo"), forCodeCompletion(false)),
+ AllOf(qName("Foo::operator="), forCodeCompletion(false)),
+ AllOf(qName("Foo::Nested"), forCodeCompletion(false)),
+ AllOf(qName("Foo::Nested::f"), forCodeCompletion(false)),
+ AllOf(qName("ClassInLambda"), forCodeCompletion(false)),
+ AllOf(qName("Friend"), forCodeCompletion(true)),
+ AllOf(qName("f1"), forCodeCompletion(true)),
+ AllOf(qName("f2"), forCodeCompletion(true)),
+ AllOf(qName("KInt"), forCodeCompletion(true)),
+ AllOf(qName("kStr"), forCodeCompletion(true)),
+ AllOf(qName("foo"), forCodeCompletion(true)),
+ AllOf(qName("foo::bar"), forCodeCompletion(true)),
+ AllOf(qName("foo::int32"), forCodeCompletion(true)),
+ AllOf(qName("foo::int32_t"), forCodeCompletion(true)),
+ AllOf(qName("foo::v1"), forCodeCompletion(true)),
+ AllOf(qName("foo::bar::v2"), forCodeCompletion(true)),
+ AllOf(qName("foo::v2"), forCodeCompletion(true)),
+ AllOf(qName("foo::baz"), forCodeCompletion(true))}));
}
TEST_F(SymbolCollectorTest, FileLocal) {
runSymbolCollector(Header, Main);
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Foo"), VisibleOutsideFile()),
- AllOf(QName("bar"), VisibleOutsideFile()),
- AllOf(QName("a"), Not(VisibleOutsideFile())),
- AllOf(QName("B"), Not(VisibleOutsideFile())),
- AllOf(QName("c"), Not(VisibleOutsideFile())),
+ AllOf(qName("Foo"), visibleOutsideFile()),
+ AllOf(qName("bar"), visibleOutsideFile()),
+ AllOf(qName("a"), Not(visibleOutsideFile())),
+ AllOf(qName("B"), Not(visibleOutsideFile())),
+ AllOf(qName("c"), Not(visibleOutsideFile())),
// FIXME: ForwardDecl likely *is* visible outside.
- AllOf(QName("ForwardDecl"), Not(VisibleOutsideFile()))));
+ AllOf(qName("ForwardDecl"), Not(visibleOutsideFile()))));
}
TEST_F(SymbolCollectorTest, Template) {
runSymbolCollector(Header.code(), /*Main=*/"");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Tmpl"), DeclRange(Header.range()),
- ForCodeCompletion(true)),
- AllOf(QName("Tmpl"), DeclRange(Header.range("specdecl")),
- ForCodeCompletion(false)),
- AllOf(QName("Tmpl"), DeclRange(Header.range("partspecdecl")),
- ForCodeCompletion(false)),
- AllOf(QName("Tmpl::x"), DeclRange(Header.range("xdecl")),
- ForCodeCompletion(false))));
+ AllOf(qName("Tmpl"), declRange(Header.range()),
+ forCodeCompletion(true)),
+ AllOf(qName("Tmpl"), declRange(Header.range("specdecl")),
+ forCodeCompletion(false)),
+ AllOf(qName("Tmpl"), declRange(Header.range("partspecdecl")),
+ forCodeCompletion(false)),
+ AllOf(qName("Tmpl::x"), declRange(Header.range("xdecl")),
+ forCodeCompletion(false))));
}
-TEST_F(SymbolCollectorTest, TemplateArgs) {
+TEST_F(SymbolCollectorTest, templateArgs) {
Annotations Header(R"(
template <class X> class $barclasstemp[[Bar]] {};
template <class T, class U, template<typename> class Z, int Q>
EXPECT_THAT(
Symbols,
AllOf(
- Contains(AllOf(QName("Tmpl"), TemplateArgs("<int, bool, Bar, 3>"),
- DeclRange(Header.range("specdecl")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Tmpl"), TemplateArgs("<bool, U, Bar, T>"),
- DeclRange(Header.range("partspecdecl")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Foo"), TemplateArgs("<Bar<int>, int, double>"),
- DeclRange(Header.range("parampack")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Foo"), TemplateArgs("<T, T>"),
- DeclRange(Header.range("parampackpartial")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Baz"), TemplateArgs("<3, 5, 8>"),
- DeclRange(Header.range("parampacknontype")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Baz"), TemplateArgs("<T, T>"),
- DeclRange(Header.range("parampacknontypepartial")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Foz"), TemplateArgs("<Bar, Bar>"),
- DeclRange(Header.range("parampacktempltempl")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Foz"), TemplateArgs("<T, T>"),
- DeclRange(Header.range("parampacktempltemplpartial")),
- ForCodeCompletion(false)))));
+ Contains(AllOf(qName("Tmpl"), templateArgs("<int, bool, Bar, 3>"),
+ declRange(Header.range("specdecl")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Tmpl"), templateArgs("<bool, U, Bar, T>"),
+ declRange(Header.range("partspecdecl")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Foo"), templateArgs("<Bar<int>, int, double>"),
+ declRange(Header.range("parampack")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Foo"), templateArgs("<T, T>"),
+ declRange(Header.range("parampackpartial")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Baz"), templateArgs("<3, 5, 8>"),
+ declRange(Header.range("parampacknontype")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Baz"), templateArgs("<T, T>"),
+ declRange(Header.range("parampacknontypepartial")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Foz"), templateArgs("<Bar, Bar>"),
+ declRange(Header.range("parampacktempltempl")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Foz"), templateArgs("<T, T>"),
+ declRange(Header.range("parampacktempltemplpartial")),
+ forCodeCompletion(false)))));
}
TEST_F(SymbolCollectorTest, ObjCSymbols) {
runSymbolCollector(Header, /*Main=*/"", {"-fblocks", "-xobjective-c++"});
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- QName("Person"), QName("Person::someMethodName:lastName:"),
- AllOf(QName("MyCategory"), ForCodeCompletion(false)),
- QName("Person::someMethodName2:"), QName("MyProtocol"),
- QName("MyProtocol::someMethodName3:")));
+ qName("Person"), qName("Person::someMethodName:lastName:"),
+ AllOf(qName("MyCategory"), forCodeCompletion(false)),
+ qName("Person::someMethodName2:"), qName("MyProtocol"),
+ qName("MyProtocol::someMethodName3:")));
}
TEST_F(SymbolCollectorTest, ObjCPropertyImpl) {
)";
TestFileName = testPath("test.m");
runSymbolCollector(Header, /*Main=*/"", {"-xobjective-c++"});
- EXPECT_THAT(Symbols, Contains(QName("Container")));
- EXPECT_THAT(Symbols, Contains(QName("Container::magic")));
+ EXPECT_THAT(Symbols, Contains(qName("Container")));
+ EXPECT_THAT(Symbols, Contains(qName("Container::magic")));
// FIXME: Results also contain Container::_magic on some platforms.
// Figure out why it's platform-dependent.
}
{"-xobjective-c++", "-Wno-objc-root-class"});
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Dog"), DeclRange(Header.range("dogdecl")),
- DefRange(Main.range("dogdef"))),
- AllOf(QName("Fluffy"), DeclRange(Header.range("fluffydecl")),
- DefRange(Main.range("fluffydef"))),
- AllOf(QName("CatDog"), DeclRange(Main.range("catdog")),
- DefRange(Main.range("catdog"))),
- AllOf(QName("Ruff"), DeclRange(Main.range("ruff")),
- DefRange(Main.range("ruff")))));
+ AllOf(qName("Dog"), declRange(Header.range("dogdecl")),
+ defRange(Main.range("dogdef"))),
+ AllOf(qName("Fluffy"), declRange(Header.range("fluffydecl")),
+ defRange(Main.range("fluffydef"))),
+ AllOf(qName("CatDog"), declRange(Main.range("catdog")),
+ defRange(Main.range("catdog"))),
+ AllOf(qName("Ruff"), declRange(Main.range("ruff")),
+ defRange(Main.range("ruff")))));
}
TEST_F(SymbolCollectorTest, ObjCForwardDecls) {
{"-xobjective-c++", "-Wno-objc-root-class"});
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("CatDog"), DeclRange(Header.range("catdogdecl")),
- DefRange(Main.range("catdogdef"))),
- AllOf(QName("Dog"), DeclRange(Main.range("dogdecl")),
- DefRange(Main.range("dogdef"))),
- AllOf(QName("Barker"), DeclRange(Main.range("barkerdecl"))),
- QName("Barker::woof"), QName("Dog::woof")));
+ AllOf(qName("CatDog"), declRange(Header.range("catdogdecl")),
+ defRange(Main.range("catdogdef"))),
+ AllOf(qName("Dog"), declRange(Main.range("dogdecl")),
+ defRange(Main.range("dogdef"))),
+ AllOf(qName("Barker"), declRange(Main.range("barkerdecl"))),
+ qName("Barker::woof"), qName("Dog::woof")));
}
TEST_F(SymbolCollectorTest, ObjCClassExtensions) {
{"-xobjective-c++", "-Wno-objc-root-class"});
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Cat"), DeclRange(Header.range("catdecl"))),
- QName("Cat::meow"), QName("Cat::pur")));
+ AllOf(qName("Cat"), declRange(Header.range("catdecl"))),
+ qName("Cat::meow"), qName("Cat::pur")));
}
TEST_F(SymbolCollectorTest, Locations) {
runSymbolCollector(Header.code(), Main.code());
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("X"), DeclRange(Header.range("xdecl")),
- DefRange(Main.range("xdef"))),
- AllOf(QName("Cls"), DeclRange(Header.range("clsdecl")),
- DefRange(Main.range("clsdef"))),
- AllOf(QName("print"), DeclRange(Header.range("printdecl")),
- DefRange(Main.range("printdef"))),
- AllOf(QName("Z"), DeclRange(Header.range("zdecl"))),
- AllOf(QName("foo"), DeclRange(Header.range("foodecl"))),
- AllOf(QName("Y"), DeclRange(Main.range("ydecl")))));
+ AllOf(qName("X"), declRange(Header.range("xdecl")),
+ defRange(Main.range("xdef"))),
+ AllOf(qName("Cls"), declRange(Header.range("clsdecl")),
+ defRange(Main.range("clsdef"))),
+ AllOf(qName("print"), declRange(Header.range("printdecl")),
+ defRange(Main.range("printdef"))),
+ AllOf(qName("Z"), declRange(Header.range("zdecl"))),
+ AllOf(qName("foo"), declRange(Header.range("foodecl"))),
+ AllOf(qName("Y"), declRange(Main.range("ydecl")))));
}
TEST_F(SymbolCollectorTest, Refs) {
runSymbolCollector(Header.code(),
(Main.code() + SymbolsOnlyInMainCode.code()).str());
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "Foo").ID,
- HaveRanges(Main.ranges("foo")))));
+ haveRanges(Main.ranges("foo")))));
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "Bar").ID,
- HaveRanges(Main.ranges("bar")))));
+ haveRanges(Main.ranges("bar")))));
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "func").ID,
- HaveRanges(Main.ranges("func")))));
+ haveRanges(Main.ranges("func")))));
EXPECT_THAT(Refs, Not(Contains(Pair(findSymbol(Symbols, "NS").ID, _))));
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "MACRO").ID,
- HaveRanges(Main.ranges("macro")))));
+ haveRanges(Main.ranges("macro")))));
// - (a, b) externally visible and should have refs.
// - (c, FUNC) externally invisible and had no refs collected.
auto MainSymbols =
runSymbolCollector(Header.code(), "");
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "FOO").ID,
- HaveRanges(Header.ranges("foo")))));
+ haveRanges(Header.ranges("foo")))));
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "BAR").ID,
- HaveRanges(Header.ranges("bar")))));
+ haveRanges(Header.ranges("bar")))));
// No unique ID for multiple symbols named UD. Check for ranges only.
- EXPECT_THAT(Refs, Contains(Pair(_, HaveRanges(Header.ranges("ud1")))));
- EXPECT_THAT(Refs, Contains(Pair(_, HaveRanges(Header.ranges("ud2")))));
+ EXPECT_THAT(Refs, Contains(Pair(_, haveRanges(Header.ranges("ud1")))));
+ EXPECT_THAT(Refs, Contains(Pair(_, haveRanges(Header.ranges("ud2")))));
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "CONCAT").ID,
- HaveRanges(Header.ranges("concat")))));
+ haveRanges(Header.ranges("concat")))));
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "PREPEND").ID,
- HaveRanges(Header.ranges("prepend")))));
+ haveRanges(Header.ranges("prepend")))));
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "MACROA").ID,
- HaveRanges(Header.ranges("macroa")))));
+ haveRanges(Header.ranges("macroa")))));
}
TEST_F(SymbolCollectorTest, MacroRefWithoutCollectingSymbol) {
CollectorOpts.RefsInHeaders = true;
CollectorOpts.CollectMacro = false;
runSymbolCollector(Header.code(), "");
- EXPECT_THAT(Refs, Contains(Pair(_, HaveRanges(Header.ranges("foo")))));
+ EXPECT_THAT(Refs, Contains(Pair(_, haveRanges(Header.ranges("foo")))));
}
TEST_F(SymbolCollectorTest, MacrosWithRefFilter) {
const auto SpelledRefs = std::move(SpelledSlabBuilder).build(),
ImplicitRefs = std::move(ImplicitSlabBuilder).build();
EXPECT_THAT(SpelledRefs,
- Contains(Pair(TargetID, HaveRanges(SpelledRanges))));
+ Contains(Pair(TargetID, haveRanges(SpelledRanges))));
EXPECT_THAT(ImplicitRefs,
- Contains(Pair(TargetID, HaveRanges(ImplicitRanges))));
+ Contains(Pair(TargetID, haveRanges(ImplicitRanges))));
}
}
// When we find references for class Foo, we expect to see all
// constructor/destructor references.
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "Foo").ID,
- HaveRanges(Header.ranges()))));
+ haveRanges(Header.ranges()))));
}
TEST_F(SymbolCollectorTest, RefsOnMacros) {
CollectorOpts.RefFilter = RefKind::All;
runSymbolCollector(Header.code(), "");
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "Foo").ID,
- HaveRanges(Header.ranges()))));
+ haveRanges(Header.ranges()))));
}
TEST_F(SymbolCollectorTest, HeaderAsMainFile) {
runSymbolCollector("", Header.code());
EXPECT_THAT(Refs,
UnorderedElementsAre(Pair(findSymbol(Symbols, "Foo").ID,
- HaveRanges(Header.ranges("Foo"))),
+ haveRanges(Header.ranges("Foo"))),
Pair(findSymbol(Symbols, "Func").ID,
- HaveRanges(Header.ranges("Func")))));
+ haveRanges(Header.ranges("Func")))));
// 2. Run the .h file as main file.
TestFileName = testPath("foo.h");
runSymbolCollector("", Header.code(),
/*ExtraArgs=*/{"-xobjective-c++-header"});
- EXPECT_THAT(Symbols, UnorderedElementsAre(QName("Foo"), QName("Func")));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(qName("Foo"), qName("Func")));
EXPECT_THAT(Refs,
UnorderedElementsAre(Pair(findSymbol(Symbols, "Foo").ID,
- HaveRanges(Header.ranges("Foo"))),
+ haveRanges(Header.ranges("Foo"))),
Pair(findSymbol(Symbols, "Func").ID,
- HaveRanges(Header.ranges("Func")))));
+ haveRanges(Header.ranges("Func")))));
// 3. Run the .hh file as main file (without "-x c++-header").
TestFileName = testPath("foo.hh");
runSymbolCollector("", Header.code());
- EXPECT_THAT(Symbols, UnorderedElementsAre(QName("Foo"), QName("Func")));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(qName("Foo"), qName("Func")));
EXPECT_THAT(Refs,
UnorderedElementsAre(Pair(findSymbol(Symbols, "Foo").ID,
- HaveRanges(Header.ranges("Foo"))),
+ haveRanges(Header.ranges("Foo"))),
Pair(findSymbol(Symbols, "Func").ID,
- HaveRanges(Header.ranges("Func")))));
+ haveRanges(Header.ranges("Func")))));
}
TEST_F(SymbolCollectorTest, RefsInHeaders) {
)");
runSymbolCollector(Header.code(), "");
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "Foo").ID,
- HaveRanges(Header.ranges("foo")))));
+ haveRanges(Header.ranges("foo")))));
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "MACRO").ID,
- HaveRanges(Header.ranges("macro")))));
+ haveRanges(Header.ranges("macro")))));
}
TEST_F(SymbolCollectorTest, BaseOfRelations) {
EXPECT_THAT(
Symbols,
UnorderedElementsAreArray(
- {AllOf(QName("W"), RefCount(1)), AllOf(QName("X"), RefCount(1)),
- AllOf(QName("Y"), RefCount(0)), AllOf(QName("Z"), RefCount(0)),
- AllOf(QName("y"), RefCount(0)), AllOf(QName("z"), RefCount(0)),
- AllOf(QName("x"), RefCount(0)), AllOf(QName("w"), RefCount(0)),
- AllOf(QName("w2"), RefCount(0)), AllOf(QName("V"), RefCount(1)),
- AllOf(QName("v"), RefCount(0))}));
+ {AllOf(qName("W"), refCount(1)), AllOf(qName("X"), refCount(1)),
+ AllOf(qName("Y"), refCount(0)), AllOf(qName("Z"), refCount(0)),
+ AllOf(qName("y"), refCount(0)), AllOf(qName("z"), refCount(0)),
+ AllOf(qName("x"), refCount(0)), AllOf(qName("w"), refCount(0)),
+ AllOf(qName("w2"), refCount(0)), AllOf(qName("V"), refCount(1)),
+ AllOf(qName("v"), refCount(0))}));
}
TEST_F(SymbolCollectorTest, SymbolRelativeNoFallback) {
runSymbolCollector("class Foo {};", /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI(TestHeaderURI))));
+ AllOf(qName("Foo"), declURI(TestHeaderURI))));
}
TEST_F(SymbolCollectorTest, SymbolRelativeWithFallback) {
CollectorOpts.FallbackDir = testRoot();
runSymbolCollector("class Foo {};", /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI(TestHeaderURI))));
+ AllOf(qName("Foo"), declURI(TestHeaderURI))));
}
TEST_F(SymbolCollectorTest, UnittestURIScheme) {
TestFileName = testPath("x.cpp");
runSymbolCollector("class Foo {};", /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI("unittest:///x.h"))));
+ AllOf(qName("Foo"), declURI("unittest:///x.h"))));
}
TEST_F(SymbolCollectorTest, IncludeEnums) {
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Red"), ForCodeCompletion(true)),
- AllOf(QName("Color"), ForCodeCompletion(true)),
- AllOf(QName("Green"), ForCodeCompletion(true)),
- AllOf(QName("Color2"), ForCodeCompletion(true)),
- AllOf(QName("Color2::Yellow"), ForCodeCompletion(false)),
- AllOf(QName("ns"), ForCodeCompletion(true)),
- AllOf(QName("ns::Black"), ForCodeCompletion(true))));
+ AllOf(qName("Red"), forCodeCompletion(true)),
+ AllOf(qName("Color"), forCodeCompletion(true)),
+ AllOf(qName("Green"), forCodeCompletion(true)),
+ AllOf(qName("Color2"), forCodeCompletion(true)),
+ AllOf(qName("Color2::Yellow"), forCodeCompletion(false)),
+ AllOf(qName("ns"), forCodeCompletion(true)),
+ AllOf(qName("ns::Black"), forCodeCompletion(true))));
}
TEST_F(SymbolCollectorTest, NamelessSymbols) {
} Foo;
)";
runSymbolCollector(Header, /*Main=*/"");
- EXPECT_THAT(Symbols, UnorderedElementsAre(QName("Foo"),
- QName("(anonymous struct)::a")));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(qName("Foo"),
+ qName("(anonymous struct)::a")));
}
TEST_F(SymbolCollectorTest, SymbolFormedFromRegisteredSchemeFromMacro) {
runSymbolCollector(Header.code(), /*Main=*/"");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("abc_Test"), DeclRange(Header.range("expansion")),
- DeclURI(TestHeaderURI)),
- AllOf(QName("Test"), DeclRange(Header.range("spelling")),
- DeclURI(TestHeaderURI))));
+ AllOf(qName("abc_Test"), declRange(Header.range("expansion")),
+ declURI(TestHeaderURI)),
+ AllOf(qName("Test"), declRange(Header.range("spelling")),
+ declURI(TestHeaderURI))));
}
TEST_F(SymbolCollectorTest, SymbolFormedByCLI) {
)");
runSymbolCollector(Header.code(), /*Main=*/"", /*ExtraArgs=*/{"-DNAME=name"});
EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(
- QName("name"), DeclRange(Header.range("expansion")),
- DeclURI(TestHeaderURI))));
+ qName("name"), declRange(Header.range("expansion")),
+ declURI(TestHeaderURI))));
}
TEST_F(SymbolCollectorTest, SymbolsInMainFile) {
)";
runSymbolCollector(/*Header=*/"", Main);
EXPECT_THAT(Symbols, UnorderedElementsAre(
- QName("Foo"), QName("f1"), QName("f2"), QName("ff"),
- QName("foo"), QName("foo::Bar"), QName("main_f")));
+ qName("Foo"), qName("f1"), qName("f2"), qName("ff"),
+ qName("foo"), qName("foo::Bar"), qName("main_f")));
}
TEST_F(SymbolCollectorTest, Documentation) {
const std::string Header = R"(
- // Doc Foo
+ // doc Foo
class Foo {
- // Doc f
+ // doc f
int f();
};
)";
runSymbolCollector(Header, /* Main */ "");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Foo"), Doc("Doc Foo"), ForCodeCompletion(true)),
- AllOf(QName("Foo::f"), Doc(""), ReturnType(""),
- ForCodeCompletion(false))));
+ AllOf(qName("Foo"), doc("doc Foo"), forCodeCompletion(true)),
+ AllOf(qName("Foo::f"), doc(""), returnType(""),
+ forCodeCompletion(false))));
CollectorOpts.StoreAllDocumentation = true;
runSymbolCollector(Header, /* Main */ "");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Foo"), Doc("Doc Foo"), ForCodeCompletion(true)),
- AllOf(QName("Foo::f"), Doc("Doc f"), ReturnType(""),
- ForCodeCompletion(false))));
+ AllOf(qName("Foo"), doc("doc Foo"), forCodeCompletion(true)),
+ AllOf(qName("Foo::f"), doc("doc f"), returnType(""),
+ forCodeCompletion(false))));
}
TEST_F(SymbolCollectorTest, ClassMembers) {
EXPECT_THAT(
Symbols,
UnorderedElementsAre(
- QName("Foo"),
- AllOf(QName("Foo::f"), ReturnType(""), ForCodeCompletion(false)),
- AllOf(QName("Foo::g"), ReturnType(""), ForCodeCompletion(false)),
- AllOf(QName("Foo::sf"), ReturnType(""), ForCodeCompletion(false)),
- AllOf(QName("Foo::ssf"), ReturnType(""), ForCodeCompletion(false)),
- AllOf(QName("Foo::x"), ReturnType(""), ForCodeCompletion(false))));
+ qName("Foo"),
+ AllOf(qName("Foo::f"), returnType(""), forCodeCompletion(false)),
+ AllOf(qName("Foo::g"), returnType(""), forCodeCompletion(false)),
+ AllOf(qName("Foo::sf"), returnType(""), forCodeCompletion(false)),
+ AllOf(qName("Foo::ssf"), returnType(""), forCodeCompletion(false)),
+ AllOf(qName("Foo::x"), returnType(""), forCodeCompletion(false))));
}
TEST_F(SymbolCollectorTest, Scopes) {
)";
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols,
- UnorderedElementsAre(QName("na"), QName("na::nb"),
- QName("na::Foo"), QName("na::nb::Bar")));
+ UnorderedElementsAre(qName("na"), qName("na::nb"),
+ qName("na::Foo"), qName("na::nb::Bar")));
}
TEST_F(SymbolCollectorTest, ExternC) {
}
)";
runSymbolCollector(Header, /*Main=*/"");
- EXPECT_THAT(Symbols, UnorderedElementsAre(QName("na"), QName("Foo"),
- QName("na::Bar")));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(qName("na"), qName("Foo"),
+ qName("na::Bar")));
}
TEST_F(SymbolCollectorTest, SkipInlineNamespace) {
)";
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols,
- UnorderedElementsAre(QName("na"), QName("na::nb"),
- QName("na::Foo"), QName("na::Bar")));
+ UnorderedElementsAre(qName("na"), qName("na::nb"),
+ qName("na::Foo"), qName("na::Bar")));
}
TEST_F(SymbolCollectorTest, SymbolWithDocumentation) {
EXPECT_THAT(
Symbols,
UnorderedElementsAre(
- QName("nx"), AllOf(QName("nx::ff"), Labeled("ff(int x, double y)"),
- ReturnType("int"), Doc("Foo comment."))));
+ qName("nx"), AllOf(qName("nx::ff"), labeled("ff(int x, double y)"),
+ returnType("int"), doc("Foo comment."))));
}
-TEST_F(SymbolCollectorTest, Snippet) {
+TEST_F(SymbolCollectorTest, snippet) {
const std::string Header = R"(
namespace nx {
void f() {}
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- QName("nx"),
- AllOf(QName("nx::f"), Labeled("f()"), Snippet("f()")),
- AllOf(QName("nx::ff"), Labeled("ff(int x, double y)"),
- Snippet("ff(${1:int x}, ${2:double y})"))));
+ qName("nx"),
+ AllOf(qName("nx::f"), labeled("f()"), snippet("f()")),
+ AllOf(qName("nx::ff"), labeled("ff(int x, double y)"),
+ snippet("ff(${1:int x}, ${2:double y})"))));
}
TEST_F(SymbolCollectorTest, IncludeHeaderSameAsFileURI) {
CollectorOpts.CollectIncludePath = true;
runSymbolCollector("#pragma once\nclass Foo {};", /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI(TestHeaderURI))));
+ AllOf(qName("Foo"), declURI(TestHeaderURI))));
EXPECT_THAT(Symbols.begin()->IncludeHeaders,
UnorderedElementsAre(IncludeHeaderWithRef(TestHeaderURI, 1u)));
}
EXPECT_THAT(
Symbols,
UnorderedElementsAre(
- QName("std"),
- AllOf(QName("std::string"), DeclURI(TestHeaderURI),
- IncludeHeader("<string>")),
+ qName("std"),
+ AllOf(qName("std::string"), declURI(TestHeaderURI),
+ includeHeader("<string>")),
// Parameter names are demangled.
- AllOf(Labeled("move(T &&value)"), IncludeHeader("<utility>")),
- AllOf(Labeled("move(I, I, O)"), IncludeHeader("<algorithm>"))));
+ AllOf(labeled("move(T &&value)"), includeHeader("<utility>")),
+ AllOf(labeled("move(I, I, O)"), includeHeader("<algorithm>"))));
}
TEST_F(SymbolCollectorTest, IWYUPragma) {
)";
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI(TestHeaderURI),
- IncludeHeader("\"the/good/header.h\""))));
+ AllOf(qName("Foo"), declURI(TestHeaderURI),
+ includeHeader("\"the/good/header.h\""))));
}
TEST_F(SymbolCollectorTest, IWYUPragmaWithDoubleQuotes) {
)";
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI(TestHeaderURI),
- IncludeHeader("\"the/good/header.h\""))));
+ AllOf(qName("Foo"), declURI(TestHeaderURI),
+ includeHeader("\"the/good/header.h\""))));
}
TEST_F(SymbolCollectorTest, SkipIncFileWhenCanonicalizeHeaders) {
runSymbolCollector("#include \"test.inc\"\nclass Y {};", /*Main=*/"",
/*ExtraArgs=*/{"-I", testRoot()});
EXPECT_THAT(Symbols,
- UnorderedElementsAre(AllOf(QName("X"), DeclURI(IncURI),
- IncludeHeader("<canonical>")),
- AllOf(QName("Y"), DeclURI(TestHeaderURI),
- IncludeHeader("<canonical>"))));
+ UnorderedElementsAre(AllOf(qName("X"), declURI(IncURI),
+ includeHeader("<canonical>")),
+ AllOf(qName("Y"), declURI(TestHeaderURI),
+ includeHeader("<canonical>"))));
}
TEST_F(SymbolCollectorTest, MainFileIsHeaderWhenSkipIncFile) {
#endif
)cpp",
/*ExtraArgs=*/{"-I", testRoot()});
- EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(QName("X"), DeclURI(IncURI),
- IncludeHeader(TestFileURI))));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(qName("X"), declURI(IncURI),
+ includeHeader(TestFileURI))));
}
TEST_F(SymbolCollectorTest, IncFileInNonHeader) {
#include "test.inc"
)cpp",
/*ExtraArgs=*/{"-I", testRoot()});
- EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(QName("X"), DeclURI(IncURI),
- Not(IncludeHeader()))));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(qName("X"), declURI(IncURI),
+ Not(includeHeader()))));
}
// Features that depend on header-guards are fragile. Header guards are only
#endif // Header guard is recognized here.
)cpp",
"");
- EXPECT_THAT(Symbols, Not(Contains(QName("HEADER_GUARD_"))));
- EXPECT_THAT(Symbols, Each(IncludeHeader()));
+ EXPECT_THAT(Symbols, Not(Contains(qName("HEADER_GUARD_"))));
+ EXPECT_THAT(Symbols, Each(includeHeader()));
}
TEST_F(SymbolCollectorTest, NonModularHeader) {
auto TU = TestTU::withHeaderCode("int x();");
- EXPECT_THAT(TU.headerSymbols(), ElementsAre(IncludeHeader()));
+ EXPECT_THAT(TU.headerSymbols(), ElementsAre(includeHeader()));
// Files missing include guards aren't eligible for insertion.
TU.ImplicitHeaderGuard = false;
- EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(IncludeHeader())));
+ EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(includeHeader())));
// We recognize some patterns of trying to prevent insertion.
TU = TestTU::withHeaderCode(R"cpp(
int x();
)cpp");
TU.ExtraArgs.push_back("-DSECRET"); // *we're* able to include it.
- EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(IncludeHeader())));
+ EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(includeHeader())));
}
TEST_F(SymbolCollectorTest, AvoidUsingFwdDeclsAsCanonicalDecls) {
EXPECT_THAT(
Symbols,
UnorderedElementsAre(
- AllOf(QName("C"), DeclURI(TestHeaderURI),
- DeclRange(Header.range("cdecl")), IncludeHeader(TestHeaderURI),
- DefURI(TestHeaderURI), DefRange(Header.range("cdecl"))),
- AllOf(QName("S"), DeclURI(TestHeaderURI),
- DeclRange(Header.range("sdecl")), IncludeHeader(TestHeaderURI),
- DefURI(TestHeaderURI), DefRange(Header.range("sdecl"))),
- AllOf(QName("U"), DeclURI(TestHeaderURI),
- DeclRange(Header.range("udecl")), IncludeHeader(TestHeaderURI),
- DefURI(TestHeaderURI), DefRange(Header.range("udecl"))),
- AllOf(QName("U::x"), DeclURI(TestHeaderURI),
- DeclRange(Header.range("xdecl")), DefURI(TestHeaderURI),
- DefRange(Header.range("xdecl"))),
- AllOf(QName("U::y"), DeclURI(TestHeaderURI),
- DeclRange(Header.range("ydecl")), DefURI(TestHeaderURI),
- DefRange(Header.range("ydecl")))));
+ AllOf(qName("C"), declURI(TestHeaderURI),
+ declRange(Header.range("cdecl")), includeHeader(TestHeaderURI),
+ defURI(TestHeaderURI), defRange(Header.range("cdecl"))),
+ AllOf(qName("S"), declURI(TestHeaderURI),
+ declRange(Header.range("sdecl")), includeHeader(TestHeaderURI),
+ defURI(TestHeaderURI), defRange(Header.range("sdecl"))),
+ AllOf(qName("U"), declURI(TestHeaderURI),
+ declRange(Header.range("udecl")), includeHeader(TestHeaderURI),
+ defURI(TestHeaderURI), defRange(Header.range("udecl"))),
+ AllOf(qName("U::x"), declURI(TestHeaderURI),
+ declRange(Header.range("xdecl")), defURI(TestHeaderURI),
+ defRange(Header.range("xdecl"))),
+ AllOf(qName("U::y"), declURI(TestHeaderURI),
+ declRange(Header.range("ydecl")), defURI(TestHeaderURI),
+ defRange(Header.range("ydecl")))));
}
TEST_F(SymbolCollectorTest, ClassForwardDeclarationIsCanonical) {
runSymbolCollector(/*Header=*/"#pragma once\nclass X;",
/*Main=*/"class X {};");
EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(
- QName("X"), DeclURI(TestHeaderURI),
- IncludeHeader(TestHeaderURI), DefURI(TestFileURI))));
+ qName("X"), declURI(TestHeaderURI),
+ includeHeader(TestHeaderURI), defURI(TestFileURI))));
}
TEST_F(SymbolCollectorTest, UTF16Character) {
Annotations Header(/*Header=*/"class [[pörk]] {};");
runSymbolCollector(Header.code(), /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("pörk"), DeclRange(Header.range()))));
+ AllOf(qName("pörk"), declRange(Header.range()))));
}
TEST_F(SymbolCollectorTest, DoNotIndexSymbolsInFriendDecl) {
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- QName("nx"), QName("nx::X"),
- AllOf(QName("nx::Y"), DeclRange(Header.range("y"))),
- AllOf(QName("nx::Z"), DeclRange(Header.range("z"))),
- AllOf(QName("nx::foo"), DeclRange(Header.range("foo"))),
- AllOf(QName("nx::bar"), DeclRange(Header.range("bar")))));
+ qName("nx"), qName("nx::X"),
+ AllOf(qName("nx::Y"), declRange(Header.range("y"))),
+ AllOf(qName("nx::Z"), declRange(Header.range("z"))),
+ AllOf(qName("nx::foo"), declRange(Header.range("foo"))),
+ AllOf(qName("nx::bar"), declRange(Header.range("bar")))));
}
TEST_F(SymbolCollectorTest, ReferencesInFriendDecl) {
)";
CollectorOpts.CountReferences = true;
runSymbolCollector(Header, Main);
- EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(QName("X"), RefCount(1)),
- AllOf(QName("Y"), RefCount(1)),
- AllOf(QName("C"), RefCount(0))));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(qName("X"), refCount(1)),
+ AllOf(qName("Y"), refCount(1)),
+ AllOf(qName("C"), refCount(0))));
}
TEST_F(SymbolCollectorTest, Origin) {
EXPECT_THAT(
Symbols,
UnorderedElementsAre(
- QName("p"), QName("t"),
- AllOf(QName("X"), DeclURI(TestHeaderURI),
- IncludeHeader(TestHeaderURI)),
- AllOf(Labeled("MAC(x)"), RefCount(0),
+ qName("p"), qName("t"),
+ AllOf(qName("X"), declURI(TestHeaderURI),
+ includeHeader(TestHeaderURI)),
+ AllOf(labeled("MAC(x)"), refCount(0),
- DeclRange(Header.range("mac")), VisibleOutsideFile()),
- AllOf(Labeled("USED(y)"), RefCount(1),
- DeclRange(Header.range("used")), VisibleOutsideFile()),
- AllOf(Labeled("MAIN"), RefCount(0), DeclRange(Main.range("main")),
- Not(VisibleOutsideFile()))));
+ declRange(Header.range("mac")), visibleOutsideFile()),
+ AllOf(labeled("USED(y)"), refCount(1),
+ declRange(Header.range("used")), visibleOutsideFile()),
+ AllOf(labeled("MAIN"), refCount(0), declRange(Main.range("main")),
+ Not(visibleOutsideFile()))));
}
TEST_F(SymbolCollectorTest, DeprecatedSymbols) {
)";
runSymbolCollector(Header, /**/ "");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("TestClangc"), Deprecated()),
- AllOf(QName("TestClangd"), Not(Deprecated()))));
+ AllOf(qName("TestClangc"), deprecated()),
+ AllOf(qName("TestClangd"), Not(deprecated()))));
}
-TEST_F(SymbolCollectorTest, ImplementationDetail) {
+TEST_F(SymbolCollectorTest, implementationDetail) {
const std::string Header = R"(
#define DECL_NAME(x, y) x##_##y##_Decl
#define DECL(x, y) class DECL_NAME(x, y) {};
runSymbolCollector(Header, /**/ "");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("X_Y_Decl"), ImplementationDetail()),
- AllOf(QName("Public"), Not(ImplementationDetail()))));
+ AllOf(qName("X_Y_Decl"), implementationDetail()),
+ AllOf(qName("Public"), Not(implementationDetail()))));
}
TEST_F(SymbolCollectorTest, UsingDecl) {
using ::foo;
})";
runSymbolCollector(Header, /**/ "");
- EXPECT_THAT(Symbols, Contains(QName("std::foo")));
+ EXPECT_THAT(Symbols, Contains(qName("std::foo")));
}
TEST_F(SymbolCollectorTest, CBuiltins) {
extern int printf(const char*, ...);
)";
runSymbolCollector(Header, /**/ "", {"-xc"});
- EXPECT_THAT(Symbols, Contains(QName("printf")));
+ EXPECT_THAT(Symbols, Contains(qName("printf")));
}
TEST_F(SymbolCollectorTest, InvalidSourceLoc) {
void operator delete(void*)
__attribute__((__externally_visible__));)";
runSymbolCollector(Header, /**/ "");
- EXPECT_THAT(Symbols, Contains(QName("operator delete")));
+ EXPECT_THAT(Symbols, Contains(qName("operator delete")));
}
TEST_F(SymbolCollectorTest, BadUTF8) {
CollectorOpts.RefFilter = RefKind::All;
CollectorOpts.RefsInHeaders = true;
runSymbolCollector(Header, "");
- EXPECT_THAT(Symbols, Contains(AllOf(QName("types"), Doc("\xef\xbf\xbd "))));
- EXPECT_THAT(Symbols, Contains(QName("PUNCT")));
+ EXPECT_THAT(Symbols, Contains(AllOf(qName("types"), doc("\xef\xbf\xbd "))));
+ EXPECT_THAT(Symbols, Contains(qName("PUNCT")));
// Reference is stored, although offset within line is not reliable.
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "PUNCT").ID, _)));
}
TestFileName = testPath("test.h");
runSymbolCollector("", "#define X");
EXPECT_THAT(Symbols,
- UnorderedElementsAre(AllOf(QName("X"), ForCodeCompletion(true))));
+ UnorderedElementsAre(AllOf(qName("X"), forCodeCompletion(true))));
}
// Regression test for a crash-bug we used to have.
TU.build();
// We mostly care about not crashing, but verify that we didn't insert garbage
// about X too.
- EXPECT_THAT(TU.headerSymbols(), Not(Contains(QName("X"))));
+ EXPECT_THAT(TU.headerSymbols(), Not(Contains(qName("X"))));
}
TEST_F(SymbolCollectorTest, NoCrashOnObjCMethodCStyleParam) {
TU.build();
// We mostly care about not crashing.
EXPECT_THAT(TU.headerSymbols(),
- UnorderedElementsAre(QName("Foo"), QName("Foo::fun:")));
+ UnorderedElementsAre(qName("Foo"), qName("Foo::fun:")));
}
TEST_F(SymbolCollectorTest, Reserved) {
CollectorOpts.CollectReserved = true;
runSymbolCollector("", Header);
- EXPECT_THAT(Symbols, UnorderedElementsAre(QName("__foo"), QName("_X"),
- QName("_X::secret")));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(qName("__foo"), qName("_X"),
+ qName("_X::secret")));
CollectorOpts.CollectReserved = false;
runSymbolCollector("", Header); //
using ::testing::UnorderedElementsAreArray;
-auto CreateExpectedSymbolDetails = [](const std::string &name,
- const std::string &container,
+auto CreateExpectedSymbolDetails = [](const std::string &Name,
+ const std::string &Container,
const std::string &USR) {
- return SymbolDetails{name, container, USR, SymbolID(USR)};
+ return SymbolDetails{Name, Container, USR, SymbolID(USR)};
};
TEST(SymbolInfoTests, All) {
SymbolSlab generateNumSymbols(int Begin, int End) {
std::vector<std::string> Names;
- for (int i = Begin; i <= End; i++)
- Names.push_back(std::to_string(i));
+ for (int I = Begin; I <= End; I++)
+ Names.push_back(std::to_string(I));
return generateSymbols(Names);
}
using ::testing::UnorderedElementsAre;
// GMock helpers for matching TypeHierarchyItem.
-MATCHER_P(WithName, N, "") { return arg.name == N; }
-MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; }
-MATCHER_P(SelectionRangeIs, R, "") { return arg.selectionRange == R; }
+MATCHER_P(withName, N, "") { return arg.name == N; }
+MATCHER_P(withKind, Kind, "") { return arg.kind == Kind; }
+MATCHER_P(selectionRangeIs, R, "") { return arg.selectionRange == R; }
template <class... ParentMatchers>
-::testing::Matcher<TypeHierarchyItem> Parents(ParentMatchers... ParentsM) {
+::testing::Matcher<TypeHierarchyItem> parents(ParentMatchers... ParentsM) {
return Field(&TypeHierarchyItem::parents,
HasValue(UnorderedElementsAre(ParentsM...)));
}
template <class... ChildMatchers>
-::testing::Matcher<TypeHierarchyItem> Children(ChildMatchers... ChildrenM) {
+::testing::Matcher<TypeHierarchyItem> children(ChildMatchers... ChildrenM) {
return Field(&TypeHierarchyItem::children,
HasValue(UnorderedElementsAre(ChildrenM...)));
}
// Note: "not resolved" is different from "resolved but empty"!
-MATCHER(ParentsNotResolved, "") { return !arg.parents; }
-MATCHER(ChildrenNotResolved, "") { return !arg.children; }
+MATCHER(parentsNotResolved, "") { return !arg.parents; }
+MATCHER(childrenNotResolved, "") { return !arg.children; }
TEST(FindRecordTypeAt, TypeOrVariable) {
Annotations Source(R"cpp(
EXPECT_THAT(typeParents(Child), ElementsAre(Parent));
}
-MATCHER_P(ImplicitSpecOf, ClassTemplate, "") {
+MATCHER_P(implicitSpecOf, ClassTemplate, "") {
const ClassTemplateSpecializationDecl *CTS =
dyn_cast<ClassTemplateSpecializationDecl>(arg);
return CTS &&
const CXXRecordDecl *Child2 =
dyn_cast<CXXRecordDecl>(&findDecl(AST, "Child2"));
- EXPECT_THAT(typeParents(Child1), ElementsAre(ImplicitSpecOf(Parent)));
+ EXPECT_THAT(typeParents(Child1), ElementsAre(implicitSpecOf(Parent)));
EXPECT_THAT(typeParents(Child2), ElementsAre(ParentSpec));
}
EXPECT_THAT(
*Result,
AllOf(
- WithName("Child"), WithKind(SymbolKind::Struct),
- Parents(AllOf(WithName("Parent1"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("Parent1Def")),
- Parents()),
- AllOf(WithName("Parent3"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("Parent3Def")),
- Parents(AllOf(
- WithName("Parent2"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("Parent2Def")),
- Parents()))))));
+ withName("Child"), withKind(SymbolKind::Struct),
+ parents(AllOf(withName("Parent1"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("Parent1Def")),
+ parents()),
+ AllOf(withName("Parent3"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("Parent3Def")),
+ parents(AllOf(
+ withName("Parent2"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("Parent2Def")),
+ parents()))))));
}
}
ASSERT_TRUE(bool(Result));
EXPECT_THAT(
*Result,
- AllOf(WithName("S<0>"), WithKind(SymbolKind::Struct),
- Parents(
- AllOf(WithName("S"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("SDef")),
- Parents(AllOf(WithName("S"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("SDef")),
- Parents()))))));
+ AllOf(withName("S<0>"), withKind(SymbolKind::Struct),
+ parents(
+ AllOf(withName("S"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("SDef")),
+ parents(AllOf(withName("S"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("SDef")),
+ parents()))))));
}
TEST(TypeHierarchy, RecursiveHierarchyBounded) {
ASSERT_TRUE(bool(Result));
EXPECT_THAT(
*Result,
- AllOf(WithName("S<2>"), WithKind(SymbolKind::Struct),
- Parents(AllOf(
- WithName("S<1>"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("SDef")),
- Parents(AllOf(WithName("S<0>"), WithKind(SymbolKind::Struct),
- Parents()))))));
+ AllOf(withName("S<2>"), withKind(SymbolKind::Struct),
+ parents(AllOf(
+ withName("S<1>"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("SDef")),
+ parents(AllOf(withName("S<0>"), withKind(SymbolKind::Struct),
+ parents()))))));
Result = getTypeHierarchy(AST, Source.point("SRefDependent"), 0,
TypeHierarchyDirection::Parents);
ASSERT_TRUE(bool(Result));
EXPECT_THAT(
*Result,
- AllOf(WithName("S"), WithKind(SymbolKind::Struct),
- Parents(AllOf(WithName("S"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("SDef")), Parents()))));
+ AllOf(withName("S"), withKind(SymbolKind::Struct),
+ parents(AllOf(withName("S"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("SDef")), parents()))));
}
TEST(TypeHierarchy, DeriveFromImplicitSpec) {
testPath(TU.Filename));
ASSERT_TRUE(bool(Result));
EXPECT_THAT(*Result,
- AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
- Children(AllOf(WithName("Child1"),
- WithKind(SymbolKind::Struct), Children()),
- AllOf(WithName("Child2"),
- WithKind(SymbolKind::Struct), Children()))));
+ AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+ children(AllOf(withName("Child1"),
+ withKind(SymbolKind::Struct), children()),
+ AllOf(withName("Child2"),
+ withKind(SymbolKind::Struct), children()))));
}
TEST(TypeHierarchy, DeriveFromPartialSpec) {
AST, Source.points()[0], 2, TypeHierarchyDirection::Children, Index.get(),
testPath(TU.Filename));
ASSERT_TRUE(bool(Result));
- EXPECT_THAT(*Result, AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
- Children()));
+ EXPECT_THAT(*Result, AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+ children()));
}
TEST(TypeHierarchy, DeriveFromTemplate) {
testPath(TU.Filename));
ASSERT_TRUE(bool(Result));
EXPECT_THAT(*Result,
- AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
- Children(AllOf(WithName("Child"),
- WithKind(SymbolKind::Struct), Children()))));
+ AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+ children(AllOf(withName("Child"),
+ withKind(SymbolKind::Struct), children()))));
}
TEST(TypeHierarchy, Preamble) {
ASSERT_TRUE(Result);
EXPECT_THAT(
*Result,
- AllOf(WithName("Child"),
- Parents(AllOf(WithName("Parent"),
- SelectionRangeIs(HeaderInPreambleAnnotations.range()),
- Parents()))));
+ AllOf(withName("Child"),
+ parents(AllOf(withName("Parent"),
+ selectionRangeIs(HeaderInPreambleAnnotations.range()),
+ parents()))));
}
SymbolID findSymbolIDByName(SymbolIndex *Index, llvm::StringRef Name,
ASSERT_TRUE(bool(Result));
EXPECT_THAT(
*Result,
- AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
- ParentsNotResolved(),
- Children(AllOf(WithName("Child1"), WithKind(SymbolKind::Struct),
- ParentsNotResolved(), ChildrenNotResolved()))));
+ AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+ parentsNotResolved(),
+ children(AllOf(withName("Child1"), withKind(SymbolKind::Struct),
+ parentsNotResolved(), childrenNotResolved()))));
resolveTypeHierarchy((*Result->children)[0], /*ResolveLevels=*/1,
TypeHierarchyDirection::Children, Index.get());
EXPECT_THAT(
(*Result->children)[0],
- AllOf(WithName("Child1"), WithKind(SymbolKind::Struct),
- ParentsNotResolved(),
- Children(AllOf(WithName("Child2a"), WithKind(SymbolKind::Struct),
- ParentsNotResolved(), ChildrenNotResolved()),
- AllOf(WithName("Child2b"), WithKind(SymbolKind::Struct),
- ParentsNotResolved(), ChildrenNotResolved()))));
+ AllOf(withName("Child1"), withKind(SymbolKind::Struct),
+ parentsNotResolved(),
+ children(AllOf(withName("Child2a"), withKind(SymbolKind::Struct),
+ parentsNotResolved(), childrenNotResolved()),
+ AllOf(withName("Child2b"), withKind(SymbolKind::Struct),
+ parentsNotResolved(), childrenNotResolved()))));
}
} // namespace
using ::testing::AllOf;
-MATCHER_P(Scheme, S, "") { return arg.scheme() == S; }
-MATCHER_P(Authority, A, "") { return arg.authority() == A; }
-MATCHER_P(Body, B, "") { return arg.body() == B; }
+MATCHER_P(scheme, S, "") { return arg.scheme() == S; }
+MATCHER_P(authority, A, "") { return arg.authority() == A; }
+MATCHER_P(body, B, "") { return arg.body() == B; }
std::string createOrDie(llvm::StringRef AbsolutePath,
llvm::StringRef Scheme = "file") {
}
TEST(PercentEncodingTest, Encode) {
- EXPECT_EQ(URI("x", /*Authority=*/"", "a/b/c").toString(), "x:a/b/c");
- EXPECT_EQ(URI("x", /*Authority=*/"", "a!b;c~").toString(), "x:a%21b%3Bc~");
- EXPECT_EQ(URI("x", /*Authority=*/"", "a123b").toString(), "x:a123b");
- EXPECT_EQ(URI("x", /*Authority=*/"", "a:b;c").toString(), "x:a:b%3Bc");
+ EXPECT_EQ(URI("x", /*authority=*/"", "a/b/c").toString(), "x:a/b/c");
+ EXPECT_EQ(URI("x", /*authority=*/"", "a!b;c~").toString(), "x:a%21b%3Bc~");
+ EXPECT_EQ(URI("x", /*authority=*/"", "a123b").toString(), "x:a123b");
+ EXPECT_EQ(URI("x", /*authority=*/"", "a:b;c").toString(), "x:a:b%3Bc");
}
TEST(PercentEncodingTest, Decode) {
TEST(URITest, Parse) {
EXPECT_THAT(parseOrDie("file://auth/x/y/z"),
- AllOf(Scheme("file"), Authority("auth"), Body("/x/y/z")));
+ AllOf(scheme("file"), authority("auth"), body("/x/y/z")));
EXPECT_THAT(parseOrDie("file://au%3dth/%28x%29/y/%5c%20z"),
- AllOf(Scheme("file"), Authority("au=th"), Body("/(x)/y/\\ z")));
+ AllOf(scheme("file"), authority("au=th"), body("/(x)/y/\\ z")));
EXPECT_THAT(parseOrDie("file:///%28x%29/y/%5c%20z"),
- AllOf(Scheme("file"), Authority(""), Body("/(x)/y/\\ z")));
+ AllOf(scheme("file"), authority(""), body("/(x)/y/\\ z")));
EXPECT_THAT(parseOrDie("file:///x/y/z"),
- AllOf(Scheme("file"), Authority(""), Body("/x/y/z")));
+ AllOf(scheme("file"), authority(""), body("/x/y/z")));
EXPECT_THAT(parseOrDie("file:"),
- AllOf(Scheme("file"), Authority(""), Body("")));
+ AllOf(scheme("file"), authority(""), body("")));
EXPECT_THAT(parseOrDie("file:///x/y/z%2"),
- AllOf(Scheme("file"), Authority(""), Body("/x/y/z%2")));
+ AllOf(scheme("file"), authority(""), body("/x/y/z%2")));
EXPECT_THAT(parseOrDie("http://llvm.org"),
- AllOf(Scheme("http"), Authority("llvm.org"), Body("")));
+ AllOf(scheme("http"), authority("llvm.org"), body("")));
EXPECT_THAT(parseOrDie("http://llvm.org/"),
- AllOf(Scheme("http"), Authority("llvm.org"), Body("/")));
+ AllOf(scheme("http"), authority("llvm.org"), body("/")));
EXPECT_THAT(parseOrDie("http://llvm.org/D"),
- AllOf(Scheme("http"), Authority("llvm.org"), Body("/D")));
+ AllOf(scheme("http"), authority("llvm.org"), body("/D")));
EXPECT_THAT(parseOrDie("http:/"),
- AllOf(Scheme("http"), Authority(""), Body("/")));
+ AllOf(scheme("http"), authority(""), body("/")));
EXPECT_THAT(parseOrDie("urn:isbn:0451450523"),
- AllOf(Scheme("urn"), Authority(""), Body("isbn:0451450523")));
+ AllOf(scheme("urn"), authority(""), body("isbn:0451450523")));
EXPECT_THAT(
parseOrDie("file:///c:/windows/system32/"),
- AllOf(Scheme("file"), Authority(""), Body("/c:/windows/system32/")));
+ AllOf(scheme("file"), authority(""), body("/c:/windows/system32/")));
}
TEST(URITest, ParseFailed) {
MATCHER_P2(FileRange, File, Range, "") {
return Location{URIForFile::canonicalize(File, testRoot()), Range} == arg;
}
-MATCHER(DeclRange, "") {
+MATCHER(declRange, "") {
const LocatedSymbol &Sym = ::testing::get<0>(arg);
const Range &Range = ::testing::get<1>(arg);
return Sym.PreferredDeclaration.range == Range;
// Extracts ranges from an annotated example, and constructs a matcher for a
// highlight set. Ranges should be named $read/$write as appropriate.
Matcher<const std::vector<DocumentHighlight> &>
-HighlightsFrom(const Annotations &Test) {
+highlightsFrom(const Annotations &Test) {
std::vector<DocumentHighlight> Expected;
auto Add = [&](const Range &R, DocumentHighlightKind K) {
Expected.emplace_back();
auto TU = TestTU::withCode(T.code());
TU.ExtraArgs.push_back("-xobjective-c++");
auto AST = TU.build();
- EXPECT_THAT(findDocumentHighlights(AST, T.point()), HighlightsFrom(T))
+ EXPECT_THAT(findDocumentHighlights(AST, T.point()), highlightsFrom(T))
<< Test;
}
}
auto TU = TestTU::withCode(T.code());
TU.ExtraArgs.push_back("-fexceptions"); // FIXME: stop testing on PS4.
auto AST = TU.build();
- EXPECT_THAT(findDocumentHighlights(AST, T.point()), HighlightsFrom(T))
+ EXPECT_THAT(findDocumentHighlights(AST, T.point()), highlightsFrom(T))
<< Test;
}
}
-MATCHER_P3(Sym, Name, Decl, DefOrNone, "") {
+MATCHER_P3(sym, Name, Decl, DefOrNone, "") {
llvm::Optional<Range> Def = DefOrNone;
if (Name != arg.Name) {
*result_listener << "Name is " << arg.Name;
return true;
}
-MATCHER_P(Sym, Name, "") { return arg.Name == Name; }
+MATCHER_P(sym, Name, "") { return arg.Name == Name; }
-MATCHER_P(RangeIs, R, "") { return arg.Loc.range == R; }
-MATCHER_P(AttrsAre, A, "") { return arg.Attributes == A; }
-MATCHER_P(HasID, ID, "") { return arg.ID == ID; }
+MATCHER_P(rangeIs, R, "") { return arg.Loc.range == R; }
+MATCHER_P(attrsAre, A, "") { return arg.Attributes == A; }
+MATCHER_P(hasID, ID, "") { return arg.ID == ID; }
TEST(LocateSymbol, WithIndex) {
Annotations SymbolHeader(R"cpp(
}
)cpp");
EXPECT_THAT(LocateWithIndex(Test),
- ElementsAre(Sym("f1", Test.range(), SymbolCpp.range("f1"))));
+ ElementsAre(sym("f1", Test.range(), SymbolCpp.range("f1"))));
Test = Annotations(R"cpp(// definition in AST.
void [[f1]]() {}
}
)cpp");
EXPECT_THAT(LocateWithIndex(Test),
- ElementsAre(Sym("f1", SymbolHeader.range("f1"), Test.range())));
+ ElementsAre(sym("f1", SymbolHeader.range("f1"), Test.range())));
Test = Annotations(R"cpp(// forward declaration in AST.
class [[Foo]];
F^oo* create();
)cpp");
EXPECT_THAT(LocateWithIndex(Test),
- ElementsAre(Sym("Foo", Test.range(), SymbolHeader.range("foo"))));
+ ElementsAre(sym("Foo", Test.range(), SymbolHeader.range("foo"))));
Test = Annotations(R"cpp(// definition in AST.
class [[Forward]] {};
)cpp");
EXPECT_THAT(
LocateWithIndex(Test),
- ElementsAre(Sym("Forward", SymbolHeader.range("forward"), Test.range())));
+ ElementsAre(sym("Forward", SymbolHeader.range("forward"), Test.range())));
}
TEST(LocateSymbol, AnonymousStructFields) {
TestTU TU = TestTU::withCode(Code.code());
auto AST = TU.build();
EXPECT_THAT(locateSymbolAt(AST, Code.point("1"), TU.index().get()),
- UnorderedElementsAre(Sym("x", Code.range("1"), Code.range("1"))));
+ UnorderedElementsAre(sym("x", Code.range("1"), Code.range("1"))));
EXPECT_THAT(
locateSymbolAt(AST, Code.point("2"), TU.index().get()),
- UnorderedElementsAre(Sym("Foo", Code.range("2"), Code.range("2"))));
+ UnorderedElementsAre(sym("Foo", Code.range("2"), Code.range("2"))));
}
TEST(LocateSymbol, FindOverrides) {
TestTU TU = TestTU::withCode(Code.code());
auto AST = TU.build();
EXPECT_THAT(locateSymbolAt(AST, Code.point(), TU.index().get()),
- UnorderedElementsAre(Sym("foo", Code.range("1"), llvm::None),
- Sym("foo", Code.range("2"), llvm::None)));
+ UnorderedElementsAre(sym("foo", Code.range("1"), llvm::None),
+ sym("foo", Code.range("2"), llvm::None)));
}
TEST(LocateSymbol, WithIndexPreferredLocation) {
{
auto Locs = clangd::locateSymbolAt(AST, Test.point("p"), Index.get());
auto CodeGenLoc = SymbolHeader.range("p");
- EXPECT_THAT(Locs, ElementsAre(Sym("Proto", CodeGenLoc, CodeGenLoc)));
+ EXPECT_THAT(Locs, ElementsAre(sym("Proto", CodeGenLoc, CodeGenLoc)));
}
{
auto Locs = clangd::locateSymbolAt(AST, Test.point("f"), Index.get());
auto CodeGenLoc = SymbolHeader.range("f");
- EXPECT_THAT(Locs, ElementsAre(Sym("func", CodeGenLoc, CodeGenLoc)));
+ EXPECT_THAT(Locs, ElementsAre(sym("func", CodeGenLoc, CodeGenLoc)));
}
}
auto AST = TU.build();
auto Index = TU.index();
EXPECT_THAT(locateSymbolAt(AST, T.point("add"), Index.get()),
- ElementsAre(AllOf(Sym("add"),
- HasID(getSymbolID(&findDecl(AST, "add"))))));
+ ElementsAre(AllOf(sym("add"),
+ hasID(getSymbolID(&findDecl(AST, "add"))))));
EXPECT_THAT(
locateSymbolAt(AST, T.point("MACRO"), Index.get()),
- ElementsAre(AllOf(Sym("MACRO"),
- HasID(findSymbol(TU.headerSymbols(), "MACRO").ID))));
+ ElementsAre(AllOf(sym("MACRO"),
+ hasID(findSymbol(TU.headerSymbols(), "MACRO").ID))));
}
TEST(LocateSymbol, AllMulti) {
auto Index = TU.index();
EXPECT_THAT(
locateSymbolAt(AST, T.point(), Index.get()),
- ElementsAre(AllOf(Sym("MyClass", T.range(), T.range()),
- HasID(getSymbolID(&findDecl(AST, "MyClass"))))));
+ ElementsAre(AllOf(sym("MyClass", T.range(), T.range()),
+ hasID(getSymbolID(&findDecl(AST, "MyClass"))))));
}
TEST(LocateSymbol, Textual) {
TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
auto AST = TU.build();
// Ordered assertions are deliberate: we expect a predictable order.
- EXPECT_THAT(locateSymbolAt(AST, T.point("1")), ElementsAre(Sym("str")));
- EXPECT_THAT(locateSymbolAt(AST, T.point("2")), ElementsAre(Sym("str")));
- EXPECT_THAT(locateSymbolAt(AST, T.point("3")), ElementsAre(Sym("f")));
- EXPECT_THAT(locateSymbolAt(AST, T.point("4")), ElementsAre(Sym("g")));
- EXPECT_THAT(locateSymbolAt(AST, T.point("5")), ElementsAre(Sym("f")));
- EXPECT_THAT(locateSymbolAt(AST, T.point("6")), ElementsAre(Sym("str")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("1")), ElementsAre(sym("str")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("2")), ElementsAre(sym("str")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("3")), ElementsAre(sym("f")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("4")), ElementsAre(sym("g")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("5")), ElementsAre(sym("f")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("6")), ElementsAre(sym("str")));
// FIXME: Target the constructor as well.
- EXPECT_THAT(locateSymbolAt(AST, T.point("7")), ElementsAre(Sym("abc")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("7")), ElementsAre(sym("abc")));
// FIXME: Target the constructor as well.
- EXPECT_THAT(locateSymbolAt(AST, T.point("8")), ElementsAre(Sym("abcd")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("8")), ElementsAre(sym("abcd")));
// FIXME: Target the constructor as well.
- EXPECT_THAT(locateSymbolAt(AST, T.point("9")), ElementsAre(Sym("Foo")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("9")), ElementsAre(sym("Foo")));
EXPECT_THAT(locateSymbolAt(AST, T.point("10")),
- ElementsAre(Sym("Foo", T.range("ConstructorLoc"), llvm::None)));
+ ElementsAre(sym("Foo", T.range("ConstructorLoc"), llvm::None)));
EXPECT_THAT(locateSymbolAt(AST, T.point("11")),
- ElementsAre(Sym("Foo", T.range("ConstructorLoc"), llvm::None)));
+ ElementsAre(sym("Foo", T.range("ConstructorLoc"), llvm::None)));
// These assertions are unordered because the order comes from
// CXXRecordDecl::lookupDependentName() which doesn't appear to provide
// an order guarantee.
EXPECT_THAT(locateSymbolAt(AST, T.point("12")),
UnorderedElementsAre(
- Sym("bar", T.range("NonstaticOverload1"), llvm::None),
- Sym("bar", T.range("NonstaticOverload2"), llvm::None)));
+ sym("bar", T.range("NonstaticOverload1"), llvm::None),
+ sym("bar", T.range("NonstaticOverload2"), llvm::None)));
EXPECT_THAT(
locateSymbolAt(AST, T.point("13")),
- UnorderedElementsAre(Sym("baz", T.range("StaticOverload1"), llvm::None),
- Sym("baz", T.range("StaticOverload2"), llvm::None)));
+ UnorderedElementsAre(sym("baz", T.range("StaticOverload1"), llvm::None),
+ sym("baz", T.range("StaticOverload2"), llvm::None)));
}
TEST(LocateSymbol, TextualDependent) {
auto Results = locateSymbolAt(AST, Source.point(), Index.get());
EXPECT_THAT(Results,
UnorderedElementsAre(
- Sym("uniqueMethodName", Header.range("FooLoc"), llvm::None),
- Sym("uniqueMethodName", Header.range("BarLoc"), llvm::None)));
+ sym("uniqueMethodName", Header.range("FooLoc"), llvm::None),
+ sym("uniqueMethodName", Header.range("BarLoc"), llvm::None)));
}
TEST(LocateSymbol, Alias) {
auto T = Annotations(Case);
auto AST = TestTU::withCode(T.code()).build();
EXPECT_THAT(locateSymbolAt(AST, T.point()),
- UnorderedPointwise(DeclRange(), T.ranges()));
+ UnorderedPointwise(declRange(), T.ranges()));
}
}
auto Locations =
runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("p1"));
EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo", SourceAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo", SourceAnnotations.range(),
SourceAnnotations.range())));
// Go to a definition in header_in_preamble.h.
EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
EXPECT_THAT(
*Locations,
- ElementsAre(Sym("bar_preamble", HeaderInPreambleAnnotations.range(),
+ ElementsAre(sym("bar_preamble", HeaderInPreambleAnnotations.range(),
HeaderInPreambleAnnotations.range())));
// Go to a definition in header_not_in_preamble.h.
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("p3"));
EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
EXPECT_THAT(*Locations,
- ElementsAre(Sym("bar_not_preamble",
+ ElementsAre(sym("bar_not_preamble",
HeaderNotInPreambleAnnotations.range(),
HeaderNotInPreambleAnnotations.range())));
}
// Test include in preamble.
auto Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point());
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
// Test include in preamble, last char.
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("2"));
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("3"));
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
// Test include outside of preamble.
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("6"));
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
// Test a few positions that do not result in Locations.
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("5"));
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("7"));
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
// Objective C #import directive.
runAddDocument(Server, FooM, ObjC.code());
Locations = runLocateSymbolAt(Server, FooM, ObjC.point());
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
}
// LocateSymbol goes to a #include file: the result comes from the preamble.
EXPECT_THAT(
cantFail(runLocateSymbolAt(Server, FooCpp, FooWithHeader.point())),
- ElementsAre(Sym("foo.h", FooHeader.range(), FooHeader.range())));
+ ElementsAre(sym("foo.h", FooHeader.range(), FooHeader.range())));
// Only preamble is built, and no AST is built in this request.
Server.addDocument(FooCpp, FooWithoutHeader.code(), "null",
// stale one.
EXPECT_THAT(
cantFail(runLocateSymbolAt(Server, FooCpp, FooWithoutHeader.point())),
- ElementsAre(Sym("foo", FooWithoutHeader.range(), llvm::None)));
+ ElementsAre(sym("foo", FooWithoutHeader.range(), llvm::None)));
// Reset test environment.
runAddDocument(Server, FooCpp, FooWithHeader.code());
// Use the AST being built in above request.
EXPECT_THAT(
cantFail(runLocateSymbolAt(Server, FooCpp, FooWithoutHeader.point())),
- ElementsAre(Sym("foo", FooWithoutHeader.range(), llvm::None)));
+ ElementsAre(sym("foo", FooWithoutHeader.range(), llvm::None)));
}
TEST(LocateSymbol, NearbyTokenSmoke) {
auto AST = TestTU::withCode(T.code()).build();
// We don't pass an index, so can't hit index-based fallback.
EXPECT_THAT(locateSymbolAt(AST, T.point()),
- ElementsAre(Sym("err", T.range(), T.range())));
+ ElementsAre(sym("err", T.range(), T.range())));
}
TEST(LocateSymbol, NearbyIdentifier) {
for (StringRef Label : {"0", "1", "2", "3", "4", "5", "6", "7"}) {
for (const auto &Point : Code.points(Label)) {
EXPECT_THAT(findImplementations(AST, Point, Index.get()),
- UnorderedPointwise(DeclRange(), Code.ranges(Label)))
+ UnorderedPointwise(declRange(), Code.ranges(Label)))
<< Code.code() << " at " << Point << " for Label " << Label;
}
}
auto AST = TU.build();
EXPECT_THAT(
findImplementations(AST, Code.point(), TU.index().get()),
- UnorderedElementsAre(Sym("Foo", Code.range("Decl"), Code.range("Def")),
- Sym("Foo", Code.range("Child2"), llvm::None)))
+ UnorderedElementsAre(sym("Foo", Code.range("Decl"), Code.range("Def")),
+ sym("Foo", Code.range("Child2"), llvm::None)))
<< Test;
}
ASSERT_GT(A.points().size(), 0u) << Case;
for (auto Pos : A.points())
EXPECT_THAT(findType(AST, Pos),
- ElementsAre(Sym("Target", HeaderA.range(), HeaderA.range())))
+ ElementsAre(sym("Target", HeaderA.range(), HeaderA.range())))
<< Case;
}
ParsedAST AST = TU.build();
EXPECT_THAT(findType(AST, A.point()),
- Not(Contains(Sym("Target", HeaderA.range(), HeaderA.range()))))
+ Not(Contains(sym("Target", HeaderA.range(), HeaderA.range()))))
<< Case;
}
}
auto AST = TU.build();
std::vector<Matcher<ReferencesResult::Reference>> ExpectedLocations;
for (const auto &R : T.ranges())
- ExpectedLocations.push_back(AllOf(RangeIs(R), AttrsAre(0u)));
+ ExpectedLocations.push_back(AllOf(rangeIs(R), attrsAre(0u)));
// $def is actually shorthand for both definition and declaration.
// If we have cases that are definition-only, we should change this.
for (const auto &R : T.ranges("def"))
ExpectedLocations.push_back(
- AllOf(RangeIs(R), AttrsAre(ReferencesResult::Definition |
+ AllOf(rangeIs(R), attrsAre(ReferencesResult::Definition |
ReferencesResult::Declaration)));
for (const auto &R : T.ranges("decl"))
ExpectedLocations.push_back(
- AllOf(RangeIs(R), AttrsAre(ReferencesResult::Declaration)));
+ AllOf(rangeIs(R), attrsAre(ReferencesResult::Declaration)));
for (const auto &R : T.ranges("overridedecl"))
ExpectedLocations.push_back(AllOf(
- RangeIs(R),
- AttrsAre(ReferencesResult::Declaration | ReferencesResult::Override)));
+ rangeIs(R),
+ attrsAre(ReferencesResult::Declaration | ReferencesResult::Override)));
for (const auto &R : T.ranges("overridedef"))
ExpectedLocations.push_back(
- AllOf(RangeIs(R), AttrsAre(ReferencesResult::Declaration |
+ AllOf(rangeIs(R), attrsAre(ReferencesResult::Declaration |
ReferencesResult::Definition |
ReferencesResult::Override)));
for (const auto &P : T.points()) {
std::vector<Matcher<ReferencesResult::Reference>> ExpectedLocations;
for (const auto &R : Code.ranges())
- ExpectedLocations.push_back(RangeIs(R));
+ ExpectedLocations.push_back(rangeIs(R));
EXPECT_THAT(findReferences(AST, Code.point(), 0).References,
ElementsAreArray(ExpectedLocations))
<< Test;
// References in main file are returned without index.
EXPECT_THAT(
findReferences(AST, Main.point(), 0, /*Index=*/nullptr).References,
- ElementsAre(RangeIs(Main.range())));
+ ElementsAre(rangeIs(Main.range())));
Annotations IndexedMain(R"cpp(
int [[foo]]() { return 42; }
)cpp");
IndexedTU.HeaderCode = Header;
EXPECT_THAT(
findReferences(AST, Main.point(), 0, IndexedTU.index().get()).References,
- ElementsAre(RangeIs(Main.range()),
- AllOf(RangeIs(IndexedMain.range()),
- AttrsAre(ReferencesResult::Declaration |
+ ElementsAre(rangeIs(Main.range()),
+ AllOf(rangeIs(IndexedMain.range()),
+ attrsAre(ReferencesResult::Declaration |
ReferencesResult::Definition))));
auto LimitRefs =
findReferences(AST, Main.point(), /*Limit*/ 1, IndexedTU.index().get());
// Avoid indexed results for the main file. Use AST for the mainfile.
TU.Code = ("\n\n" + Main.code()).str();
EXPECT_THAT(findReferences(AST, Main.point(), 0, TU.index().get()).References,
- ElementsAre(RangeIs(Main.range())));
+ ElementsAre(rangeIs(Main.range())));
}
TEST(FindReferences, NeedsIndexForMacro) {
// References in main file are returned without index.
EXPECT_THAT(
findReferences(AST, Main.point(), 0, /*Index=*/nullptr).References,
- ElementsAre(RangeIs(Main.range())));
+ ElementsAre(rangeIs(Main.range())));
Annotations IndexedMain(R"cpp(
int indexed_main() {
IndexedTU.HeaderCode = Header;
EXPECT_THAT(
findReferences(AST, Main.point(), 0, IndexedTU.index().get()).References,
- ElementsAre(RangeIs(Main.range()), RangeIs(IndexedMain.range())));
+ ElementsAre(rangeIs(Main.range()), rangeIs(IndexedMain.range())));
auto LimitRefs =
findReferences(AST, Main.point(), /*Limit*/ 1, IndexedTU.index().get());
EXPECT_EQ(1u, LimitRefs.References.size());
int Counter(0); /* GUARDED_BY(Mutex) */
{
AsyncTaskRunner Tasks;
- auto scheduleIncrements = [&]() {
+ auto ScheduleIncrements = [&]() {
for (int TaskI = 0; TaskI < TasksCnt; ++TaskI) {
Tasks.runAsync("task", [&Counter, &Mutex, IncrementsPerTask]() {
for (int Increment = 0; Increment < IncrementsPerTask; ++Increment) {
// Make sure runAsync is not running tasks synchronously on the same
// thread by locking the Mutex used for increments.
std::lock_guard<std::mutex> Lock(Mutex);
- scheduleIncrements();
+ ScheduleIncrements();
}
Tasks.wait();
{
std::lock_guard<std::mutex> Lock(Mutex);
Counter = 0;
- scheduleIncrements();
+ ScheduleIncrements();
}
}
// Check that destructor has waited for tasks to finish.
using testing::SizeIs;
using testing::StartsWith;
-MATCHER_P(StringNode, Val, "") {
+MATCHER_P(stringNode, Val, "") {
if (arg->getType() != llvm::yaml::Node::NK_Scalar) {
*result_listener << "is a " << arg->getVerbatimTag();
return false;
// Checks that N is a Mapping (JS object) with the expected scalar properties.
// The object must have all the Expected properties, but may have others.
-bool VerifyObject(llvm::yaml::Node &N,
+bool verifyObject(llvm::yaml::Node &N,
std::map<std::string, std::string> Expected) {
auto *M = llvm::dyn_cast<llvm::yaml::MappingNode>(&N);
if (!M) {
// (The order doesn't matter, but the YAML parser is awkward to use otherwise)
auto Prop = Root->begin();
ASSERT_NE(Prop, Root->end()) << "Expected displayTimeUnit property";
- ASSERT_THAT(Prop->getKey(), StringNode("displayTimeUnit"));
- EXPECT_THAT(Prop->getValue(), StringNode("ns"));
+ ASSERT_THAT(Prop->getKey(), stringNode("displayTimeUnit"));
+ EXPECT_THAT(Prop->getValue(), stringNode("ns"));
ASSERT_NE(++Prop, Root->end()) << "Expected traceEvents property";
- EXPECT_THAT(Prop->getKey(), StringNode("traceEvents"));
+ EXPECT_THAT(Prop->getKey(), stringNode("traceEvents"));
auto *Events =
llvm::dyn_cast_or_null<llvm::yaml::SequenceNode>(Prop->getValue());
ASSERT_NE(Events, nullptr) << "traceEvents should be an array";
auto Event = Events->begin();
ASSERT_NE(Event, Events->end()) << "Expected process name";
- EXPECT_TRUE(VerifyObject(*Event, {{"ph", "M"}, {"name", "process_name"}}));
+ EXPECT_TRUE(verifyObject(*Event, {{"ph", "M"}, {"name", "process_name"}}));
if (ThreadsHaveNames) {
ASSERT_NE(++Event, Events->end()) << "Expected thread name";
- EXPECT_TRUE(VerifyObject(*Event, {{"ph", "M"}, {"name", "thread_name"}}));
+ EXPECT_TRUE(verifyObject(*Event, {{"ph", "M"}, {"name", "thread_name"}}));
}
ASSERT_NE(++Event, Events->end()) << "Expected log message";
- EXPECT_TRUE(VerifyObject(*Event, {{"ph", "i"}, {"name", "Log"}}));
+ EXPECT_TRUE(verifyObject(*Event, {{"ph", "i"}, {"name", "Log"}}));
ASSERT_NE(++Event, Events->end()) << "Expected span end";
- EXPECT_TRUE(VerifyObject(*Event, {{"ph", "X"}, {"name", "A"}}));
+ EXPECT_TRUE(verifyObject(*Event, {{"ph", "X"}, {"name", "A"}}));
ASSERT_EQ(++Event, Events->end());
ASSERT_EQ(++Prop, Root->end());
}