Move commonly useful code for AST testing into MatchVerfier.h.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@174057 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/unittests/AST/MatchVerifier.h b/unittests/AST/MatchVerifier.h
new file mode 100644
index 0000000..4706899
--- /dev/null
+++ b/unittests/AST/MatchVerifier.h
@@ -0,0 +1,194 @@
+//===- unittest/AST/MatchVerifier.h - AST unit test support ---------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Provides MatchVerifier, a base class to implement gtest matchers that
+// verify things that can be matched on the AST.
+//
+// Also implements matchers based on MatchVerifier:
+// LocationVerifier and RangeVerifier to verify whether a matched node has
+// the expected source location or source range.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Tooling/Tooling.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace ast_matchers {
+
+enum Language { Lang_C, Lang_C89, Lang_CXX };
+
+/// \brief Base class for verifying some property of nodes found by a matcher.
+template <typename NodeType>
+class MatchVerifier : public MatchFinder::MatchCallback {
+public:
+ template <typename MatcherType>
+ testing::AssertionResult match(const std::string &Code,
+ const MatcherType &AMatcher) {
+ return match(Code, AMatcher, Lang_CXX);
+ }
+
+ template <typename MatcherType>
+ testing::AssertionResult match(const std::string &Code,
+ const MatcherType &AMatcher, Language L);
+
+protected:
+ virtual void run(const MatchFinder::MatchResult &Result);
+ virtual void verify(const MatchFinder::MatchResult &Result,
+ const NodeType &Node) = 0;
+
+ void setFailure(const Twine &Result) {
+ Verified = false;
+ VerifyResult = Result.str();
+ }
+
+ void setSuccess() {
+ Verified = true;
+ }
+
+private:
+ bool Verified;
+ std::string VerifyResult;
+};
+
+/// \brief Runs a matcher over some code, and returns the result of the
+/// verifier for the matched node.
+template <typename NodeType> template <typename MatcherType>
+testing::AssertionResult MatchVerifier<NodeType>::match(
+ const std::string &Code, const MatcherType &AMatcher, Language L) {
+ MatchFinder Finder;
+ Finder.addMatcher(AMatcher.bind(""), this);
+ OwningPtr<tooling::FrontendActionFactory> Factory(
+ tooling::newFrontendActionFactory(&Finder));
+
+ std::vector<std::string> Args;
+ StringRef FileName;
+ switch (L) {
+ case Lang_C:
+ Args.push_back("-std=c99");
+ FileName = "input.c";
+ break;
+ case Lang_C89:
+ Args.push_back("-std=c89");
+ FileName = "input.c";
+ break;
+ case Lang_CXX:
+ Args.push_back("-std=c++98");
+ FileName = "input.cc";
+ break;
+ }
+
+ // Default to failure in case callback is never called
+ setFailure("Could not find match");
+ if (!tooling::runToolOnCodeWithArgs(Factory->create(), Code, Args, FileName))
+ return testing::AssertionFailure() << "Parsing error";
+ if (!Verified)
+ return testing::AssertionFailure() << VerifyResult;
+ return testing::AssertionSuccess();
+}
+
+template <typename NodeType>
+void MatchVerifier<NodeType>::run(const MatchFinder::MatchResult &Result) {
+ const NodeType *Node = Result.Nodes.getNodeAs<NodeType>("");
+ if (!Node) {
+ setFailure("Matched node has wrong type");
+ } else {
+ // Callback has been called, default to success.
+ setSuccess();
+ verify(Result, *Node);
+ }
+}
+
+/// \brief Verify whether a node has the correct source location.
+///
+/// By default, Node.getSourceLocation() is checked. This can be changed
+/// by overriding getLocation().
+template <typename NodeType>
+class LocationVerifier : public MatchVerifier<NodeType> {
+public:
+ void expectLocation(unsigned Line, unsigned Column) {
+ ExpectLine = Line;
+ ExpectColumn = Column;
+ }
+
+protected:
+ void verify(const MatchFinder::MatchResult &Result, const NodeType &Node) {
+ SourceLocation Loc = getLocation(Node);
+ unsigned Line = Result.SourceManager->getSpellingLineNumber(Loc);
+ unsigned Column = Result.SourceManager->getSpellingColumnNumber(Loc);
+ if (Line != ExpectLine || Column != ExpectColumn) {
+ std::string MsgStr;
+ llvm::raw_string_ostream Msg(MsgStr);
+ Msg << "Expected location <" << ExpectLine << ":" << ExpectColumn
+ << ">, found <";
+ Loc.print(Msg, *Result.SourceManager);
+ Msg << '>';
+ this->setFailure(Msg.str());
+ }
+ }
+
+ virtual SourceLocation getLocation(const NodeType &Node) {
+ return Node.getLocation();
+ }
+
+private:
+ unsigned ExpectLine, ExpectColumn;
+};
+
+/// \brief Verify whether a node has the correct source range.
+///
+/// By default, Node.getSourceRange() is checked. This can be changed
+/// by overriding getRange().
+template <typename NodeType>
+class RangeVerifier : public MatchVerifier<NodeType> {
+public:
+ void expectRange(unsigned BeginLine, unsigned BeginColumn,
+ unsigned EndLine, unsigned EndColumn) {
+ ExpectBeginLine = BeginLine;
+ ExpectBeginColumn = BeginColumn;
+ ExpectEndLine = EndLine;
+ ExpectEndColumn = EndColumn;
+ }
+
+protected:
+ void verify(const MatchFinder::MatchResult &Result, const NodeType &Node) {
+ SourceRange R = getRange(Node);
+ SourceLocation Begin = R.getBegin();
+ SourceLocation End = R.getEnd();
+ unsigned BeginLine = Result.SourceManager->getSpellingLineNumber(Begin);
+ unsigned BeginColumn = Result.SourceManager->getSpellingColumnNumber(Begin);
+ unsigned EndLine = Result.SourceManager->getSpellingLineNumber(End);
+ unsigned EndColumn = Result.SourceManager->getSpellingColumnNumber(End);
+ if (BeginLine != ExpectBeginLine || BeginColumn != ExpectBeginColumn ||
+ EndLine != ExpectEndLine || EndColumn != ExpectEndColumn) {
+ std::string MsgStr;
+ llvm::raw_string_ostream Msg(MsgStr);
+ Msg << "Expected range <" << ExpectBeginLine << ":" << ExpectBeginColumn
+ << '-' << ExpectEndLine << ":" << ExpectEndColumn << ">, found <";
+ Begin.print(Msg, *Result.SourceManager);
+ Msg << '-';
+ End.print(Msg, *Result.SourceManager);
+ Msg << '>';
+ this->setFailure(Msg.str());
+ }
+ }
+
+ virtual SourceRange getRange(const NodeType &Node) {
+ return Node.getSourceRange();
+ }
+
+private:
+ unsigned ExpectBeginLine, ExpectBeginColumn, ExpectEndLine, ExpectEndColumn;
+};
+
+} // end namespace ast_matchers
+} // end namespace clang
diff --git a/unittests/AST/SourceLocationTest.cpp b/unittests/AST/SourceLocationTest.cpp
index eaf9285..486c82f 100644
--- a/unittests/AST/SourceLocationTest.cpp
+++ b/unittests/AST/SourceLocationTest.cpp
@@ -21,175 +21,12 @@
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Tooling/Tooling.h"
#include "gtest/gtest.h"
+#include "MatchVerifier.h"
namespace clang {
namespace ast_matchers {
-using clang::tooling::newFrontendActionFactory;
-using clang::tooling::runToolOnCodeWithArgs;
-using clang::tooling::FrontendActionFactory;
-
-enum Language { Lang_C, Lang_C89, Lang_CXX };
-
-/// \brief Base class for verifying some property of nodes found by a matcher.
-///
-/// FIXME: This class should be shared with other AST tests.
-template <typename NodeType>
-class MatchVerifier : public MatchFinder::MatchCallback {
-public:
- template <typename MatcherType>
- testing::AssertionResult match(const std::string &Code,
- const MatcherType &AMatcher) {
- return match(Code, AMatcher, Lang_CXX);
- }
-
- template <typename MatcherType>
- testing::AssertionResult match(const std::string &Code,
- const MatcherType &AMatcher, Language L);
-
-protected:
- virtual void run(const MatchFinder::MatchResult &Result);
- virtual void verify(const MatchFinder::MatchResult &Result,
- const NodeType &Node) = 0;
-
- void setFailure(const Twine &Result) {
- Verified = false;
- VerifyResult = Result.str();
- }
-
-private:
- bool Verified;
- std::string VerifyResult;
-};
-
-/// \brief Runs a matcher over some code, and returns the result of the
-/// verifier for the matched node.
-template <typename NodeType> template <typename MatcherType>
-testing::AssertionResult MatchVerifier<NodeType>::match(
- const std::string &Code, const MatcherType &AMatcher, Language L) {
- MatchFinder Finder;
- Finder.addMatcher(AMatcher.bind(""), this);
- OwningPtr<FrontendActionFactory> Factory(newFrontendActionFactory(&Finder));
-
- std::vector<std::string> Args;
- StringRef FileName;
- switch (L) {
- case Lang_C:
- Args.push_back("-std=c99");
- FileName = "input.c";
- break;
- case Lang_C89:
- Args.push_back("-std=c89");
- FileName = "input.c";
- break;
- case Lang_CXX:
- Args.push_back("-std=c++98");
- FileName = "input.cc";
- break;
- }
-
- // Default to failure in case callback is never called
- setFailure("Could not find match");
- if (!runToolOnCodeWithArgs(Factory->create(), Code, Args, FileName))
- return testing::AssertionFailure() << "Parsing error";
- if (!Verified)
- return testing::AssertionFailure() << VerifyResult;
- return testing::AssertionSuccess();
-}
-
-template <typename NodeType>
-void MatchVerifier<NodeType>::run(const MatchFinder::MatchResult &Result) {
- const NodeType *Node = Result.Nodes.getNodeAs<NodeType>("");
- if (!Node) {
- setFailure("Matched node has wrong type");
- } else {
- // Callback has been called, default to success
- Verified = true;
- verify(Result, *Node);
- }
-}
-
-/// \brief Verify whether a node has the correct source location.
-///
-/// By default, Node.getSourceLocation() is checked. This can be changed
-/// by overriding getLocation().
-template <typename NodeType>
-class LocationVerifier : public MatchVerifier<NodeType> {
-public:
- void expectLocation(unsigned Line, unsigned Column) {
- ExpectLine = Line;
- ExpectColumn = Column;
- }
-
-protected:
- void verify(const MatchFinder::MatchResult &Result, const NodeType &Node) {
- SourceLocation Loc = getLocation(Node);
- unsigned Line = Result.SourceManager->getSpellingLineNumber(Loc);
- unsigned Column = Result.SourceManager->getSpellingColumnNumber(Loc);
- if (Line != ExpectLine || Column != ExpectColumn) {
- std::string MsgStr;
- llvm::raw_string_ostream Msg(MsgStr);
- Msg << "Expected location <" << ExpectLine << ":" << ExpectColumn
- << ">, found <";
- Loc.print(Msg, *Result.SourceManager);
- Msg << '>';
- this->setFailure(Msg.str());
- }
- }
-
- virtual SourceLocation getLocation(const NodeType &Node) {
- return Node.getLocation();
- }
-
-private:
- unsigned ExpectLine, ExpectColumn;
-};
-
-/// \brief Verify whether a node has the correct source range.
-///
-/// By default, Node.getSourceRange() is checked. This can be changed
-/// by overriding getRange().
-template <typename NodeType>
-class RangeVerifier : public MatchVerifier<NodeType> {
-public:
- void expectRange(unsigned BeginLine, unsigned BeginColumn,
- unsigned EndLine, unsigned EndColumn) {
- ExpectBeginLine = BeginLine;
- ExpectBeginColumn = BeginColumn;
- ExpectEndLine = EndLine;
- ExpectEndColumn = EndColumn;
- }
-
-protected:
- void verify(const MatchFinder::MatchResult &Result, const NodeType &Node) {
- SourceRange R = getRange(Node);
- SourceLocation Begin = R.getBegin();
- SourceLocation End = R.getEnd();
- unsigned BeginLine = Result.SourceManager->getSpellingLineNumber(Begin);
- unsigned BeginColumn = Result.SourceManager->getSpellingColumnNumber(Begin);
- unsigned EndLine = Result.SourceManager->getSpellingLineNumber(End);
- unsigned EndColumn = Result.SourceManager->getSpellingColumnNumber(End);
- if (BeginLine != ExpectBeginLine || BeginColumn != ExpectBeginColumn ||
- EndLine != ExpectEndLine || EndColumn != ExpectEndColumn) {
- std::string MsgStr;
- llvm::raw_string_ostream Msg(MsgStr);
- Msg << "Expected range <" << ExpectBeginLine << ":" << ExpectBeginColumn
- << '-' << ExpectEndLine << ":" << ExpectEndColumn << ">, found <";
- Begin.print(Msg, *Result.SourceManager);
- Msg << '-';
- End.print(Msg, *Result.SourceManager);
- Msg << '>';
- this->setFailure(Msg.str());
- }
- }
-
- virtual SourceRange getRange(const NodeType &Node) {
- return Node.getSourceRange();
- }
-
-private:
- unsigned ExpectBeginLine, ExpectBeginColumn, ExpectEndLine, ExpectEndColumn;
-};
+// FIXME: Pull the *Verifier tests into their own test file.
TEST(MatchVerifier, ParseError) {
LocationVerifier<VarDecl> Verifier;
