Page MenuHomePhabricator

Please use GitHub pull requests for new patches. Phabricator shutdown timeline

Differential D61774 Diff 199896 clang/unittests/Tooling/RangeSelectorTest.cpp

Changeset View

Standalone View

View Options

clang/unittests/Tooling/RangeSelectorTest.cpp

  • This file was added.
//===- unittest/Tooling/RangeSelectorTest.cpp -----------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "clang/Tooling/Refactoring/RangeSelector.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Tooling/FixIt.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/Support/Error.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using namespace clang;
using namespace tooling;
using namespace ast_matchers;
namespace {
using ::testing::AllOf;
using ::testing::Eq;
using ::testing::HasSubstr;
using MatchResult = MatchFinder::MatchResult;
using ::llvm::Expected;
using ::llvm::Optional;
struct TestMatch {
// The AST unit from which `result` is built. We bundle it because it backs
// the result. Users are not expected to access it.
std::unique_ptr<ASTUnit> AstUnit;
// The result to use in the test. References `ast_unit`.
MatchResult Result;
};
template <typename M>
llvm::Optional<TestMatch> matchAny(StringRef Code, M Matcher) {
auto AstUnit = buildASTFromCode(Code);
ilya-biryukovUnsubmitted
Done
ReplyInline Actions

NIT: use ASTUnit to match LLVM naming rules

ilya-biryukov: NIT: use `ASTUnit` to match LLVM naming rules
if (AstUnit == nullptr) {
ADD_FAILURE() << "AST construction failed";
return llvm::None;
}
ASTContext &Context = AstUnit->getASTContext();
if (Context.getDiagnostics().hasErrorOccurred()) {
ADD_FAILURE() << "Compilation error";
return llvm::None;
}
auto Matches = ast_matchers::match(Matcher, Context);
// We expect a single, exact match.
if (Matches.size() != 1) {
ADD_FAILURE() << "Wrong number of matches: " << Matches.size();
return llvm::None;
}
return TestMatch{std::move(AstUnit), MatchResult(Matches[0], &Context)};
}
template <typename M>
void test(M Matcher, RangeSelector Selector, StringRef Code,
StringRef Selected) {
Optional<TestMatch> Match = matchAny(Code, Matcher);
ASSERT_TRUE(Match);
MatchResult &Result = Match->Result;
if (Expected<CharSourceRange> Range = Selector(Result))
EXPECT_EQ(fixit::internal::getText(*Range, *Result.Context), Selected);
else
ADD_FAILURE() << llvm::toString(Range.takeError());
}
// Verifies that \c Selector fails when evaluated on \c Code.
template <typename M>
void testError(M Matcher, const RangeSelector &Selector, StringRef Code,
::testing::Matcher<std::string> ErrorMatcher) {
Optional<TestMatch> Match = matchAny(Code, Matcher);
ASSERT_TRUE(Match);
auto Range = Selector(Match->Result);
if (Range) {
ADD_FAILURE() << "Expected failure but succeeded";
return;
}
auto Err = llvm::handleErrors(Range.takeError(),
[&ErrorMatcher](const llvm::StringError &Err) {
EXPECT_THAT(Err.getMessage(), ErrorMatcher);
});
if (Err)
ADD_FAILURE() << "Unhandled error: " << llvm::toString(std::move(Err));
}
// Tests failures caused by references to unbound nodes. `UnboundID` is the ID
// that will cause the failure.
void testUnboundNodeError(const RangeSelector &S, llvm::StringRef UnboundID) {
// We need to bind the result to something, or the match will fail. Create an
// ID from UnboundID to ensure they are different.
std::string BoundID = (UnboundID + "_").str();
testError(varDecl().bind(BoundID), S, "static int x = 0;",
AllOf(HasSubstr(UnboundID), HasSubstr("not bound")));
}
// Tests failures caused by operations applied to nodes of the wrong type. For
// convenience, binds a statement to "stmt", a (non-member) ctor-initializer to
// "init", an expression to "expr" and a (nameless) declaration to "decl".
void testTypeError(const RangeSelector &Selector, llvm::StringRef NodeID) {
StringRef Code = R"cc(
struct A {};
class F : public A {
public:
F(int) {}
};
void g() { F f(1); }
)cc";
auto Matcher =
compoundStmt(
hasDescendant(
cxxConstructExpr(
hasDeclaration(
decl(hasDescendant(cxxCtorInitializer(isBaseInitializer())
.bind("init")))
.bind("decl")))
.bind("expr")))
.bind("stmt");
testError(Matcher, Selector, Code,
AllOf(HasSubstr(NodeID), HasSubstr("mismatched type")));
}
TEST(RangeSelectorTest, UnboundNode) {
testUnboundNodeError(node("unbound"), "unbound");
}
TEST(RangeSelectorTest, RangeOp) {
StringRef Code = R"cc(
int f(int x, int y, int z) { return 3; }
int g() { return f(/* comment */ 3, 7 /* comment */, 9); }
)cc";
StringRef Arg0 = "a0";
StringRef Arg1 = "a1";
StringRef Call = "call";
auto Matcher = callExpr(hasArgument(0, expr().bind(Arg0)),
hasArgument(1, expr().bind(Arg1)))
.bind(Call);
// Node-id specific version:
test(Matcher, range(Arg0, Arg1), Code, "3, 7");
ilya-biryukovUnsubmitted
Done
ReplyInline Actions

