1*67e74705SXin Li //===- unittests/AST/DeclPrinterTest.cpp --- Declaration printer tests ----===//
2*67e74705SXin Li //
3*67e74705SXin Li // The LLVM Compiler Infrastructure
4*67e74705SXin Li //
5*67e74705SXin Li // This file is distributed under the University of Illinois Open Source
6*67e74705SXin Li // License. See LICENSE.TXT for details.
7*67e74705SXin Li //
8*67e74705SXin Li //===----------------------------------------------------------------------===//
9*67e74705SXin Li //
10*67e74705SXin Li // This file contains tests for Decl::print() and related methods.
11*67e74705SXin Li //
12*67e74705SXin Li // Search this file for WRONG to see test cases that are producing something
13*67e74705SXin Li // completely wrong, invalid C++ or just misleading.
14*67e74705SXin Li //
15*67e74705SXin Li // These tests have a coding convention:
16*67e74705SXin Li // * declaration to be printed is named 'A' unless it should have some special
17*67e74705SXin Li // name (e.g., 'operator+');
18*67e74705SXin Li // * additional helper declarations are 'Z', 'Y', 'X' and so on.
19*67e74705SXin Li //
20*67e74705SXin Li //===----------------------------------------------------------------------===//
21*67e74705SXin Li
22*67e74705SXin Li #include "clang/AST/ASTContext.h"
23*67e74705SXin Li #include "clang/ASTMatchers/ASTMatchFinder.h"
24*67e74705SXin Li #include "clang/Tooling/Tooling.h"
25*67e74705SXin Li #include "llvm/ADT/SmallString.h"
26*67e74705SXin Li #include "gtest/gtest.h"
27*67e74705SXin Li
28*67e74705SXin Li using namespace clang;
29*67e74705SXin Li using namespace ast_matchers;
30*67e74705SXin Li using namespace tooling;
31*67e74705SXin Li
32*67e74705SXin Li namespace {
33*67e74705SXin Li
PrintDecl(raw_ostream & Out,const ASTContext * Context,const Decl * D)34*67e74705SXin Li void PrintDecl(raw_ostream &Out, const ASTContext *Context, const Decl *D) {
35*67e74705SXin Li PrintingPolicy Policy = Context->getPrintingPolicy();
36*67e74705SXin Li Policy.TerseOutput = true;
37*67e74705SXin Li D->print(Out, Policy, /*Indentation*/ 0, /*PrintInstantiation*/ false);
38*67e74705SXin Li }
39*67e74705SXin Li
40*67e74705SXin Li class PrintMatch : public MatchFinder::MatchCallback {
41*67e74705SXin Li SmallString<1024> Printed;
42*67e74705SXin Li unsigned NumFoundDecls;
43*67e74705SXin Li
44*67e74705SXin Li public:
PrintMatch()45*67e74705SXin Li PrintMatch() : NumFoundDecls(0) {}
46*67e74705SXin Li
run(const MatchFinder::MatchResult & Result)47*67e74705SXin Li void run(const MatchFinder::MatchResult &Result) override {
48*67e74705SXin Li const Decl *D = Result.Nodes.getDeclAs<Decl>("id");
49*67e74705SXin Li if (!D || D->isImplicit())
50*67e74705SXin Li return;
51*67e74705SXin Li NumFoundDecls++;
52*67e74705SXin Li if (NumFoundDecls > 1)
53*67e74705SXin Li return;
54*67e74705SXin Li
55*67e74705SXin Li llvm::raw_svector_ostream Out(Printed);
56*67e74705SXin Li PrintDecl(Out, Result.Context, D);
57*67e74705SXin Li }
58*67e74705SXin Li
getPrinted() const59*67e74705SXin Li StringRef getPrinted() const {
60*67e74705SXin Li return Printed;
61*67e74705SXin Li }
62*67e74705SXin Li
getNumFoundDecls() const63*67e74705SXin Li unsigned getNumFoundDecls() const {
64*67e74705SXin Li return NumFoundDecls;
65*67e74705SXin Li }
66*67e74705SXin Li };
67*67e74705SXin Li
PrintedDeclMatches(StringRef Code,const std::vector<std::string> & Args,const DeclarationMatcher & NodeMatch,StringRef ExpectedPrinted,StringRef FileName)68*67e74705SXin Li ::testing::AssertionResult PrintedDeclMatches(
69*67e74705SXin Li StringRef Code,
70*67e74705SXin Li const std::vector<std::string> &Args,
71*67e74705SXin Li const DeclarationMatcher &NodeMatch,
72*67e74705SXin Li StringRef ExpectedPrinted,
73*67e74705SXin Li StringRef FileName) {
74*67e74705SXin Li PrintMatch Printer;
75*67e74705SXin Li MatchFinder Finder;
76*67e74705SXin Li Finder.addMatcher(NodeMatch, &Printer);
77*67e74705SXin Li std::unique_ptr<FrontendActionFactory> Factory(
78*67e74705SXin Li newFrontendActionFactory(&Finder));
79*67e74705SXin Li
80*67e74705SXin Li if (!runToolOnCodeWithArgs(Factory->create(), Code, Args, FileName))
81*67e74705SXin Li return testing::AssertionFailure()
82*67e74705SXin Li << "Parsing error in \"" << Code.str() << "\"";
83*67e74705SXin Li
84*67e74705SXin Li if (Printer.getNumFoundDecls() == 0)
85*67e74705SXin Li return testing::AssertionFailure()
86*67e74705SXin Li << "Matcher didn't find any declarations";
87*67e74705SXin Li
88*67e74705SXin Li if (Printer.getNumFoundDecls() > 1)
89*67e74705SXin Li return testing::AssertionFailure()
90*67e74705SXin Li << "Matcher should match only one declaration "
91*67e74705SXin Li "(found " << Printer.getNumFoundDecls() << ")";
92*67e74705SXin Li
93*67e74705SXin Li if (Printer.getPrinted() != ExpectedPrinted)
94*67e74705SXin Li return ::testing::AssertionFailure()
95*67e74705SXin Li << "Expected \"" << ExpectedPrinted.str() << "\", "
96*67e74705SXin Li "got \"" << Printer.getPrinted().str() << "\"";
97*67e74705SXin Li
98*67e74705SXin Li return ::testing::AssertionSuccess();
99*67e74705SXin Li }
100*67e74705SXin Li
PrintedDeclCXX98Matches(StringRef Code,StringRef DeclName,StringRef ExpectedPrinted)101*67e74705SXin Li ::testing::AssertionResult PrintedDeclCXX98Matches(StringRef Code,
102*67e74705SXin Li StringRef DeclName,
103*67e74705SXin Li StringRef ExpectedPrinted) {
104*67e74705SXin Li std::vector<std::string> Args(1, "-std=c++98");
105*67e74705SXin Li return PrintedDeclMatches(Code,
106*67e74705SXin Li Args,
107*67e74705SXin Li namedDecl(hasName(DeclName)).bind("id"),
108*67e74705SXin Li ExpectedPrinted,
109*67e74705SXin Li "input.cc");
110*67e74705SXin Li }
111*67e74705SXin Li
PrintedDeclCXX98Matches(StringRef Code,const DeclarationMatcher & NodeMatch,StringRef ExpectedPrinted)112*67e74705SXin Li ::testing::AssertionResult PrintedDeclCXX98Matches(
113*67e74705SXin Li StringRef Code,
114*67e74705SXin Li const DeclarationMatcher &NodeMatch,
115*67e74705SXin Li StringRef ExpectedPrinted) {
116*67e74705SXin Li std::vector<std::string> Args(1, "-std=c++98");
117*67e74705SXin Li return PrintedDeclMatches(Code,
118*67e74705SXin Li Args,
119*67e74705SXin Li NodeMatch,
120*67e74705SXin Li ExpectedPrinted,
121*67e74705SXin Li "input.cc");
122*67e74705SXin Li }
123*67e74705SXin Li
PrintedDeclCXX11Matches(StringRef Code,StringRef DeclName,StringRef ExpectedPrinted)124*67e74705SXin Li ::testing::AssertionResult PrintedDeclCXX11Matches(StringRef Code,
125*67e74705SXin Li StringRef DeclName,
126*67e74705SXin Li StringRef ExpectedPrinted) {
127*67e74705SXin Li std::vector<std::string> Args(1, "-std=c++11");
128*67e74705SXin Li return PrintedDeclMatches(Code,
129*67e74705SXin Li Args,
130*67e74705SXin Li namedDecl(hasName(DeclName)).bind("id"),
131*67e74705SXin Li ExpectedPrinted,
132*67e74705SXin Li "input.cc");
133*67e74705SXin Li }
134*67e74705SXin Li
PrintedDeclCXX11Matches(StringRef Code,const DeclarationMatcher & NodeMatch,StringRef ExpectedPrinted)135*67e74705SXin Li ::testing::AssertionResult PrintedDeclCXX11Matches(
136*67e74705SXin Li StringRef Code,
137*67e74705SXin Li const DeclarationMatcher &NodeMatch,
138*67e74705SXin Li StringRef ExpectedPrinted) {
139*67e74705SXin Li std::vector<std::string> Args(1, "-std=c++11");
140*67e74705SXin Li return PrintedDeclMatches(Code,
141*67e74705SXin Li Args,
142*67e74705SXin Li NodeMatch,
143*67e74705SXin Li ExpectedPrinted,
144*67e74705SXin Li "input.cc");
145*67e74705SXin Li }
146*67e74705SXin Li
PrintedDeclCXX11nonMSCMatches(StringRef Code,const DeclarationMatcher & NodeMatch,StringRef ExpectedPrinted)147*67e74705SXin Li ::testing::AssertionResult PrintedDeclCXX11nonMSCMatches(
148*67e74705SXin Li StringRef Code,
149*67e74705SXin Li const DeclarationMatcher &NodeMatch,
150*67e74705SXin Li StringRef ExpectedPrinted) {
151*67e74705SXin Li std::vector<std::string> Args(1, "-std=c++11");
152*67e74705SXin Li Args.push_back("-fno-delayed-template-parsing");
153*67e74705SXin Li return PrintedDeclMatches(Code,
154*67e74705SXin Li Args,
155*67e74705SXin Li NodeMatch,
156*67e74705SXin Li ExpectedPrinted,
157*67e74705SXin Li "input.cc");
158*67e74705SXin Li }
159*67e74705SXin Li
160*67e74705SXin Li ::testing::AssertionResult
PrintedDeclCXX1ZMatches(StringRef Code,const DeclarationMatcher & NodeMatch,StringRef ExpectedPrinted)161*67e74705SXin Li PrintedDeclCXX1ZMatches(StringRef Code, const DeclarationMatcher &NodeMatch,
162*67e74705SXin Li StringRef ExpectedPrinted) {
163*67e74705SXin Li std::vector<std::string> Args(1, "-std=c++1z");
164*67e74705SXin Li return PrintedDeclMatches(Code,
165*67e74705SXin Li Args,
166*67e74705SXin Li NodeMatch,
167*67e74705SXin Li ExpectedPrinted,
168*67e74705SXin Li "input.cc");
169*67e74705SXin Li }
170*67e74705SXin Li
PrintedDeclObjCMatches(StringRef Code,const DeclarationMatcher & NodeMatch,StringRef ExpectedPrinted)171*67e74705SXin Li ::testing::AssertionResult PrintedDeclObjCMatches(
172*67e74705SXin Li StringRef Code,
173*67e74705SXin Li const DeclarationMatcher &NodeMatch,
174*67e74705SXin Li StringRef ExpectedPrinted) {
175*67e74705SXin Li std::vector<std::string> Args(1, "");
176*67e74705SXin Li return PrintedDeclMatches(Code,
177*67e74705SXin Li Args,
178*67e74705SXin Li NodeMatch,
179*67e74705SXin Li ExpectedPrinted,
180*67e74705SXin Li "input.m");
181*67e74705SXin Li }
182*67e74705SXin Li
183*67e74705SXin Li } // unnamed namespace
184*67e74705SXin Li
TEST(DeclPrinter,TestTypedef1)185*67e74705SXin Li TEST(DeclPrinter, TestTypedef1) {
186*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
187*67e74705SXin Li "typedef int A;",
188*67e74705SXin Li "A",
189*67e74705SXin Li "typedef int A"));
190*67e74705SXin Li // Should be: with semicolon
191*67e74705SXin Li }
192*67e74705SXin Li
TEST(DeclPrinter,TestTypedef2)193*67e74705SXin Li TEST(DeclPrinter, TestTypedef2) {
194*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
195*67e74705SXin Li "typedef const char *A;",
196*67e74705SXin Li "A",
197*67e74705SXin Li "typedef const char *A"));
198*67e74705SXin Li // Should be: with semicolon
199*67e74705SXin Li }
200*67e74705SXin Li
TEST(DeclPrinter,TestTypedef3)201*67e74705SXin Li TEST(DeclPrinter, TestTypedef3) {
202*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
203*67e74705SXin Li "template <typename Y> class X {};"
204*67e74705SXin Li "typedef X<int> A;",
205*67e74705SXin Li "A",
206*67e74705SXin Li "typedef X<int> A"));
207*67e74705SXin Li // Should be: with semicolon
208*67e74705SXin Li }
209*67e74705SXin Li
TEST(DeclPrinter,TestTypedef4)210*67e74705SXin Li TEST(DeclPrinter, TestTypedef4) {
211*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
212*67e74705SXin Li "namespace X { class Y {}; }"
213*67e74705SXin Li "typedef X::Y A;",
214*67e74705SXin Li "A",
215*67e74705SXin Li "typedef X::Y A"));
216*67e74705SXin Li // Should be: with semicolon
217*67e74705SXin Li }
218*67e74705SXin Li
TEST(DeclPrinter,TestNamespace1)219*67e74705SXin Li TEST(DeclPrinter, TestNamespace1) {
220*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
221*67e74705SXin Li "namespace A { int B; }",
222*67e74705SXin Li "A",
223*67e74705SXin Li "namespace A {\n}"));
224*67e74705SXin Li // Should be: with { ... }
225*67e74705SXin Li }
226*67e74705SXin Li
TEST(DeclPrinter,TestNamespace2)227*67e74705SXin Li TEST(DeclPrinter, TestNamespace2) {
228*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
229*67e74705SXin Li "inline namespace A { int B; }",
230*67e74705SXin Li "A",
231*67e74705SXin Li "inline namespace A {\n}"));
232*67e74705SXin Li // Should be: with { ... }
233*67e74705SXin Li }
234*67e74705SXin Li
TEST(DeclPrinter,TestNamespaceAlias1)235*67e74705SXin Li TEST(DeclPrinter, TestNamespaceAlias1) {
236*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
237*67e74705SXin Li "namespace Z { }"
238*67e74705SXin Li "namespace A = Z;",
239*67e74705SXin Li "A",
240*67e74705SXin Li "namespace A = Z"));
241*67e74705SXin Li // Should be: with semicolon
242*67e74705SXin Li }
243*67e74705SXin Li
TEST(DeclPrinter,TestNamespaceAlias2)244*67e74705SXin Li TEST(DeclPrinter, TestNamespaceAlias2) {
245*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
246*67e74705SXin Li "namespace X { namespace Y {} }"
247*67e74705SXin Li "namespace A = X::Y;",
248*67e74705SXin Li "A",
249*67e74705SXin Li "namespace A = X::Y"));
250*67e74705SXin Li // Should be: with semicolon
251*67e74705SXin Li }
252*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl1)253*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl1) {
254*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
255*67e74705SXin Li "class A { int a; };",
256*67e74705SXin Li "A",
257*67e74705SXin Li "class A {\n}"));
258*67e74705SXin Li // Should be: with semicolon, with { ... }
259*67e74705SXin Li }
260*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl2)261*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl2) {
262*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
263*67e74705SXin Li "struct A { int a; };",
264*67e74705SXin Li "A",
265*67e74705SXin Li "struct A {\n}"));
266*67e74705SXin Li // Should be: with semicolon, with { ... }
267*67e74705SXin Li }
268*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl3)269*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl3) {
270*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
271*67e74705SXin Li "union A { int a; };",
272*67e74705SXin Li "A",
273*67e74705SXin Li "union A {\n}"));
274*67e74705SXin Li // Should be: with semicolon, with { ... }
275*67e74705SXin Li }
276*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl4)277*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl4) {
278*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
279*67e74705SXin Li "class Z { int a; };"
280*67e74705SXin Li "class A : Z { int b; };",
281*67e74705SXin Li "A",
282*67e74705SXin Li "class A : Z {\n}"));
283*67e74705SXin Li // Should be: with semicolon, with { ... }
284*67e74705SXin Li }
285*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl5)286*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl5) {
287*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
288*67e74705SXin Li "struct Z { int a; };"
289*67e74705SXin Li "struct A : Z { int b; };",
290*67e74705SXin Li "A",
291*67e74705SXin Li "struct A : Z {\n}"));
292*67e74705SXin Li // Should be: with semicolon, with { ... }
293*67e74705SXin Li }
294*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl6)295*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl6) {
296*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
297*67e74705SXin Li "class Z { int a; };"
298*67e74705SXin Li "class A : public Z { int b; };",
299*67e74705SXin Li "A",
300*67e74705SXin Li "class A : public Z {\n}"));
301*67e74705SXin Li // Should be: with semicolon, with { ... }
302*67e74705SXin Li }
303*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl7)304*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl7) {
305*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
306*67e74705SXin Li "class Z { int a; };"
307*67e74705SXin Li "class A : protected Z { int b; };",
308*67e74705SXin Li "A",
309*67e74705SXin Li "class A : protected Z {\n}"));
310*67e74705SXin Li // Should be: with semicolon, with { ... }
311*67e74705SXin Li }
312*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl8)313*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl8) {
314*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
315*67e74705SXin Li "class Z { int a; };"
316*67e74705SXin Li "class A : private Z { int b; };",
317*67e74705SXin Li "A",
318*67e74705SXin Li "class A : private Z {\n}"));
319*67e74705SXin Li // Should be: with semicolon, with { ... }
320*67e74705SXin Li }
321*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl9)322*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl9) {
323*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
324*67e74705SXin Li "class Z { int a; };"
325*67e74705SXin Li "class A : virtual Z { int b; };",
326*67e74705SXin Li "A",
327*67e74705SXin Li "class A : virtual Z {\n}"));
328*67e74705SXin Li // Should be: with semicolon, with { ... }
329*67e74705SXin Li }
330*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl10)331*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl10) {
332*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
333*67e74705SXin Li "class Z { int a; };"
334*67e74705SXin Li "class A : virtual public Z { int b; };",
335*67e74705SXin Li "A",
336*67e74705SXin Li "class A : virtual public Z {\n}"));
337*67e74705SXin Li // Should be: with semicolon, with { ... }
338*67e74705SXin Li }
339*67e74705SXin Li
TEST(DeclPrinter,TestCXXRecordDecl11)340*67e74705SXin Li TEST(DeclPrinter, TestCXXRecordDecl11) {
341*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
342*67e74705SXin Li "class Z { int a; };"
343*67e74705SXin Li "class Y : virtual public Z { int b; };"
344*67e74705SXin Li "class A : virtual public Z, private Y { int c; };",
345*67e74705SXin Li "A",
346*67e74705SXin Li "class A : virtual public Z, private Y {\n}"));
347*67e74705SXin Li // Should be: with semicolon, with { ... }
348*67e74705SXin Li }
349*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl1)350*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl1) {
351*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
352*67e74705SXin Li "void A();",
353*67e74705SXin Li "A",
354*67e74705SXin Li "void A()"));
355*67e74705SXin Li // Should be: with semicolon
356*67e74705SXin Li }
357*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl2)358*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl2) {
359*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
360*67e74705SXin Li "void A() {}",
361*67e74705SXin Li "A",
362*67e74705SXin Li "void A()"));
363*67e74705SXin Li // Should be: with semicolon
364*67e74705SXin Li }
365*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl3)366*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl3) {
367*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
368*67e74705SXin Li "void Z();"
369*67e74705SXin Li "void A() { Z(); }",
370*67e74705SXin Li "A",
371*67e74705SXin Li "void A()"));
372*67e74705SXin Li // Should be: with semicolon
373*67e74705SXin Li }
374*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl4)375*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl4) {
376*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
377*67e74705SXin Li "extern void A();",
378*67e74705SXin Li "A",
379*67e74705SXin Li "extern void A()"));
380*67e74705SXin Li // Should be: with semicolon
381*67e74705SXin Li }
382*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl5)383*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl5) {
384*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
385*67e74705SXin Li "static void A();",
386*67e74705SXin Li "A",
387*67e74705SXin Li "static void A()"));
388*67e74705SXin Li // Should be: with semicolon
389*67e74705SXin Li }
390*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl6)391*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl6) {
392*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
393*67e74705SXin Li "inline void A();",
394*67e74705SXin Li "A",
395*67e74705SXin Li "inline void A()"));
396*67e74705SXin Li // Should be: with semicolon
397*67e74705SXin Li }
398*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl7)399*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl7) {
400*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
401*67e74705SXin Li "constexpr int A(int a);",
402*67e74705SXin Li "A",
403*67e74705SXin Li "constexpr int A(int a)"));
404*67e74705SXin Li // Should be: with semicolon
405*67e74705SXin Li }
406*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl8)407*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl8) {
408*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
409*67e74705SXin Li "void A(int a);",
410*67e74705SXin Li "A",
411*67e74705SXin Li "void A(int a)"));
412*67e74705SXin Li // Should be: with semicolon
413*67e74705SXin Li }
414*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl9)415*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl9) {
416*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
417*67e74705SXin Li "void A(...);",
418*67e74705SXin Li "A",
419*67e74705SXin Li "void A(...)"));
420*67e74705SXin Li // Should be: with semicolon
421*67e74705SXin Li }
422*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl10)423*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl10) {
424*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
425*67e74705SXin Li "void A(int a, ...);",
426*67e74705SXin Li "A",
427*67e74705SXin Li "void A(int a, ...)"));
428*67e74705SXin Li // Should be: with semicolon
429*67e74705SXin Li }
430*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl11)431*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl11) {
432*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
433*67e74705SXin Li "typedef long ssize_t;"
434*67e74705SXin Li "typedef int *pInt;"
435*67e74705SXin Li "void A(int a, pInt b, ssize_t c);",
436*67e74705SXin Li "A",
437*67e74705SXin Li "void A(int a, pInt b, ssize_t c)"));
438*67e74705SXin Li // Should be: with semicolon
439*67e74705SXin Li }
440*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl12)441*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl12) {
442*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
443*67e74705SXin Li "void A(int a, int b = 0);",
444*67e74705SXin Li "A",
445*67e74705SXin Li "void A(int a, int b = 0)"));
446*67e74705SXin Li // Should be: with semicolon
447*67e74705SXin Li }
448*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl13)449*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl13) {
450*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
451*67e74705SXin Li "void (*A(int a))(int b);",
452*67e74705SXin Li "A",
453*67e74705SXin Li "void (*A(int a))(int)"));
454*67e74705SXin Li // Should be: with semicolon, with parameter name (?)
455*67e74705SXin Li }
456*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl14)457*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl14) {
458*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
459*67e74705SXin Li "template<typename T>"
460*67e74705SXin Li "void A(T t) { }"
461*67e74705SXin Li "template<>"
462*67e74705SXin Li "void A(int N) { }",
463*67e74705SXin Li functionDecl(hasName("A"), isExplicitTemplateSpecialization()).bind("id"),
464*67e74705SXin Li "void A(int N)"));
465*67e74705SXin Li // WRONG; Should be: "template <> void A(int N);"));
466*67e74705SXin Li }
467*67e74705SXin Li
468*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl1)469*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl1) {
470*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
471*67e74705SXin Li "struct A {"
472*67e74705SXin Li " A();"
473*67e74705SXin Li "};",
474*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
475*67e74705SXin Li "A()"));
476*67e74705SXin Li }
477*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl2)478*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl2) {
479*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
480*67e74705SXin Li "struct A {"
481*67e74705SXin Li " A(int a);"
482*67e74705SXin Li "};",
483*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
484*67e74705SXin Li "A(int a)"));
485*67e74705SXin Li }
486*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl3)487*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl3) {
488*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
489*67e74705SXin Li "struct A {"
490*67e74705SXin Li " A(const A &a);"
491*67e74705SXin Li "};",
492*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
493*67e74705SXin Li "A(const A &a)"));
494*67e74705SXin Li }
495*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl4)496*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl4) {
497*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
498*67e74705SXin Li "struct A {"
499*67e74705SXin Li " A(const A &a, int = 0);"
500*67e74705SXin Li "};",
501*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
502*67e74705SXin Li "A(const A &a, int = 0)"));
503*67e74705SXin Li }
504*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl5)505*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl5) {
506*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
507*67e74705SXin Li "struct A {"
508*67e74705SXin Li " A(const A &&a);"
509*67e74705SXin Li "};",
510*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
511*67e74705SXin Li "A(const A &&a)"));
512*67e74705SXin Li }
513*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl6)514*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl6) {
515*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
516*67e74705SXin Li "struct A {"
517*67e74705SXin Li " explicit A(int a);"
518*67e74705SXin Li "};",
519*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
520*67e74705SXin Li "explicit A(int a)"));
521*67e74705SXin Li }
522*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl7)523*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl7) {
524*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
525*67e74705SXin Li "struct A {"
526*67e74705SXin Li " constexpr A();"
527*67e74705SXin Li "};",
528*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
529*67e74705SXin Li "constexpr A()"));
530*67e74705SXin Li }
531*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl8)532*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl8) {
533*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
534*67e74705SXin Li "struct A {"
535*67e74705SXin Li " A() = default;"
536*67e74705SXin Li "};",
537*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
538*67e74705SXin Li "A() = default"));
539*67e74705SXin Li }
540*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl9)541*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl9) {
542*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
543*67e74705SXin Li "struct A {"
544*67e74705SXin Li " A() = delete;"
545*67e74705SXin Li "};",
546*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
547*67e74705SXin Li "A() = delete"));
548*67e74705SXin Li }
549*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl10)550*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl10) {
551*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
552*67e74705SXin Li "template<typename... T>"
553*67e74705SXin Li "struct A {"
554*67e74705SXin Li " A(const A &a);"
555*67e74705SXin Li "};",
556*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
557*67e74705SXin Li "A<T...>(const A<T...> &a)"));
558*67e74705SXin Li // WRONG; Should be: "A(const A<T...> &a);"
559*67e74705SXin Li }
560*67e74705SXin Li
TEST(DeclPrinter,TestCXXConstructorDecl11)561*67e74705SXin Li TEST(DeclPrinter, TestCXXConstructorDecl11) {
562*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11nonMSCMatches(
563*67e74705SXin Li "template<typename... T>"
564*67e74705SXin Li "struct A : public T... {"
565*67e74705SXin Li " A(T&&... ts) : T(ts)... {}"
566*67e74705SXin Li "};",
567*67e74705SXin Li cxxConstructorDecl(ofClass(hasName("A"))).bind("id"),
568*67e74705SXin Li "A<T...>(T &&...ts) : T(ts)..."));
569*67e74705SXin Li // WRONG; Should be: "A(T &&...ts) : T(ts)... {}"
570*67e74705SXin Li }
571*67e74705SXin Li
TEST(DeclPrinter,TestCXXDestructorDecl1)572*67e74705SXin Li TEST(DeclPrinter, TestCXXDestructorDecl1) {
573*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
574*67e74705SXin Li "struct A {"
575*67e74705SXin Li " ~A();"
576*67e74705SXin Li "};",
577*67e74705SXin Li cxxDestructorDecl(ofClass(hasName("A"))).bind("id"),
578*67e74705SXin Li "~A()"));
579*67e74705SXin Li }
580*67e74705SXin Li
TEST(DeclPrinter,TestCXXDestructorDecl2)581*67e74705SXin Li TEST(DeclPrinter, TestCXXDestructorDecl2) {
582*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
583*67e74705SXin Li "struct A {"
584*67e74705SXin Li " virtual ~A();"
585*67e74705SXin Li "};",
586*67e74705SXin Li cxxDestructorDecl(ofClass(hasName("A"))).bind("id"),
587*67e74705SXin Li "virtual ~A()"));
588*67e74705SXin Li }
589*67e74705SXin Li
TEST(DeclPrinter,TestCXXConversionDecl1)590*67e74705SXin Li TEST(DeclPrinter, TestCXXConversionDecl1) {
591*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
592*67e74705SXin Li "struct A {"
593*67e74705SXin Li " operator int();"
594*67e74705SXin Li "};",
595*67e74705SXin Li cxxMethodDecl(ofClass(hasName("A"))).bind("id"),
596*67e74705SXin Li "operator int()"));
597*67e74705SXin Li }
598*67e74705SXin Li
TEST(DeclPrinter,TestCXXConversionDecl2)599*67e74705SXin Li TEST(DeclPrinter, TestCXXConversionDecl2) {
600*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
601*67e74705SXin Li "struct A {"
602*67e74705SXin Li " operator bool();"
603*67e74705SXin Li "};",
604*67e74705SXin Li cxxMethodDecl(ofClass(hasName("A"))).bind("id"),
605*67e74705SXin Li "operator bool()"));
606*67e74705SXin Li }
607*67e74705SXin Li
TEST(DeclPrinter,TestCXXConversionDecl3)608*67e74705SXin Li TEST(DeclPrinter, TestCXXConversionDecl3) {
609*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
610*67e74705SXin Li "struct Z {};"
611*67e74705SXin Li "struct A {"
612*67e74705SXin Li " operator Z();"
613*67e74705SXin Li "};",
614*67e74705SXin Li cxxMethodDecl(ofClass(hasName("A"))).bind("id"),
615*67e74705SXin Li "operator Z()"));
616*67e74705SXin Li }
617*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_AllocationFunction1)618*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_AllocationFunction1) {
619*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
620*67e74705SXin Li "namespace std { typedef decltype(sizeof(int)) size_t; }"
621*67e74705SXin Li "struct Z {"
622*67e74705SXin Li " void *operator new(std::size_t);"
623*67e74705SXin Li "};",
624*67e74705SXin Li cxxMethodDecl(ofClass(hasName("Z"))).bind("id"),
625*67e74705SXin Li "void *operator new(std::size_t)"));
626*67e74705SXin Li // Should be: with semicolon
627*67e74705SXin Li }
628*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_AllocationFunction2)629*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_AllocationFunction2) {
630*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
631*67e74705SXin Li "namespace std { typedef decltype(sizeof(int)) size_t; }"
632*67e74705SXin Li "struct Z {"
633*67e74705SXin Li " void *operator new[](std::size_t);"
634*67e74705SXin Li "};",
635*67e74705SXin Li cxxMethodDecl(ofClass(hasName("Z"))).bind("id"),
636*67e74705SXin Li "void *operator new[](std::size_t)"));
637*67e74705SXin Li // Should be: with semicolon
638*67e74705SXin Li }
639*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_AllocationFunction3)640*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_AllocationFunction3) {
641*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
642*67e74705SXin Li "struct Z {"
643*67e74705SXin Li " void operator delete(void *);"
644*67e74705SXin Li "};",
645*67e74705SXin Li cxxMethodDecl(ofClass(hasName("Z"))).bind("id"),
646*67e74705SXin Li "void operator delete(void *) noexcept"));
647*67e74705SXin Li // Should be: with semicolon, without noexcept?
648*67e74705SXin Li }
649*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_AllocationFunction4)650*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_AllocationFunction4) {
651*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
652*67e74705SXin Li "struct Z {"
653*67e74705SXin Li " void operator delete(void *);"
654*67e74705SXin Li "};",
655*67e74705SXin Li cxxMethodDecl(ofClass(hasName("Z"))).bind("id"),
656*67e74705SXin Li "void operator delete(void *)"));
657*67e74705SXin Li // Should be: with semicolon
658*67e74705SXin Li }
659*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_AllocationFunction5)660*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_AllocationFunction5) {
661*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
662*67e74705SXin Li "struct Z {"
663*67e74705SXin Li " void operator delete[](void *);"
664*67e74705SXin Li "};",
665*67e74705SXin Li cxxMethodDecl(ofClass(hasName("Z"))).bind("id"),
666*67e74705SXin Li "void operator delete[](void *) noexcept"));
667*67e74705SXin Li // Should be: with semicolon, without noexcept?
668*67e74705SXin Li }
669*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_Operator1)670*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_Operator1) {
671*67e74705SXin Li const char *OperatorNames[] = {
672*67e74705SXin Li "+", "-", "*", "/", "%", "^", "&", "|",
673*67e74705SXin Li "=", "<", ">", "+=", "-=", "*=", "/=", "%=",
674*67e74705SXin Li "^=", "&=", "|=", "<<", ">>", ">>=", "<<=", "==", "!=",
675*67e74705SXin Li "<=", ">=", "&&", "||", ",", "->*",
676*67e74705SXin Li "()", "[]"
677*67e74705SXin Li };
678*67e74705SXin Li
679*67e74705SXin Li for (unsigned i = 0, e = llvm::array_lengthof(OperatorNames); i != e; ++i) {
680*67e74705SXin Li SmallString<128> Code;
681*67e74705SXin Li Code.append("struct Z { void operator");
682*67e74705SXin Li Code.append(OperatorNames[i]);
683*67e74705SXin Li Code.append("(Z z); };");
684*67e74705SXin Li
685*67e74705SXin Li SmallString<128> Expected;
686*67e74705SXin Li Expected.append("void operator");
687*67e74705SXin Li Expected.append(OperatorNames[i]);
688*67e74705SXin Li Expected.append("(Z z)");
689*67e74705SXin Li // Should be: with semicolon
690*67e74705SXin Li
691*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
692*67e74705SXin Li Code,
693*67e74705SXin Li cxxMethodDecl(ofClass(hasName("Z"))).bind("id"),
694*67e74705SXin Li Expected));
695*67e74705SXin Li }
696*67e74705SXin Li }
697*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_Operator2)698*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_Operator2) {
699*67e74705SXin Li const char *OperatorNames[] = {
700*67e74705SXin Li "~", "!", "++", "--", "->"
701*67e74705SXin Li };
702*67e74705SXin Li
703*67e74705SXin Li for (unsigned i = 0, e = llvm::array_lengthof(OperatorNames); i != e; ++i) {
704*67e74705SXin Li SmallString<128> Code;
705*67e74705SXin Li Code.append("struct Z { void operator");
706*67e74705SXin Li Code.append(OperatorNames[i]);
707*67e74705SXin Li Code.append("(); };");
708*67e74705SXin Li
709*67e74705SXin Li SmallString<128> Expected;
710*67e74705SXin Li Expected.append("void operator");
711*67e74705SXin Li Expected.append(OperatorNames[i]);
712*67e74705SXin Li Expected.append("()");
713*67e74705SXin Li // Should be: with semicolon
714*67e74705SXin Li
715*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
716*67e74705SXin Li Code,
717*67e74705SXin Li cxxMethodDecl(ofClass(hasName("Z"))).bind("id"),
718*67e74705SXin Li Expected));
719*67e74705SXin Li }
720*67e74705SXin Li }
721*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl1)722*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl1) {
723*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
724*67e74705SXin Li "struct Z {"
725*67e74705SXin Li " void A(int a);"
726*67e74705SXin Li "};",
727*67e74705SXin Li "A",
728*67e74705SXin Li "void A(int a)"));
729*67e74705SXin Li // Should be: with semicolon
730*67e74705SXin Li }
731*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl2)732*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl2) {
733*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
734*67e74705SXin Li "struct Z {"
735*67e74705SXin Li " virtual void A(int a);"
736*67e74705SXin Li "};",
737*67e74705SXin Li "A",
738*67e74705SXin Li "virtual void A(int a)"));
739*67e74705SXin Li // Should be: with semicolon
740*67e74705SXin Li }
741*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl3)742*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl3) {
743*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
744*67e74705SXin Li "struct Z {"
745*67e74705SXin Li " virtual void A(int a);"
746*67e74705SXin Li "};"
747*67e74705SXin Li "struct ZZ : Z {"
748*67e74705SXin Li " void A(int a);"
749*67e74705SXin Li "};",
750*67e74705SXin Li "ZZ::A",
751*67e74705SXin Li "void A(int a)"));
752*67e74705SXin Li // Should be: with semicolon
753*67e74705SXin Li // TODO: should we print "virtual"?
754*67e74705SXin Li }
755*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl4)756*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl4) {
757*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
758*67e74705SXin Li "struct Z {"
759*67e74705SXin Li " inline void A(int a);"
760*67e74705SXin Li "};",
761*67e74705SXin Li "A",
762*67e74705SXin Li "inline void A(int a)"));
763*67e74705SXin Li // Should be: with semicolon
764*67e74705SXin Li }
765*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl5)766*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl5) {
767*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
768*67e74705SXin Li "struct Z {"
769*67e74705SXin Li " virtual void A(int a) = 0;"
770*67e74705SXin Li "};",
771*67e74705SXin Li "A",
772*67e74705SXin Li "virtual void A(int a) = 0"));
773*67e74705SXin Li // Should be: with semicolon
774*67e74705SXin Li }
775*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_CVQualifier1)776*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_CVQualifier1) {
777*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
778*67e74705SXin Li "struct Z {"
779*67e74705SXin Li " void A(int a) const;"
780*67e74705SXin Li "};",
781*67e74705SXin Li "A",
782*67e74705SXin Li "void A(int a) const"));
783*67e74705SXin Li // Should be: with semicolon
784*67e74705SXin Li }
785*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_CVQualifier2)786*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_CVQualifier2) {
787*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
788*67e74705SXin Li "struct Z {"
789*67e74705SXin Li " void A(int a) volatile;"
790*67e74705SXin Li "};",
791*67e74705SXin Li "A",
792*67e74705SXin Li "void A(int a) volatile"));
793*67e74705SXin Li // Should be: with semicolon
794*67e74705SXin Li }
795*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_CVQualifier3)796*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_CVQualifier3) {
797*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
798*67e74705SXin Li "struct Z {"
799*67e74705SXin Li " void A(int a) const volatile;"
800*67e74705SXin Li "};",
801*67e74705SXin Li "A",
802*67e74705SXin Li "void A(int a) const volatile"));
803*67e74705SXin Li // Should be: with semicolon
804*67e74705SXin Li }
805*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_RefQualifier1)806*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_RefQualifier1) {
807*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
808*67e74705SXin Li "struct Z {"
809*67e74705SXin Li " void A(int a) &;"
810*67e74705SXin Li "};",
811*67e74705SXin Li "A",
812*67e74705SXin Li "void A(int a) &"));
813*67e74705SXin Li // Should be: with semicolon
814*67e74705SXin Li }
815*67e74705SXin Li
TEST(DeclPrinter,TestCXXMethodDecl_RefQualifier2)816*67e74705SXin Li TEST(DeclPrinter, TestCXXMethodDecl_RefQualifier2) {
817*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
818*67e74705SXin Li "struct Z {"
819*67e74705SXin Li " void A(int a) &&;"
820*67e74705SXin Li "};",
821*67e74705SXin Li "A",
822*67e74705SXin Li "void A(int a) &&"));
823*67e74705SXin Li // Should be: with semicolon
824*67e74705SXin Li }
825*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl_ExceptionSpecification1)826*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl_ExceptionSpecification1) {
827*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
828*67e74705SXin Li "struct Z {"
829*67e74705SXin Li " void A(int a) throw();"
830*67e74705SXin Li "};",
831*67e74705SXin Li "A",
832*67e74705SXin Li "void A(int a) throw()"));
833*67e74705SXin Li // Should be: with semicolon
834*67e74705SXin Li }
835*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl_ExceptionSpecification2)836*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl_ExceptionSpecification2) {
837*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
838*67e74705SXin Li "struct Z {"
839*67e74705SXin Li " void A(int a) throw(int);"
840*67e74705SXin Li "};",
841*67e74705SXin Li "A",
842*67e74705SXin Li "void A(int a) throw(int)"));
843*67e74705SXin Li // Should be: with semicolon
844*67e74705SXin Li }
845*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl_ExceptionSpecification3)846*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl_ExceptionSpecification3) {
847*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
848*67e74705SXin Li "class ZZ {};"
849*67e74705SXin Li "struct Z {"
850*67e74705SXin Li " void A(int a) throw(ZZ, int);"
851*67e74705SXin Li "};",
852*67e74705SXin Li "A",
853*67e74705SXin Li "void A(int a) throw(ZZ, int)"));
854*67e74705SXin Li // Should be: with semicolon
855*67e74705SXin Li }
856*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl_ExceptionSpecification4)857*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl_ExceptionSpecification4) {
858*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
859*67e74705SXin Li "struct Z {"
860*67e74705SXin Li " void A(int a) noexcept;"
861*67e74705SXin Li "};",
862*67e74705SXin Li "A",
863*67e74705SXin Li "void A(int a) noexcept"));
864*67e74705SXin Li // Should be: with semicolon
865*67e74705SXin Li }
866*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl_ExceptionSpecification5)867*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl_ExceptionSpecification5) {
868*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
869*67e74705SXin Li "struct Z {"
870*67e74705SXin Li " void A(int a) noexcept(true);"
871*67e74705SXin Li "};",
872*67e74705SXin Li "A",
873*67e74705SXin Li "void A(int a) noexcept(trueA(int a) noexcept(true)"));
874*67e74705SXin Li // WRONG; Should be: "void A(int a) noexcept(true);"
875*67e74705SXin Li }
876*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl_ExceptionSpecification6)877*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl_ExceptionSpecification6) {
878*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
879*67e74705SXin Li "struct Z {"
880*67e74705SXin Li " void A(int a) noexcept(1 < 2);"
881*67e74705SXin Li "};",
882*67e74705SXin Li "A",
883*67e74705SXin Li "void A(int a) noexcept(1 < 2A(int a) noexcept(1 < 2)"));
884*67e74705SXin Li // WRONG; Should be: "void A(int a) noexcept(1 < 2);"
885*67e74705SXin Li }
886*67e74705SXin Li
TEST(DeclPrinter,TestFunctionDecl_ExceptionSpecification7)887*67e74705SXin Li TEST(DeclPrinter, TestFunctionDecl_ExceptionSpecification7) {
888*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
889*67e74705SXin Li "template<int N>"
890*67e74705SXin Li "struct Z {"
891*67e74705SXin Li " void A(int a) noexcept(N < 2);"
892*67e74705SXin Li "};",
893*67e74705SXin Li "A",
894*67e74705SXin Li "void A(int a) noexcept(N < 2A(int a) noexcept(N < 2)"));
895*67e74705SXin Li // WRONG; Should be: "void A(int a) noexcept(N < 2);"
896*67e74705SXin Li }
897*67e74705SXin Li
TEST(DeclPrinter,TestVarDecl1)898*67e74705SXin Li TEST(DeclPrinter, TestVarDecl1) {
899*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
900*67e74705SXin Li "char *const (*(*A)[5])(int);",
901*67e74705SXin Li "A",
902*67e74705SXin Li "char *const (*(*A)[5])(int)"));
903*67e74705SXin Li // Should be: with semicolon
904*67e74705SXin Li }
905*67e74705SXin Li
TEST(DeclPrinter,TestVarDecl2)906*67e74705SXin Li TEST(DeclPrinter, TestVarDecl2) {
907*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
908*67e74705SXin Li "void (*A)() throw(int);",
909*67e74705SXin Li "A",
910*67e74705SXin Li "void (*A)() throw(int)"));
911*67e74705SXin Li // Should be: with semicolon
912*67e74705SXin Li }
913*67e74705SXin Li
TEST(DeclPrinter,TestVarDecl3)914*67e74705SXin Li TEST(DeclPrinter, TestVarDecl3) {
915*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
916*67e74705SXin Li "void (*A)() noexcept;",
917*67e74705SXin Li "A",
918*67e74705SXin Li "void (*A)() noexcept"));
919*67e74705SXin Li // Should be: with semicolon
920*67e74705SXin Li }
921*67e74705SXin Li
TEST(DeclPrinter,TestFieldDecl1)922*67e74705SXin Li TEST(DeclPrinter, TestFieldDecl1) {
923*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
924*67e74705SXin Li "template<typename T>"
925*67e74705SXin Li "struct Z { T A; };",
926*67e74705SXin Li "A",
927*67e74705SXin Li "T A"));
928*67e74705SXin Li // Should be: with semicolon
929*67e74705SXin Li }
930*67e74705SXin Li
TEST(DeclPrinter,TestFieldDecl2)931*67e74705SXin Li TEST(DeclPrinter, TestFieldDecl2) {
932*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
933*67e74705SXin Li "template<int N>"
934*67e74705SXin Li "struct Z { int A[N]; };",
935*67e74705SXin Li "A",
936*67e74705SXin Li "int A[N]"));
937*67e74705SXin Li // Should be: with semicolon
938*67e74705SXin Li }
939*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl1)940*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl1) {
941*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
942*67e74705SXin Li "template<typename T>"
943*67e74705SXin Li "struct A { T a; };",
944*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
945*67e74705SXin Li "template <typename T> struct A {\n}"));
946*67e74705SXin Li // Should be: with semicolon, with { ... }
947*67e74705SXin Li }
948*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl2)949*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl2) {
950*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
951*67e74705SXin Li "template<typename T = int>"
952*67e74705SXin Li "struct A { T a; };",
953*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
954*67e74705SXin Li "template <typename T = int> struct A {\n}"));
955*67e74705SXin Li // Should be: with semicolon, with { ... }
956*67e74705SXin Li }
957*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl3)958*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl3) {
959*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
960*67e74705SXin Li "template<class T>"
961*67e74705SXin Li "struct A { T a; };",
962*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
963*67e74705SXin Li "template <class T> struct A {\n}"));
964*67e74705SXin Li // Should be: with semicolon, with { ... }
965*67e74705SXin Li }
966*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl4)967*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl4) {
968*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
969*67e74705SXin Li "template<typename T, typename U>"
970*67e74705SXin Li "struct A { T a; U b; };",
971*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
972*67e74705SXin Li "template <typename T, typename U> struct A {\n}"));
973*67e74705SXin Li // Should be: with semicolon, with { ... }
974*67e74705SXin Li }
975*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl5)976*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl5) {
977*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
978*67e74705SXin Li "template<int N>"
979*67e74705SXin Li "struct A { int a[N]; };",
980*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
981*67e74705SXin Li "template <int N> struct A {\n}"));
982*67e74705SXin Li // Should be: with semicolon, with { ... }
983*67e74705SXin Li }
984*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl6)985*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl6) {
986*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
987*67e74705SXin Li "template<int N = 42>"
988*67e74705SXin Li "struct A { int a[N]; };",
989*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
990*67e74705SXin Li "template <int N = 42> struct A {\n}"));
991*67e74705SXin Li // Should be: with semicolon, with { ... }
992*67e74705SXin Li }
993*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl7)994*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl7) {
995*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
996*67e74705SXin Li "typedef int MyInt;"
997*67e74705SXin Li "template<MyInt N>"
998*67e74705SXin Li "struct A { int a[N]; };",
999*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
1000*67e74705SXin Li "template <MyInt N> struct A {\n}"));
1001*67e74705SXin Li // Should be: with semicolon, with { ... }
1002*67e74705SXin Li }
1003*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl8)1004*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl8) {
1005*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1006*67e74705SXin Li "template<template<typename U> class T> struct A { };",
1007*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
1008*67e74705SXin Li "template <template <typename U> class T> struct A {\n}"));
1009*67e74705SXin Li // Should be: with semicolon, with { ... }
1010*67e74705SXin Li }
1011*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl9)1012*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl9) {
1013*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1014*67e74705SXin Li "template<typename T> struct Z { };"
1015*67e74705SXin Li "template<template<typename U> class T = Z> struct A { };",
1016*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
1017*67e74705SXin Li "template <template <typename U> class T> struct A {\n}"));
1018*67e74705SXin Li // Should be: with semicolon, with { ... }
1019*67e74705SXin Li }
1020*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl10)1021*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl10) {
1022*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
1023*67e74705SXin Li "template<typename... T>"
1024*67e74705SXin Li "struct A { int a; };",
1025*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
1026*67e74705SXin Li "template <typename ...T> struct A {\n}"));
1027*67e74705SXin Li // Should be: with semicolon, with { ... }
1028*67e74705SXin Li }
1029*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateDecl11)1030*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateDecl11) {
1031*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
1032*67e74705SXin Li "template<typename... T>"
1033*67e74705SXin Li "struct A : public T... { int a; };",
1034*67e74705SXin Li classTemplateDecl(hasName("A")).bind("id"),
1035*67e74705SXin Li "template <typename ...T> struct A : public T... {\n}"));
1036*67e74705SXin Li // Should be: with semicolon, with { ... }
1037*67e74705SXin Li }
1038*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplatePartialSpecializationDecl1)1039*67e74705SXin Li TEST(DeclPrinter, TestClassTemplatePartialSpecializationDecl1) {
1040*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1041*67e74705SXin Li "template<typename T, typename U>"
1042*67e74705SXin Li "struct A { T a; U b; };"
1043*67e74705SXin Li "template<typename T>"
1044*67e74705SXin Li "struct A<T, int> { T a; };",
1045*67e74705SXin Li classTemplateSpecializationDecl().bind("id"),
1046*67e74705SXin Li "struct A {\n}"));
1047*67e74705SXin Li // WRONG; Should be: "template<typename T> struct A<T, int> { ... }"
1048*67e74705SXin Li }
1049*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplatePartialSpecializationDecl2)1050*67e74705SXin Li TEST(DeclPrinter, TestClassTemplatePartialSpecializationDecl2) {
1051*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1052*67e74705SXin Li "template<typename T>"
1053*67e74705SXin Li "struct A { T a; };"
1054*67e74705SXin Li "template<typename T>"
1055*67e74705SXin Li "struct A<T *> { T a; };",
1056*67e74705SXin Li classTemplateSpecializationDecl().bind("id"),
1057*67e74705SXin Li "struct A {\n}"));
1058*67e74705SXin Li // WRONG; Should be: "template<typename T> struct A<T *> { ... }"
1059*67e74705SXin Li }
1060*67e74705SXin Li
TEST(DeclPrinter,TestClassTemplateSpecializationDecl1)1061*67e74705SXin Li TEST(DeclPrinter, TestClassTemplateSpecializationDecl1) {
1062*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1063*67e74705SXin Li "template<typename T>"
1064*67e74705SXin Li "struct A { T a; };"
1065*67e74705SXin Li "template<>"
1066*67e74705SXin Li "struct A<int> { int a; };",
1067*67e74705SXin Li classTemplateSpecializationDecl().bind("id"),
1068*67e74705SXin Li "struct A {\n}"));
1069*67e74705SXin Li // WRONG; Should be: "template<> struct A<int> { ... }"
1070*67e74705SXin Li }
1071*67e74705SXin Li
TEST(DeclPrinter,TestFunctionTemplateDecl1)1072*67e74705SXin Li TEST(DeclPrinter, TestFunctionTemplateDecl1) {
1073*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1074*67e74705SXin Li "template<typename T>"
1075*67e74705SXin Li "void A(T &t);",
1076*67e74705SXin Li functionTemplateDecl(hasName("A")).bind("id"),
1077*67e74705SXin Li "template <typename T> void A(T &t)"));
1078*67e74705SXin Li // Should be: with semicolon
1079*67e74705SXin Li }
1080*67e74705SXin Li
TEST(DeclPrinter,TestFunctionTemplateDecl2)1081*67e74705SXin Li TEST(DeclPrinter, TestFunctionTemplateDecl2) {
1082*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1083*67e74705SXin Li "template<typename T>"
1084*67e74705SXin Li "void A(T &t) { }",
1085*67e74705SXin Li functionTemplateDecl(hasName("A")).bind("id"),
1086*67e74705SXin Li "template <typename T> void A(T &t)"));
1087*67e74705SXin Li // Should be: with semicolon
1088*67e74705SXin Li }
1089*67e74705SXin Li
TEST(DeclPrinter,TestFunctionTemplateDecl3)1090*67e74705SXin Li TEST(DeclPrinter, TestFunctionTemplateDecl3) {
1091*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
1092*67e74705SXin Li "template<typename... T>"
1093*67e74705SXin Li "void A(T... a);",
1094*67e74705SXin Li functionTemplateDecl(hasName("A")).bind("id"),
1095*67e74705SXin Li "template <typename ...T> void A(T ...a)"));
1096*67e74705SXin Li // Should be: with semicolon.
1097*67e74705SXin Li }
1098*67e74705SXin Li
TEST(DeclPrinter,TestFunctionTemplateDecl4)1099*67e74705SXin Li TEST(DeclPrinter, TestFunctionTemplateDecl4) {
1100*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1101*67e74705SXin Li "struct Z { template<typename T> void A(T t); };",
1102*67e74705SXin Li functionTemplateDecl(hasName("A")).bind("id"),
1103*67e74705SXin Li "template <typename T> void A(T t)"));
1104*67e74705SXin Li // Should be: with semicolon
1105*67e74705SXin Li }
1106*67e74705SXin Li
TEST(DeclPrinter,TestFunctionTemplateDecl5)1107*67e74705SXin Li TEST(DeclPrinter, TestFunctionTemplateDecl5) {
1108*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1109*67e74705SXin Li "struct Z { template<typename T> void A(T t) {} };",
1110*67e74705SXin Li functionTemplateDecl(hasName("A")).bind("id"),
1111*67e74705SXin Li "template <typename T> void A(T t)"));
1112*67e74705SXin Li // Should be: with semicolon
1113*67e74705SXin Li }
1114*67e74705SXin Li
TEST(DeclPrinter,TestFunctionTemplateDecl6)1115*67e74705SXin Li TEST(DeclPrinter, TestFunctionTemplateDecl6) {
1116*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1117*67e74705SXin Li "template<typename T >struct Z {"
1118*67e74705SXin Li " template<typename U> void A(U t) {}"
1119*67e74705SXin Li "};",
1120*67e74705SXin Li functionTemplateDecl(hasName("A")).bind("id"),
1121*67e74705SXin Li "template <typename U> void A(U t)"));
1122*67e74705SXin Li // Should be: with semicolon
1123*67e74705SXin Li }
1124*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList1)1125*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList1) {
1126*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1127*67e74705SXin Li "template<typename T> struct Z {};"
1128*67e74705SXin Li "struct X {};"
1129*67e74705SXin Li "Z<X> A;",
1130*67e74705SXin Li "A",
1131*67e74705SXin Li "Z<X> A"));
1132*67e74705SXin Li // Should be: with semicolon
1133*67e74705SXin Li }
1134*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList2)1135*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList2) {
1136*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1137*67e74705SXin Li "template<typename T, typename U> struct Z {};"
1138*67e74705SXin Li "struct X {};"
1139*67e74705SXin Li "typedef int Y;"
1140*67e74705SXin Li "Z<X, Y> A;",
1141*67e74705SXin Li "A",
1142*67e74705SXin Li "Z<X, Y> A"));
1143*67e74705SXin Li // Should be: with semicolon
1144*67e74705SXin Li }
1145*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList3)1146*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList3) {
1147*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1148*67e74705SXin Li "template<typename T> struct Z {};"
1149*67e74705SXin Li "template<typename T> struct X {};"
1150*67e74705SXin Li "Z<X<int> > A;",
1151*67e74705SXin Li "A",
1152*67e74705SXin Li "Z<X<int> > A"));
1153*67e74705SXin Li // Should be: with semicolon
1154*67e74705SXin Li }
1155*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList4)1156*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList4) {
1157*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
1158*67e74705SXin Li "template<typename T> struct Z {};"
1159*67e74705SXin Li "template<typename T> struct X {};"
1160*67e74705SXin Li "Z<X<int>> A;",
1161*67e74705SXin Li "A",
1162*67e74705SXin Li "Z<X<int> > A"));
1163*67e74705SXin Li // Should be: with semicolon, without extra space in "> >"
1164*67e74705SXin Li }
1165*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList5)1166*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList5) {
1167*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1168*67e74705SXin Li "template<typename T> struct Z {};"
1169*67e74705SXin Li "template<typename T> struct X { Z<T> A; };",
1170*67e74705SXin Li "A",
1171*67e74705SXin Li "Z<T> A"));
1172*67e74705SXin Li // Should be: with semicolon
1173*67e74705SXin Li }
1174*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList6)1175*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList6) {
1176*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1177*67e74705SXin Li "template<template<typename T> class U> struct Z {};"
1178*67e74705SXin Li "template<typename T> struct X {};"
1179*67e74705SXin Li "Z<X> A;",
1180*67e74705SXin Li "A",
1181*67e74705SXin Li "Z<X> A"));
1182*67e74705SXin Li // Should be: with semicolon
1183*67e74705SXin Li }
1184*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList7)1185*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList7) {
1186*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1187*67e74705SXin Li "template<template<typename T> class U> struct Z {};"
1188*67e74705SXin Li "template<template<typename T> class U> struct Y {"
1189*67e74705SXin Li " Z<U> A;"
1190*67e74705SXin Li "};",
1191*67e74705SXin Li "A",
1192*67e74705SXin Li "Z<U> A"));
1193*67e74705SXin Li // Should be: with semicolon
1194*67e74705SXin Li }
1195*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList8)1196*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList8) {
1197*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1198*67e74705SXin Li "template<typename T> struct Z {};"
1199*67e74705SXin Li "template<template<typename T> class U> struct Y {"
1200*67e74705SXin Li " Z<U<int> > A;"
1201*67e74705SXin Li "};",
1202*67e74705SXin Li "A",
1203*67e74705SXin Li "Z<U<int> > A"));
1204*67e74705SXin Li // Should be: with semicolon
1205*67e74705SXin Li }
1206*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList9)1207*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList9) {
1208*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1209*67e74705SXin Li "template<unsigned I> struct Z {};"
1210*67e74705SXin Li "Z<0> A;",
1211*67e74705SXin Li "A",
1212*67e74705SXin Li "Z<0> A"));
1213*67e74705SXin Li // Should be: with semicolon
1214*67e74705SXin Li }
1215*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList10)1216*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList10) {
1217*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1218*67e74705SXin Li "template<unsigned I> struct Z {};"
1219*67e74705SXin Li "template<unsigned I> struct X { Z<I> A; };",
1220*67e74705SXin Li "A",
1221*67e74705SXin Li "Z<I> A"));
1222*67e74705SXin Li // Should be: with semicolon
1223*67e74705SXin Li }
1224*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList11)1225*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList11) {
1226*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1227*67e74705SXin Li "template<int I> struct Z {};"
1228*67e74705SXin Li "Z<42 * 10 - 420 / 1> A;",
1229*67e74705SXin Li "A",
1230*67e74705SXin Li "Z<42 * 10 - 420 / 1> A"));
1231*67e74705SXin Li // Should be: with semicolon
1232*67e74705SXin Li }
1233*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList12)1234*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList12) {
1235*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX98Matches(
1236*67e74705SXin Li "template<const char *p> struct Z {};"
1237*67e74705SXin Li "extern const char X[] = \"aaa\";"
1238*67e74705SXin Li "Z<X> A;",
1239*67e74705SXin Li "A",
1240*67e74705SXin Li "Z<X> A"));
1241*67e74705SXin Li // Should be: with semicolon
1242*67e74705SXin Li }
1243*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList13)1244*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList13) {
1245*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
1246*67e74705SXin Li "template<typename... T> struct Z {};"
1247*67e74705SXin Li "template<typename... T> struct X {"
1248*67e74705SXin Li " Z<T...> A;"
1249*67e74705SXin Li "};",
1250*67e74705SXin Li "A",
1251*67e74705SXin Li "Z<T...> A"));
1252*67e74705SXin Li // Should be: with semicolon
1253*67e74705SXin Li }
1254*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList14)1255*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList14) {
1256*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
1257*67e74705SXin Li "template<typename... T> struct Z {};"
1258*67e74705SXin Li "template<typename T> struct Y {};"
1259*67e74705SXin Li "template<typename... T> struct X {"
1260*67e74705SXin Li " Z<Y<T>...> A;"
1261*67e74705SXin Li "};",
1262*67e74705SXin Li "A",
1263*67e74705SXin Li "Z<Y<T>...> A"));
1264*67e74705SXin Li // Should be: with semicolon
1265*67e74705SXin Li }
1266*67e74705SXin Li
TEST(DeclPrinter,TestTemplateArgumentList15)1267*67e74705SXin Li TEST(DeclPrinter, TestTemplateArgumentList15) {
1268*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX11Matches(
1269*67e74705SXin Li "template<unsigned I> struct Z {};"
1270*67e74705SXin Li "template<typename... T> struct X {"
1271*67e74705SXin Li " Z<sizeof...(T)> A;"
1272*67e74705SXin Li "};",
1273*67e74705SXin Li "A",
1274*67e74705SXin Li "Z<sizeof...(T)> A"));
1275*67e74705SXin Li // Should be: with semicolon
1276*67e74705SXin Li }
1277*67e74705SXin Li
TEST(DeclPrinter,TestStaticAssert1)1278*67e74705SXin Li TEST(DeclPrinter, TestStaticAssert1) {
1279*67e74705SXin Li ASSERT_TRUE(PrintedDeclCXX1ZMatches(
1280*67e74705SXin Li "static_assert(true);",
1281*67e74705SXin Li staticAssertDecl().bind("id"),
1282*67e74705SXin Li "static_assert(true)"));
1283*67e74705SXin Li }
1284*67e74705SXin Li
TEST(DeclPrinter,TestObjCMethod1)1285*67e74705SXin Li TEST(DeclPrinter, TestObjCMethod1) {
1286*67e74705SXin Li ASSERT_TRUE(PrintedDeclObjCMatches(
1287*67e74705SXin Li "__attribute__((objc_root_class)) @interface X\n"
1288*67e74705SXin Li "- (int)A:(id)anObject inRange:(long)range;\n"
1289*67e74705SXin Li "@end\n"
1290*67e74705SXin Li "@implementation X\n"
1291*67e74705SXin Li "- (int)A:(id)anObject inRange:(long)range { int printThis; return 0; }\n"
1292*67e74705SXin Li "@end\n",
1293*67e74705SXin Li namedDecl(hasName("A:inRange:"),
1294*67e74705SXin Li hasDescendant(namedDecl(hasName("printThis")))).bind("id"),
1295*67e74705SXin Li "- (int) A:(id)anObject inRange:(long)range"));
1296*67e74705SXin Li }
1297*67e74705SXin Li
TEST(DeclPrinter,TestObjCProtocol1)1298*67e74705SXin Li TEST(DeclPrinter, TestObjCProtocol1) {
1299*67e74705SXin Li ASSERT_TRUE(PrintedDeclObjCMatches(
1300*67e74705SXin Li "@protocol P1, P2;",
1301*67e74705SXin Li namedDecl(hasName("P1")).bind("id"),
1302*67e74705SXin Li "@protocol P1;\n"));
1303*67e74705SXin Li ASSERT_TRUE(PrintedDeclObjCMatches(
1304*67e74705SXin Li "@protocol P1, P2;",
1305*67e74705SXin Li namedDecl(hasName("P2")).bind("id"),
1306*67e74705SXin Li "@protocol P2;\n"));
1307*67e74705SXin Li }
1308*67e74705SXin Li
TEST(DeclPrinter,TestObjCProtocol2)1309*67e74705SXin Li TEST(DeclPrinter, TestObjCProtocol2) {
1310*67e74705SXin Li ASSERT_TRUE(PrintedDeclObjCMatches(
1311*67e74705SXin Li "@protocol P2 @end"
1312*67e74705SXin Li "@protocol P1<P2> @end",
1313*67e74705SXin Li namedDecl(hasName("P1")).bind("id"),
1314*67e74705SXin Li "@protocol P1<P2>\n@end"));
1315*67e74705SXin Li }
1316