From c72c57c9e9b69944e3e009cd5e209634839581d3 Mon Sep 17 00:00:00 2001 From: dim Date: Mon, 8 Apr 2013 18:45:10 +0000 Subject: Vendor import of clang trunk r178860: http://llvm.org/svn/llvm-project/cfe/trunk@178860 --- unittests/AST/SourceLocationTest.cpp | 202 +++++++---------------------------- 1 file changed, 36 insertions(+), 166 deletions(-) (limited to 'unittests/AST/SourceLocationTest.cpp') diff --git a/unittests/AST/SourceLocationTest.cpp b/unittests/AST/SourceLocationTest.cpp index dec833d..b8d8b02 100644 --- a/unittests/AST/SourceLocationTest.cpp +++ b/unittests/AST/SourceLocationTest.cpp @@ -17,179 +17,16 @@ //===----------------------------------------------------------------------===// #include "clang/AST/ASTContext.h" -#include "clang/ASTMatchers/ASTMatchers.h" #include "clang/ASTMatchers/ASTMatchFinder.h" +#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 -class MatchVerifier : public MatchFinder::MatchCallback { -public: - template - testing::AssertionResult match(const std::string &Code, - const MatcherType &AMatcher) { - return match(Code, AMatcher, Lang_CXX); - } - - template - 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 template -testing::AssertionResult MatchVerifier::match( - const std::string &Code, const MatcherType &AMatcher, Language L) { - MatchFinder Finder; - Finder.addMatcher(AMatcher.bind(""), this); - OwningPtr Factory(newFrontendActionFactory(&Finder)); - - std::vector 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 -void MatchVerifier::run(const MatchFinder::MatchResult &Result) { - const NodeType *Node = Result.Nodes.getNodeAs(""); - 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 -class LocationVerifier : public MatchVerifier { -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 -class RangeVerifier : public MatchVerifier { -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 Verifier; @@ -285,5 +122,38 @@ TEST(CXXConstructorDecl, NoRetFunTypeLocRange) { EXPECT_TRUE(Verifier.match("class C { C(); };", functionDecl())); } +TEST(CompoundLiteralExpr, CompoundVectorLiteralRange) { + RangeVerifier Verifier; + Verifier.expectRange(2, 11, 2, 22); + EXPECT_TRUE(Verifier.match( + "typedef int int2 __attribute__((ext_vector_type(2)));\n" + "int2 i2 = (int2){1, 2};", compoundLiteralExpr())); +} + +TEST(CompoundLiteralExpr, ParensCompoundVectorLiteralRange) { + RangeVerifier Verifier; + Verifier.expectRange(2, 11, 2, 22); + EXPECT_TRUE(Verifier.match( + "typedef int int2 __attribute__((ext_vector_type(2)));\n" + "int2 i2 = (int2)(1, 2);", + compoundLiteralExpr(), Lang_OpenCL)); +} + +TEST(InitListExpr, VectorLiteralListBraceRange) { + RangeVerifier Verifier; + Verifier.expectRange(2, 17, 2, 22); + EXPECT_TRUE(Verifier.match( + "typedef int int2 __attribute__((ext_vector_type(2)));\n" + "int2 i2 = (int2){1, 2};", initListExpr())); +} + +TEST(InitListExpr, VectorLiteralInitListParens) { + RangeVerifier Verifier; + Verifier.expectRange(2, 17, 2, 22); + EXPECT_TRUE(Verifier.match( + "typedef int int2 __attribute__((ext_vector_type(2)));\n" + "int2 i2 = (int2)(1, 2);", initListExpr(), Lang_OpenCL)); +} + } // end namespace ast_matchers } // end namespace clang -- cgit v1.1