Consider restructuring the code to place assertions into the test function itself.
This wildly improves locations reported in case of test failures and makes tests easier to read.

I.e. having something like

auto AST = buildASTAndMatch(Code, Matcher);
EXPECT_EQ(applySelector(range(Arg0, Arg1), AST),  "3, 7");

is arguably both easier to read and produces better location information on failures than a function that runs the test.
Even though it's a bit more code.

Note that it's a bit more complicated if you need to deal with Expected<> return types, but still possible:

EXPECT_THAT_EXPECTED(applySelector(range(Arg0, Arg1), AST),  HasValue("3, 7"));
EXPECT_THAT_EXPECTED(applySelector(range(Arg1, Arg0), AST),  Failed());
ilya-biryukov: Consider restructuring the code to place assertions into the test function itself. This wildly…
ymandelAuthorUnsubmitted
Done
ReplyInline Actions

Thanks for the suggestion. Thoroughly reworked the tests along these lines. I think the result is much clearer.

ymandel: Thanks for the suggestion. Thoroughly reworked the tests along these lines. I think the result…
// General version:
test(Matcher, range(node(Arg0), node(Arg1)), Code, "3, 7");
}
TEST(RangeSelectorTest, NodeOpStatement) {
StringRef Code = "int f() { return 3; }";
StringRef ID = "id";
test(returnStmt().bind(ID), node(ID), Code, "return 3;");
}
TEST(RangeSelectorTest, NodeOpExpression) {
StringRef Code = "int f() { return 3; }";
StringRef ID = "id";
test(expr().bind(ID), node(ID), Code, "3");
}
TEST(RangeSelectorTest, StatementOp) {
StringRef Code = "int f() { return 3; }";
StringRef ID = "id";
test(expr().bind(ID), statement(ID), Code, "3;");
}
TEST(RangeSelectorTest, MemberOp) {
StringRef Code = R"cc(
struct S {
int member;
};
int g() {
S s;
return s.member;
}
)cc";
StringRef ID = "id";
test(memberExpr().bind(ID), member(ID), Code, "member");
}
// Tests that member does not select any qualifiers on the member name.
TEST(RangeSelectorTest, MemberOpQualified) {
StringRef Code = R"cc(
struct S {
int member;
};
struct T : public S {
int field;
};
int g() {
T t;
return t.S::member;
}
)cc";
StringRef ID = "id";
test(memberExpr().bind(ID), member(ID), Code, "member");
}
TEST(RangeSelectorTest, MemberOpTemplate) {
StringRef Code = R"cc(
struct S {
template <typename T> T foo(T t);
};
int f(int x) {
S s;
return s.template foo<int>(3);
}
)cc";
StringRef ID = "id";
test(memberExpr().bind(ID), member(ID), Code, "foo");
}
TEST(RangeSelectorTest, MemberOpOperator) {
StringRef Code = R"cc(
struct S {
int operator*();
};
int f(int x) {
S s;
return s.operator *();
}
)cc";
StringRef ID = "id";
test(memberExpr().bind(ID), member(ID), Code, "operator *");
}
TEST(RangeSelectorTest, NameOpNamedDecl) {
StringRef Code = R"cc(
int myfun() {
return 3;
}
)cc";
StringRef ID = "id";
test(functionDecl().bind(ID), name(ID), Code, "myfun");
}
TEST(RangeSelectorTest, NameOpDeclRef) {
StringRef Code = R"cc(
int foo(int x) {
return x;
}
int g(int x) { return foo(x) * x; }
)cc";
StringRef Ref = "ref";
test(declRefExpr(to(functionDecl())).bind(Ref), name(Ref), Code, "foo");
}
TEST(RangeSelectorTest, NameOpCtorInitializer) {
StringRef Code = R"cc(
class C {
public:
C() : field(3) {}
int field;
};
)cc";
StringRef Init = "init";
test(cxxCtorInitializer().bind(Init), name(Init), Code, "field");
}
TEST(RangeSelectorTest, NameOpErrors) {
testUnboundNodeError(name("unbound"), "unbound");
testTypeError(name("stmt"), "stmt");
}
TEST(RangeSelectorTest, NameOpDeclRefError) {
StringRef Code = R"cc(
struct S {
int operator*();
};
int f(int x) {
S s;
return *s + x;
}
)cc";
StringRef Ref = "ref";
testError(declRefExpr(to(functionDecl())).bind(Ref), name(Ref), Code,
AllOf(HasSubstr(Ref), HasSubstr("requires property 'identifier'")));
}
TEST(RangeSelectorTest, CallArgsOp) {
const StringRef Code = R"cc(
struct C {
int bar(int, int);
};
int f() {
C x;
return x.bar(3, 4);
}
)cc";
StringRef ID = "id";
test(callExpr().bind(ID), callArgs(ID), Code, "3, 4");
}
TEST(RangeSelectorTest, CallArgsOpNoArgs) {
const StringRef Code = R"cc(
struct C {
int bar();
};
int f() {
C x;
return x.bar();
}
)cc";
StringRef ID = "id";
test(callExpr().bind(ID), callArgs(ID), Code, "");
}
TEST(RangeSelectorTest, CallArgsOpNoArgsWithComments) {
const StringRef Code = R"cc(
struct C {
int bar();
};
int f() {
C x;
return x.bar(/*empty*/);
}
)cc";
StringRef ID = "id";
test(callExpr().bind(ID), callArgs(ID), Code, "/*empty*/");
}
// Tests that arguments are extracted correctly when a temporary (with parens)
// is used.
TEST(RangeSelectorTest, CallArgsOpWithParens) {
const StringRef Code = R"cc(
struct C {
int bar(int, int) { return 3; }
};
int f() {
C x;
return C().bar(3, 4);
}
)cc";
StringRef ID = "id";
test(callExpr(callee(functionDecl(hasName("bar")))).bind(ID), callArgs(ID),
Code, "3, 4");
}
TEST(RangeSelectorTest, CallArgsOpLeadingComments) {
const StringRef Code = R"cc(
struct C {
int bar(int, int) { return 3; }
};
int f() {
C x;
return x.bar(/*leading*/ 3, 4);
}
)cc";
StringRef ID = "id";
test(callExpr().bind(ID), callArgs(ID), Code, "/*leading*/ 3, 4");
}
TEST(RangeSelectorTest, CallArgsOpTrailingComments) {
const StringRef Code = R"cc(
struct C {
int bar(int, int) { return 3; }
};
int f() {
C x;
return x.bar(3 /*trailing*/, 4);
}
)cc";
StringRef ID = "id";
test(callExpr().bind(ID), callArgs(ID), Code, "3 /*trailing*/, 4");
}
TEST(RangeSelectorTest, CallArgsOpEolComments) {
const StringRef Code = R"cc(
struct C {
int bar(int, int) { return 3; }
};
int f() {
C x;
return x.bar( // Header
1, // foo
2 // bar
);
}
)cc";
StringRef ID = "id";
test(callExpr().bind(ID), callArgs(ID), Code, R"( // Header
1, // foo
2 // bar
)");
}
TEST(RangeSelectorTest, CallArgsErrors) {
testUnboundNodeError(callArgs("unbound"), "unbound");
testTypeError(callArgs("stmt"), "stmt");
}
TEST(RangeSelectorTest, StatementsOp) {
StringRef Code = R"cc(
void g();
void f() { /* comment */ g(); /* comment*/ g(); /* comment */ }
)cc";
StringRef ID = "id";
test(compoundStmt().bind(ID), statements(ID), Code,
" /* comment */ g(); /* comment*/ g(); /* comment */ ");
}
TEST(RangeSelectorTest, StatementsOpEmptyList) {
StringRef Code = "void f() {}";
StringRef ID = "id";
test(compoundStmt().bind(ID), statements(ID), Code, "");
}
TEST(RangeSelectorTest, StatementsOpErrors) {
testUnboundNodeError(statements("unbound"), "unbound");
testTypeError(statements("decl"), "decl");
}
TEST(RangeSelectorTest, ElementsOp) {
StringRef Code = R"cc(
void f() {
int v[] = {/* comment */ 3, /* comment*/ 4 /* comment */};
(void)v;
}
)cc";
StringRef ID = "id";
test(initListExpr().bind(ID), initListElements(ID), Code,
"/* comment */ 3, /* comment*/ 4 /* comment */");
}
TEST(RangeSelectorTest, ElementsOpEmptyList) {
StringRef Code = R"cc(
void f() {
int v[] = {};
(void)v;
}
)cc";
StringRef ID = "id";
test(initListExpr().bind(ID), initListElements(ID), Code, "");
}
TEST(RangeSelectorTest, ElementsOpErrors) {
testUnboundNodeError(initListElements("unbound"), "unbound");
testTypeError(initListElements("stmt"), "stmt");
}
// Tests case where the matched node is the complete expanded text.
TEST(RangeSelectorTest, ExpansionOp) {
StringRef Code = R"cc(
#define BADDECL(E) int bad(int x) { return E; }
BADDECL(x * x)
)cc";
StringRef Fun = "Fun";
test(functionDecl(hasName("bad")).bind(Fun), expansion(node(Fun)), Code,
"BADDECL(x * x)");
}
// Tests case where the matched node is (only) part of the expanded text.
TEST(RangeSelectorTest, ExpansionOpPartial) {
StringRef Code = R"cc(
#define BADDECL(E) int bad(int x) { return E; }
BADDECL(x * x)
)cc";
StringRef Ret = "Ret";
test(returnStmt().bind(Ret), expansion(node(Ret)), Code, "BADDECL(x * x)");
}
} // namespace