This is an archive of the discontinued LLVM Phabricator instance.

Differential D47847

[clangd] Simplify matches in FindSymbols tests
ClosedPublic

Authored by malaperle on Jun 6 2018, 2:36 PM.

Details

Reviewers
simark
malaperle
Commits
rG9e8a24df5bfb: [clangd] Simplify matches in FindSymbols tests
rCTE335624: [clangd] Simplify matches in FindSymbols tests
rL335624: [clangd] Simplify matches in FindSymbols tests
Summary

Instead of checking symbol name and container (scope) separately, check the
qualified name instead. This is much shorter and similar to how it is done
in the SymbolCollector tests.

Signed-off-by: Marc-Andre Laperle <marc-andre.laperle@ericsson.com>

Diff Detail

Repository
rL LLVM

Event Timeline

malaperle created this revision.Jun 6 2018, 2:36 PM
Harbormaster completed remote builds in B19014: Diff 150201.Jun 6 2018, 2:36 PM
Herald added subscribers: cfe-commits, jkorous, MaskRay and 2 others. · View Herald TranscriptJun 6 2018, 2:36 PM
malaperle added a reviewer: simark.Jun 6 2018, 2:40 PM
malaperle updated this revision to Diff 152536.Jun 22 2018, 1:04 PM

Rebased.

malaperle accepted this revision.Jun 26 2018, 9:58 AM

Self-approving because this is pretty inconsequential.

This revision is now accepted and ready to land.Jun 26 2018, 9:58 AM
Closed by commit rL335624: [clangd] Simplify matches in FindSymbols tests (authored by malaperle). · Explain WhyJun 26 2018, 10:02 AM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptJun 26 2018, 10:02 AM

Revision Contents

PathSize
clang-tools-extra/
trunk/
unittests/
clangd/
104 lines

Diff 152908

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

