blob: a0644401a76aba07f8677d4ddb2716c2b2012c86 [file] [log] [blame]
//===- unittests/AST/StmtPrinterTest.cpp --- Statement printer tests ------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains tests for Stmt::printPretty() and related methods.
//
// Search this file for WRONG to see test cases that are producing something
// completely wrong, invalid C++ or just misleading.
//
// These tests have a coding convention:
// * statements to be printed should be contained within a function named 'A'
// unless it should have some special name (e.g., 'operator+');
// * additional helper declarations are 'Z', 'Y', 'X' and so on.
//
//===----------------------------------------------------------------------===//
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/ADT/SmallString.h"
#include "gtest/gtest.h"
using namespace clang;
using namespace ast_matchers;
using namespace tooling;
namespace {
using PolicyAdjusterType =
Optional<llvm::function_ref<void(PrintingPolicy &Policy)>>;
void PrintStmt(raw_ostream &Out, const ASTContext *Context, const Stmt *S,
PolicyAdjusterType PolicyAdjuster) {
assert(S != nullptr && "Expected non-null Stmt");
PrintingPolicy Policy = Context->getPrintingPolicy();
if (PolicyAdjuster)
(*PolicyAdjuster)(Policy);
S->printPretty(Out, /*Helper*/ nullptr, Policy);
}
class PrintMatch : public MatchFinder::MatchCallback {
SmallString<1024> Printed;
unsigned NumFoundStmts;
PolicyAdjusterType PolicyAdjuster;
public:
PrintMatch(PolicyAdjusterType PolicyAdjuster)
: NumFoundStmts(0), PolicyAdjuster(PolicyAdjuster) {}
void run(const MatchFinder::MatchResult &Result) override {
const Stmt *S = Result.Nodes.getNodeAs<Stmt>("id");
if (!S)
return;
NumFoundStmts++;
if (NumFoundStmts > 1)
return;
llvm::raw_svector_ostream Out(Printed);
PrintStmt(Out, Result.Context, S, PolicyAdjuster);
}
StringRef getPrinted() const {
return Printed;
}
unsigned getNumFoundStmts() const {
return NumFoundStmts;
}
};
template <typename T>
::testing::AssertionResult
PrintedStmtMatches(StringRef Code, const std::vector<std::string> &Args,
const T &NodeMatch, StringRef ExpectedPrinted,
PolicyAdjusterType PolicyAdjuster = None) {
PrintMatch Printer(PolicyAdjuster);
MatchFinder Finder;
Finder.addMatcher(NodeMatch, &Printer);
std::unique_ptr<FrontendActionFactory> Factory(
newFrontendActionFactory(&Finder));
if (!runToolOnCodeWithArgs(Factory->create(), Code, Args))
return testing::AssertionFailure()
<< "Parsing error in \"" << Code.str() << "\"";
if (Printer.getNumFoundStmts() == 0)
return testing::AssertionFailure()
<< "Matcher didn't find any statements";
if (Printer.getNumFoundStmts() > 1)
return testing::AssertionFailure()
<< "Matcher should match only one statement "
"(found " << Printer.getNumFoundStmts() << ")";
if (Printer.getPrinted() != ExpectedPrinted)
return ::testing::AssertionFailure()
<< "Expected \"" << ExpectedPrinted.str() << "\", "
"got \"" << Printer.getPrinted().str() << "\"";
return ::testing::AssertionSuccess();
}
::testing::AssertionResult
PrintedStmtCXX98Matches(StringRef Code, const StatementMatcher &NodeMatch,
StringRef ExpectedPrinted) {
std::vector<std::string> Args;
Args.push_back("-std=c++98");
Args.push_back("-Wno-unused-value");
return PrintedStmtMatches(Code, Args, NodeMatch, ExpectedPrinted);
}
::testing::AssertionResult PrintedStmtCXX98Matches(
StringRef Code,
StringRef ContainingFunction,
StringRef ExpectedPrinted) {
std::vector<std::string> Args;
Args.push_back("-std=c++98");
Args.push_back("-Wno-unused-value");
return PrintedStmtMatches(Code,
Args,
functionDecl(hasName(ContainingFunction),
has(compoundStmt(has(stmt().bind("id"))))),
ExpectedPrinted);
}
::testing::AssertionResult
PrintedStmtCXX11Matches(StringRef Code, const StatementMatcher &NodeMatch,
StringRef ExpectedPrinted,
PolicyAdjusterType PolicyAdjuster = None) {
std::vector<std::string> Args;
Args.push_back("-std=c++11");
Args.push_back("-Wno-unused-value");
return PrintedStmtMatches(Code, Args, NodeMatch, ExpectedPrinted,
PolicyAdjuster);
}
::testing::AssertionResult PrintedStmtMSMatches(
StringRef Code,
StringRef ContainingFunction,
StringRef ExpectedPrinted) {
std::vector<std::string> Args;
Args.push_back("-target");
Args.push_back("i686-pc-win32");
Args.push_back("-std=c++98");
Args.push_back("-fms-extensions");
Args.push_back("-Wno-unused-value");
return PrintedStmtMatches(Code,
Args,
functionDecl(hasName(ContainingFunction),
has(compoundStmt(has(stmt().bind("id"))))),
ExpectedPrinted);
}
::testing::AssertionResult
PrintedStmtObjCMatches(StringRef Code, const StatementMatcher &NodeMatch,
StringRef ExpectedPrinted,
PolicyAdjusterType PolicyAdjuster = None) {
std::vector<std::string> Args;
Args.push_back("-ObjC");
Args.push_back("-fobjc-runtime=macosx-10.12.0");
return PrintedStmtMatches(Code, Args, NodeMatch, ExpectedPrinted,
PolicyAdjuster);
}
} // unnamed namespace
TEST(StmtPrinter, TestIntegerLiteral) {
ASSERT_TRUE(PrintedStmtCXX98Matches(
"void A() {"
" 1, -1, 1U, 1u,"
" 1L, 1l, -1L, 1UL, 1ul,"
" 1LL, -1LL, 1ULL;"
"}",
"A",
"1 , -1 , 1U , 1U , "
"1L , 1L , -1L , 1UL , 1UL , "
"1LL , -1LL , 1ULL"));
// Should be: with semicolon
}
TEST(StmtPrinter, TestMSIntegerLiteral) {
ASSERT_TRUE(PrintedStmtMSMatches(
"void A() {"
" 1i8, -1i8, 1ui8, "
" 1i16, -1i16, 1ui16, "
" 1i32, -1i32, 1ui32, "
" 1i64, -1i64, 1ui64;"
"}",
"A",
"1i8 , -1i8 , 1Ui8 , "
"1i16 , -1i16 , 1Ui16 , "
"1 , -1 , 1U , "
"1LL , -1LL , 1ULL"));
// Should be: with semicolon
}
TEST(StmtPrinter, TestFloatingPointLiteral) {
ASSERT_TRUE(PrintedStmtCXX98Matches(
"void A() { 1.0f, -1.0f, 1.0, -1.0, 1.0l, -1.0l; }",
"A",
"1.F , -1.F , 1. , -1. , 1.L , -1.L"));
// Should be: with semicolon
}
TEST(StmtPrinter, TestCXXConversionDeclImplicit) {
ASSERT_TRUE(PrintedStmtCXX98Matches(
"struct A {"
"operator void *();"
"A operator&(A);"
"};"
"void bar(void *);"
"void foo(A a, A b) {"
" bar(a & b);"
"}",
cxxMemberCallExpr(anything()).bind("id"),
"a & b"));
}
TEST(StmtPrinter, TestCXXConversionDeclExplicit) {
ASSERT_TRUE(PrintedStmtCXX11Matches(
"struct A {"
"operator void *();"
"A operator&(A);"
"};"
"void bar(void *);"
"void foo(A a, A b) {"
" auto x = (a & b).operator void *();"
"}",
cxxMemberCallExpr(anything()).bind("id"),
"(a & b)"));
// WRONG; Should be: (a & b).operator void *()
}
TEST(StmtPrinter, TestNoImplicitBases) {
const char *CPPSource = R"(
class A {
int field;
int member() { return field; }
};
)";
// No implicit 'this'.
ASSERT_TRUE(PrintedStmtCXX11Matches(
CPPSource, memberExpr(anything()).bind("id"), "field",
PolicyAdjusterType(
[](PrintingPolicy &PP) { PP.SuppressImplicitBase = true; })));
// Print implicit 'this'.
ASSERT_TRUE(PrintedStmtCXX11Matches(
CPPSource, memberExpr(anything()).bind("id"), "this->field"));
const char *ObjCSource = R"(
@interface I {
int ivar;
}
@end
@implementation I
- (int) method {
return ivar;
}
@end
)";
// No implicit 'self'.
ASSERT_TRUE(PrintedStmtObjCMatches(ObjCSource, returnStmt().bind("id"),
"return ivar;\n",
PolicyAdjusterType([](PrintingPolicy &PP) {
PP.SuppressImplicitBase = true;
})));
// Print implicit 'self'.
ASSERT_TRUE(PrintedStmtObjCMatches(ObjCSource, returnStmt().bind("id"),
"return self->ivar;\n"));
}