Dmitri Gribenko | 525394e | 2012-09-23 20:29:07 +0000 | [diff] [blame] | 1 | //===- unittests/AST/StmtPrinterTest.cpp --- Statement printer tests ------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This file contains tests for Stmt::printPretty() and related methods. |
| 11 | // |
| 12 | // Search this file for WRONG to see test cases that are producing something |
| 13 | // completely wrong, invalid C++ or just misleading. |
| 14 | // |
| 15 | // These tests have a coding convention: |
| 16 | // * statements to be printed should be contained within a function named 'A' |
| 17 | // unless it should have some special name (e.g., 'operator+'); |
| 18 | // * additional helper declarations are 'Z', 'Y', 'X' and so on. |
| 19 | // |
| 20 | //===----------------------------------------------------------------------===// |
| 21 | |
| 22 | #include "clang/AST/ASTContext.h" |
| 23 | #include "clang/ASTMatchers/ASTMatchFinder.h" |
| 24 | #include "clang/Tooling/Tooling.h" |
| 25 | #include "llvm/ADT/SmallString.h" |
| 26 | #include "gtest/gtest.h" |
| 27 | |
| 28 | using namespace clang; |
| 29 | using namespace ast_matchers; |
| 30 | using namespace tooling; |
| 31 | |
| 32 | namespace { |
| 33 | |
| 34 | void PrintStmt(raw_ostream &Out, const ASTContext *Context, const Stmt *S) { |
| 35 | PrintingPolicy Policy = Context->getPrintingPolicy(); |
| 36 | S->printPretty(Out, /*Helper*/ 0, Policy); |
| 37 | } |
| 38 | |
| 39 | class PrintMatch : public MatchFinder::MatchCallback { |
| 40 | SmallString<1024> Printed; |
| 41 | unsigned NumFoundStmts; |
| 42 | |
| 43 | public: |
| 44 | PrintMatch() : NumFoundStmts(0) {} |
| 45 | |
| 46 | virtual void run(const MatchFinder::MatchResult &Result) { |
| 47 | const Stmt *S = Result.Nodes.getStmtAs<Stmt>("id"); |
| 48 | if (!S) |
| 49 | return; |
| 50 | NumFoundStmts++; |
| 51 | if (NumFoundStmts > 1) |
| 52 | return; |
| 53 | |
| 54 | llvm::raw_svector_ostream Out(Printed); |
| 55 | PrintStmt(Out, Result.Context, S); |
| 56 | } |
| 57 | |
| 58 | StringRef getPrinted() const { |
| 59 | return Printed; |
| 60 | } |
| 61 | |
| 62 | unsigned getNumFoundStmts() const { |
| 63 | return NumFoundStmts; |
| 64 | } |
| 65 | }; |
| 66 | |
| 67 | ::testing::AssertionResult PrintedStmtMatches( |
| 68 | StringRef Code, |
| 69 | const std::vector<std::string> &Args, |
| 70 | const DeclarationMatcher &NodeMatch, |
| 71 | StringRef ExpectedPrinted) { |
| 72 | |
| 73 | PrintMatch Printer; |
| 74 | MatchFinder Finder; |
| 75 | Finder.addMatcher(NodeMatch, &Printer); |
| 76 | OwningPtr<FrontendActionFactory> Factory(newFrontendActionFactory(&Finder)); |
| 77 | |
| 78 | if (!runToolOnCodeWithArgs(Factory->create(), Code, Args)) |
| 79 | return testing::AssertionFailure() << "Parsing error in \"" << Code << "\""; |
| 80 | |
| 81 | if (Printer.getNumFoundStmts() == 0) |
| 82 | return testing::AssertionFailure() |
| 83 | << "Matcher didn't find any statements"; |
| 84 | |
| 85 | if (Printer.getNumFoundStmts() > 1) |
| 86 | return testing::AssertionFailure() |
| 87 | << "Matcher should match only one statement " |
| 88 | "(found " << Printer.getNumFoundStmts() << ")"; |
| 89 | |
| 90 | if (Printer.getPrinted() != ExpectedPrinted) |
| 91 | return ::testing::AssertionFailure() |
| 92 | << "Expected \"" << ExpectedPrinted << "\", " |
| 93 | "got \"" << Printer.getPrinted() << "\""; |
| 94 | |
| 95 | return ::testing::AssertionSuccess(); |
| 96 | } |
| 97 | |
| 98 | ::testing::AssertionResult PrintedStmtCXX98Matches( |
| 99 | StringRef Code, |
| 100 | StringRef ContainingFunction, |
| 101 | StringRef ExpectedPrinted) { |
| 102 | std::vector<std::string> Args; |
| 103 | Args.push_back("-std=c++98"); |
| 104 | Args.push_back("-Wno-unused-value"); |
| 105 | return PrintedStmtMatches(Code, |
| 106 | Args, |
| 107 | functionDecl(hasName(ContainingFunction), |
| 108 | has(compoundStmt(has(stmt().bind("id"))))), |
| 109 | ExpectedPrinted); |
| 110 | } |
| 111 | |
| 112 | ::testing::AssertionResult PrintedStmtMSMatches( |
| 113 | StringRef Code, |
| 114 | StringRef ContainingFunction, |
| 115 | StringRef ExpectedPrinted) { |
| 116 | std::vector<std::string> Args; |
| 117 | Args.push_back("-std=c++98"); |
| 118 | Args.push_back("-fms-extensions"); |
| 119 | Args.push_back("-Wno-unused-value"); |
| 120 | return PrintedStmtMatches(Code, |
| 121 | Args, |
| 122 | functionDecl(hasName(ContainingFunction), |
| 123 | has(compoundStmt(has(stmt().bind("id"))))), |
| 124 | ExpectedPrinted); |
| 125 | } |
| 126 | |
| 127 | } // unnamed namespace |
| 128 | |
| 129 | TEST(StmtPrinter, TestIntegerLiteral) { |
| 130 | ASSERT_TRUE(PrintedStmtCXX98Matches( |
| 131 | "void A() {" |
| 132 | " 1, -1, 1U, 1u," |
| 133 | " 1L, 1l, -1L, 1UL, 1ul," |
| 134 | " 1LL, -1LL, 1ULL;" |
| 135 | "}", |
| 136 | "A", |
| 137 | "1 , -1 , 1U , 1U , " |
| 138 | "1L , 1L , -1L , 1UL , 1UL , " |
| 139 | "1LL , -1LL , 1ULL")); |
| 140 | // Should be: with semicolon |
| 141 | } |
| 142 | |
| 143 | TEST(StmtPrinter, TestMSIntegerLiteral) { |
| 144 | ASSERT_TRUE(PrintedStmtMSMatches( |
| 145 | "void A() {" |
| 146 | " 1i8, -1i8, 1ui8, " |
| 147 | " 1i16, -1i16, 1ui16, " |
| 148 | " 1i32, -1i32, 1ui32, " |
NAKAMURA Takumi | 96794f1 | 2012-11-29 10:22:40 +0000 | [diff] [blame] | 149 | " 1i64, -1i64, 1ui64;" |
Dmitri Gribenko | 525394e | 2012-09-23 20:29:07 +0000 | [diff] [blame] | 150 | "}", |
| 151 | "A", |
| 152 | "1 , -1 , 1U , " |
| 153 | "1 , -1 , 1U , " |
| 154 | "1L , -1L , 1UL , " |
NAKAMURA Takumi | 96794f1 | 2012-11-29 10:22:40 +0000 | [diff] [blame] | 155 | "1LL , -1LL , 1ULL")); |
Dmitri Gribenko | 525394e | 2012-09-23 20:29:07 +0000 | [diff] [blame] | 156 | // Should be: with semicolon |
Dmitri Gribenko | 525394e | 2012-09-23 20:29:07 +0000 | [diff] [blame] | 157 | } |
| 158 | |
| 159 | TEST(StmtPrinter, TestFloatingPointLiteral) { |
| 160 | ASSERT_TRUE(PrintedStmtCXX98Matches( |
| 161 | "void A() { 1.0f, -1.0f, 1.0, -1.0, 1.0l, -1.0l; }", |
| 162 | "A", |
| 163 | "1.F , -1.F , 1. , -1. , 1.L , -1.L")); |
| 164 | // Should be: with semicolon |
| 165 | } |