Show All 25 Lines
using ::testing::UnorderedElementsAre; using ::testing::UnorderedElementsAre;
class IgnoreDiagnostics : public DiagnosticsConsumer { class IgnoreDiagnostics : public DiagnosticsConsumer {
void onDiagnosticsReady(PathRef File, void onDiagnosticsReady(PathRef File,
std::vector<Diag> Diagnostics) override {} std::vector<Diag> Diagnostics) override {}
}; };
// GMock helpers for matching SymbolInfos items. // GMock helpers for matching SymbolInfos items.
MATCHER_P(Named, Name, "") { return arg.name == Name; } MATCHER_P(QName, Name, "") {
MATCHER_P(InContainer, ContainerName, "") { if (arg.containerName.empty())
return arg.containerName == ContainerName; return arg.name == Name;
return (arg.containerName + "::" + arg.name) == Name;
} }
MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; } MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; }
ClangdServer::Options optsForTests() { ClangdServer::Options optsForTests() {
auto ServerOpts = ClangdServer::optsForTest(); auto ServerOpts = ClangdServer::optsForTest();
ServerOpts.BuildDynamicSymbolIndex = true; ServerOpts.BuildDynamicSymbolIndex = true;
ServerOpts.URISchemes = {"unittest", "file"}; ServerOpts.URISchemes = {"unittest", "file"};
return ServerOpts; return ServerOpts;
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines addFile("foo.h", R"cpp(
int global_func(); int global_func();
struct GlobalStruct {};)cpp"); struct GlobalStruct {};)cpp");
addFile("foo.cpp", R"cpp( addFile("foo.cpp", R"cpp(
#include "foo.h" #include "foo.h"
)cpp"); )cpp");
EXPECT_THAT(getSymbols("global"), EXPECT_THAT(getSymbols("global"),
UnorderedElementsAre(AllOf(Named("GlobalStruct"), InContainer(""), UnorderedElementsAre(
WithKind(SymbolKind::Struct)), AllOf(QName("GlobalStruct"), WithKind(SymbolKind::Struct)),
AllOf(Named("global_func"), InContainer(""), AllOf(QName("global_func"), WithKind(SymbolKind::Function)),
WithKind(SymbolKind::Function)), AllOf(QName("global_var"), WithKind(SymbolKind::Variable))));
AllOf(Named("global_var"), InContainer(""),
WithKind(SymbolKind::Variable))));
} }
TEST_F(WorkspaceSymbolsTest, Unnamed) { TEST_F(WorkspaceSymbolsTest, Unnamed) {
addFile("foo.h", R"cpp( addFile("foo.h", R"cpp(
struct { struct {
int InUnnamed; int InUnnamed;
} UnnamedStruct;)cpp"); } UnnamedStruct;)cpp");
addFile("foo.cpp", R"cpp( addFile("foo.cpp", R"cpp(
#include "foo.h" #include "foo.h"
)cpp"); )cpp");
EXPECT_THAT(getSymbols("UnnamedStruct"), EXPECT_THAT(getSymbols("UnnamedStruct"),
ElementsAre(AllOf(Named("UnnamedStruct"), ElementsAre(AllOf(QName("UnnamedStruct"),
WithKind(SymbolKind::Variable)))); WithKind(SymbolKind::Variable))));
EXPECT_THAT( EXPECT_THAT(getSymbols("InUnnamed"),
getSymbols("InUnnamed"), ElementsAre(AllOf(QName("(anonymous struct)::InUnnamed"),
ElementsAre(AllOf(Named("InUnnamed"), InContainer("(anonymous struct)"),
WithKind(SymbolKind::Field)))); WithKind(SymbolKind::Field))));
} }
TEST_F(WorkspaceSymbolsTest, InMainFile) { TEST_F(WorkspaceSymbolsTest, InMainFile) {
addFile("foo.cpp", R"cpp( addFile("foo.cpp", R"cpp(
int test() { int test() {
} }
)cpp"); )cpp");
EXPECT_THAT(getSymbols("test"), IsEmpty()); EXPECT_THAT(getSymbols("test"), IsEmpty());
} }
TEST_F(WorkspaceSymbolsTest, Namespaces) { TEST_F(WorkspaceSymbolsTest, Namespaces) {
addFile("foo.h", R"cpp( addFile("foo.h", R"cpp(
namespace ans1 { namespace ans1 {
int ai1; int ai1;
namespace ans2 { namespace ans2 {
int ai2; int ai2;
} }
} }
)cpp"); )cpp");
addFile("foo.cpp", R"cpp( addFile("foo.cpp", R"cpp(
#include "foo.h" #include "foo.h"
)cpp"); )cpp");
EXPECT_THAT( EXPECT_THAT(getSymbols("a"),
getSymbols("a"), UnorderedElementsAre(QName("ans1"), QName("ans1::ai1"),
UnorderedElementsAre(AllOf(Named("ans1"), InContainer("")), QName("ans1::ans2"),
AllOf(Named("ai1"), InContainer("ans1")), QName("ans1::ans2::ai2")));
AllOf(Named("ans2"), InContainer("ans1")), EXPECT_THAT(getSymbols("::"), ElementsAre(QName("ans1")));
AllOf(Named("ai2"), InContainer("ans1::ans2")))); EXPECT_THAT(getSymbols("::a"), ElementsAre(QName("ans1")));
EXPECT_THAT(getSymbols("::"),
ElementsAre(AllOf(Named("ans1"), InContainer(""))));
EXPECT_THAT(getSymbols("::a"),
ElementsAre(AllOf(Named("ans1"), InContainer(""))));
EXPECT_THAT(getSymbols("ans1::"), EXPECT_THAT(getSymbols("ans1::"),
UnorderedElementsAre(AllOf(Named("ai1"), InContainer("ans1")), UnorderedElementsAre(QName("ans1::ai1"), QName("ans1::ans2")));
AllOf(Named("ans2"), InContainer("ans1")))); EXPECT_THAT(getSymbols("::ans1"), ElementsAre(QName("ans1")));
EXPECT_THAT(getSymbols("::ans1"),
ElementsAre(AllOf(Named("ans1"), InContainer(""))));
EXPECT_THAT(getSymbols("::ans1::"), EXPECT_THAT(getSymbols("::ans1::"),
UnorderedElementsAre(AllOf(Named("ai1"), InContainer("ans1")), UnorderedElementsAre(QName("ans1::ai1"), QName("ans1::ans2")));
AllOf(Named("ans2"), InContainer("ans1")))); EXPECT_THAT(getSymbols("::ans1::ans2"), ElementsAre(QName("ans1::ans2")));
EXPECT_THAT(getSymbols("::ans1::ans2"),
ElementsAre(AllOf(Named("ans2"), InContainer("ans1"))));
EXPECT_THAT(getSymbols("::ans1::ans2::"), EXPECT_THAT(getSymbols("::ans1::ans2::"),
ElementsAre(AllOf(Named("ai2"), InContainer("ans1::ans2")))); ElementsAre(QName("ans1::ans2::ai2")));
} }
TEST_F(WorkspaceSymbolsTest, AnonymousNamespace) { TEST_F(WorkspaceSymbolsTest, AnonymousNamespace) {
addFile("foo.h", R"cpp( addFile("foo.h", R"cpp(
namespace { namespace {
void test() {} void test() {}
} }
)cpp"); )cpp");
Show All 12 Lines addFile("foo2.h", R"cpp(
int foo2() { int foo2() {
} }
)cpp"); )cpp");
addFile("foo.cpp", R"cpp( addFile("foo.cpp", R"cpp(
#include "foo.h" #include "foo.h"
#include "foo2.h" #include "foo2.h"
)cpp"); )cpp");
EXPECT_THAT(getSymbols("foo"), EXPECT_THAT(getSymbols("foo"),
UnorderedElementsAre(AllOf(Named("foo"), InContainer("")), UnorderedElementsAre(QName("foo"), QName("foo2")));
AllOf(Named("foo2"), InContainer(""))));
} }
TEST_F(WorkspaceSymbolsTest, GlobalNamespaceQueries) { TEST_F(WorkspaceSymbolsTest, GlobalNamespaceQueries) {
addFile("foo.h", R"cpp( addFile("foo.h", R"cpp(
int foo() { int foo() {
} }
class Foo { class Foo {
int a; int a;
}; };
namespace ns { namespace ns {
int foo2() { int foo2() {
} }
} }
)cpp"); )cpp");
addFile("foo.cpp", R"cpp( addFile("foo.cpp", R"cpp(
#include "foo.h" #include "foo.h"
)cpp"); )cpp");
EXPECT_THAT( EXPECT_THAT(getSymbols("::"),
getSymbols("::"),
UnorderedElementsAre( UnorderedElementsAre(
AllOf(Named("Foo"), InContainer(""), WithKind(SymbolKind::Class)), AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
AllOf(Named("foo"), InContainer(""), WithKind(SymbolKind::Function)), AllOf(QName("foo"), WithKind(SymbolKind::Function)),
AllOf(Named("ns"), InContainer(""), AllOf(QName("ns"), WithKind(SymbolKind::Namespace))));
WithKind(SymbolKind::Namespace))));
EXPECT_THAT(getSymbols(":"), IsEmpty()); EXPECT_THAT(getSymbols(":"), IsEmpty());
EXPECT_THAT(getSymbols(""), IsEmpty()); EXPECT_THAT(getSymbols(""), IsEmpty());
} }
TEST_F(WorkspaceSymbolsTest, Enums) { TEST_F(WorkspaceSymbolsTest, Enums) {
addFile("foo.h", R"cpp( addFile("foo.h", R"cpp(
enum { enum {
Red Red
Show All 14 Lines namespace ns {
enum class Color4 { enum class Color4 {
White White
}; };
} }
)cpp"); )cpp");
addFile("foo.cpp", R"cpp( addFile("foo.cpp", R"cpp(
#include "foo.h" #include "foo.h"
)cpp"); )cpp");
EXPECT_THAT(getSymbols("Red"), ElementsAre(Named("Red"))); EXPECT_THAT(getSymbols("Red"), ElementsAre(QName("Red")));
EXPECT_THAT(getSymbols("::Red"), ElementsAre(Named("Red"))); EXPECT_THAT(getSymbols("::Red"), ElementsAre(QName("Red")));
EXPECT_THAT(getSymbols("Green"), ElementsAre(Named("Green"))); EXPECT_THAT(getSymbols("Green"), ElementsAre(QName("Green")));
EXPECT_THAT(getSymbols("Green"), ElementsAre(Named("Green"))); EXPECT_THAT(getSymbols("Green"), ElementsAre(QName("Green")));
EXPECT_THAT(getSymbols("Color2::Yellow"), ElementsAre(Named("Yellow"))); EXPECT_THAT(getSymbols("Color2::Yellow"),
EXPECT_THAT(getSymbols("Yellow"), ElementsAre(Named("Yellow"))); ElementsAre(QName("Color2::Yellow")));
EXPECT_THAT(getSymbols("Yellow"), ElementsAre(QName("Color2::Yellow")));
EXPECT_THAT(getSymbols("ns::Black"), ElementsAre(Named("Black")));
EXPECT_THAT(getSymbols("ns::Blue"), ElementsAre(Named("Blue"))); EXPECT_THAT(getSymbols("ns::Black"), ElementsAre(QName("ns::Black")));
EXPECT_THAT(getSymbols("ns::Color4::White"), ElementsAre(Named("White"))); EXPECT_THAT(getSymbols("ns::Blue"), ElementsAre(QName("ns::Blue")));
EXPECT_THAT(getSymbols("ns::Color4::White"),
ElementsAre(QName("ns::Color4::White")));
} }
TEST_F(WorkspaceSymbolsTest, Ranking) { TEST_F(WorkspaceSymbolsTest, Ranking) {
addFile("foo.h", R"cpp( addFile("foo.h", R"cpp(
namespace ns{} namespace ns{}
function func(); function func();
)cpp"); )cpp");
addFile("foo.cpp", R"cpp( addFile("foo.cpp", R"cpp(
#include "foo.h" #include "foo.h"
)cpp"); )cpp");
EXPECT_THAT(getSymbols("::"), ElementsAre(Named("func"), Named("ns"))); EXPECT_THAT(getSymbols("::"), ElementsAre(QName("func"), QName("ns")));
} }
TEST_F(WorkspaceSymbolsTest, WithLimit) { TEST_F(WorkspaceSymbolsTest, WithLimit) {
addFile("foo.h", R"cpp( addFile("foo.h", R"cpp(
int foo; int foo;
int foo2; int foo2;
)cpp"); )cpp");
addFile("foo.cpp", R"cpp( addFile("foo.cpp", R"cpp(
#include "foo.h" #include "foo.h"
)cpp"); )cpp");
// Foo is higher ranked because of exact name match. // Foo is higher ranked because of exact name match.
EXPECT_THAT(getSymbols("foo"), EXPECT_THAT(getSymbols("foo"),
UnorderedElementsAre(AllOf(Named("foo"), InContainer(""), UnorderedElementsAre(
WithKind(SymbolKind::Variable)), AllOf(QName("foo"), WithKind(SymbolKind::Variable)),
AllOf(Named("foo2"), InContainer(""), AllOf(QName("foo2"), WithKind(SymbolKind::Variable))));
WithKind(SymbolKind::Variable))));
Limit = 1; Limit = 1;
EXPECT_THAT(getSymbols("foo"), ElementsAre(Named("foo"))); EXPECT_THAT(getSymbols("foo"), ElementsAre(QName("foo")));
} }
} // namespace clangd } // namespace clangd
} // namespace clang } // namespace clang