From bfef399519ca9b8a4b4c6b563253bad7e0eeffe0 Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Sun, 22 Dec 2013 00:07:40 +0000 Subject: Vendor import of clang release_34 branch r197841 (effectively, 3.4 RC3): https://llvm.org/svn/llvm-project/cfe/branches/release_34@197841 --- unittests/Format/FormatTest.cpp | 4012 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 3705 insertions(+), 307 deletions(-) (limited to 'unittests/Format/FormatTest.cpp') diff --git a/unittests/Format/FormatTest.cpp b/unittests/Format/FormatTest.cpp index 4c948e89e9807..b6574c7503aaa 100644 --- a/unittests/Format/FormatTest.cpp +++ b/unittests/Format/FormatTest.cpp @@ -10,7 +10,6 @@ #define DEBUG_TYPE "format-test" #include "clang/Format/Format.h" -#include "../Tooling/RewriterTestContext.h" #include "clang/Lex/Lexer.h" #include "llvm/Support/Debug.h" #include "gtest/gtest.h" @@ -23,21 +22,14 @@ protected: std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length, const FormatStyle &Style) { DEBUG(llvm::errs() << "---\n"); - RewriterTestContext Context; - FileID ID = Context.createInMemoryFile("input.cc", Code); - SourceLocation Start = - Context.Sources.getLocForStartOfFile(ID).getLocWithOffset(Offset); - std::vector Ranges( - 1, - CharSourceRange::getCharRange(Start, Start.getLocWithOffset(Length))); - Lexer Lex(ID, Context.Sources.getBuffer(ID), Context.Sources, - getFormattingLangOpts()); - tooling::Replacements Replace = reformat( - Style, Lex, Context.Sources, Ranges, new IgnoringDiagConsumer()); - ReplacementCount = Replace.size(); - EXPECT_TRUE(applyAllReplacements(Replace, Context.Rewrite)); - DEBUG(llvm::errs() << "\n" << Context.getRewrittenText(ID) << "\n\n"); - return Context.getRewrittenText(ID); + DEBUG(llvm::errs() << Code << "\n\n"); + std::vector Ranges(1, tooling::Range(Offset, Length)); + tooling::Replacements Replaces = reformat(Style, Code, Ranges); + ReplacementCount = Replaces.size(); + std::string Result = applyAllReplacements(Code, Replaces); + EXPECT_NE("", Result); + DEBUG(llvm::errs() << "\n" << Result << "\n\n"); + return Result; } std::string @@ -75,7 +67,14 @@ protected: JustReplacedNewline = false; } } - return MessedUp; + std::string WithoutWhitespace; + if (MessedUp[0] != ' ') + WithoutWhitespace.push_back(MessedUp[0]); + for (unsigned i = 1, e = MessedUp.size(); i != e; ++i) { + if (MessedUp[i] != ' ' || MessedUp[i - 1] != ' ') + WithoutWhitespace.push_back(MessedUp[i]); + } + return WithoutWhitespace; } FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) { @@ -112,20 +111,20 @@ TEST_F(FormatTest, MessUp) { EXPECT_EQ("1 2 3\n", messUp("1\n2\n3\n")); EXPECT_EQ("a\n//b\nc", messUp("a\n//b\nc")); EXPECT_EQ("a\n#b\nc", messUp("a\n#b\nc")); - EXPECT_EQ("a\n#b c d\ne", messUp("a\n#b\\\nc\\\nd\ne")); + EXPECT_EQ("a\n#b c d\ne", messUp("a\n#b\\\nc\\\nd\ne")); } //===----------------------------------------------------------------------===// // Basic function tests. //===----------------------------------------------------------------------===// -TEST_F(FormatTest, DoesNotChangeCorrectlyFormatedCode) { +TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { EXPECT_EQ(";", format(";")); } TEST_F(FormatTest, FormatsGlobalStatementsAt0) { EXPECT_EQ("int i;", format(" int i;")); - EXPECT_EQ("\nint i;", format(" \n\t \r int i;")); + EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;")); EXPECT_EQ("int i;\nint j;", format(" int i; int j;")); EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;")); } @@ -147,6 +146,7 @@ TEST_F(FormatTest, FormatsNestedCall) { TEST_F(FormatTest, NestedNameSpecifiers) { verifyFormat("vector< ::Type> v;"); verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())"); + verifyFormat("static constexpr bool Bar = decltype(bar())::value;"); } TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { @@ -201,6 +201,53 @@ TEST_F(FormatTest, RemovesWhitespaceWhenTriggeredOnEmptyLine) { format("int a;\n \n\n int b;", 9, 0, getLLVMStyle())); } +TEST_F(FormatTest, RemovesEmptyLines) { + EXPECT_EQ("class C {\n" + " int i;\n" + "};", + format("class C {\n" + " int i;\n" + "\n" + "};")); + + // Don't remove empty lines in more complex control statements. + EXPECT_EQ("void f() {\n" + " if (a) {\n" + " f();\n" + "\n" + " } else if (b) {\n" + " f();\n" + " }\n" + "}", + format("void f() {\n" + " if (a) {\n" + " f();\n" + "\n" + " } else if (b) {\n" + " f();\n" + "\n" + " }\n" + "\n" + "}")); + + // FIXME: This is slightly inconsistent. + EXPECT_EQ("namespace {\n" + "int i;\n" + "}", + format("namespace {\n" + "int i;\n" + "\n" + "}")); + EXPECT_EQ("namespace {\n" + "int i;\n" + "\n" + "} // namespace", + format("namespace {\n" + "int i;\n" + "\n" + "} // namespace")); +} + TEST_F(FormatTest, ReformatsMovedLines) { EXPECT_EQ( "template T *getFETokenInfo() const {\n" @@ -218,25 +265,31 @@ TEST_F(FormatTest, ReformatsMovedLines) { // Tests for control statements. //===----------------------------------------------------------------------===// -TEST_F(FormatTest, FormatIfWithoutCompountStatement) { +TEST_F(FormatTest, FormatIfWithoutCompoundStatement) { verifyFormat("if (true)\n f();\ng();"); verifyFormat("if (a)\n if (b)\n if (c)\n g();\nh();"); verifyFormat("if (a)\n if (b) {\n f();\n }\ng();"); - FormatStyle AllowsMergedIf = getGoogleStyle(); + FormatStyle AllowsMergedIf = getLLVMStyle(); AllowsMergedIf.AllowShortIfStatementsOnASingleLine = true; verifyFormat("if (a)\n" " // comment\n" " f();", AllowsMergedIf); + verifyFormat("if (a)\n" + " ;", + AllowsMergedIf); + verifyFormat("if (a)\n" + " if (b) return;", + AllowsMergedIf); - verifyFormat("if (a) // Can't merge this\n" + verifyFormat("if (a) // Can't merge this\n" " f();\n", AllowsMergedIf); verifyFormat("if (a) /* still don't merge */\n" " f();", AllowsMergedIf); - verifyFormat("if (a) { // Never merge this\n" + verifyFormat("if (a) { // Never merge this\n" " f();\n" "}", AllowsMergedIf); @@ -245,6 +298,10 @@ TEST_F(FormatTest, FormatIfWithoutCompountStatement) { "}", AllowsMergedIf); + EXPECT_EQ("if (a) return;", format("if(a)\nreturn;", 7, 1, AllowsMergedIf)); + EXPECT_EQ("if (a) return; // comment", + format("if(a)\nreturn; // comment", 20, 1, AllowsMergedIf)); + AllowsMergedIf.ColumnLimit = 14; verifyFormat("if (a) return;", AllowsMergedIf); verifyFormat("if (aaaaaaaaa)\n" @@ -255,6 +312,29 @@ TEST_F(FormatTest, FormatIfWithoutCompountStatement) { verifyFormat("if (a)\n return;", AllowsMergedIf); } +TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { + FormatStyle AllowsMergedLoops = getLLVMStyle(); + AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; + verifyFormat("while (true) continue;", AllowsMergedLoops); + verifyFormat("for (;;) continue;", AllowsMergedLoops); + verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); + verifyFormat("while (true)\n" + " ;", + AllowsMergedLoops); + verifyFormat("for (;;)\n" + " ;", + AllowsMergedLoops); + verifyFormat("for (;;)\n" + " for (;;) continue;", + AllowsMergedLoops); + verifyFormat("for (;;) // Can't merge this\n" + " continue;", + AllowsMergedLoops); + verifyFormat("for (;;) /* still don't merge */\n" + " continue;", + AllowsMergedLoops); +} + TEST_F(FormatTest, ParseIfElse) { verifyFormat("if (true)\n" " if (true)\n" @@ -279,6 +359,11 @@ TEST_F(FormatTest, ParseIfElse) { "else {\n" " i();\n" "}"); + verifyFormat("void f() {\n" + " if (a) {\n" + " } else {\n" + " }\n" + "}"); } TEST_F(FormatTest, ElseIf) { @@ -289,6 +374,13 @@ TEST_F(FormatTest, ElseIf) { " g();\n" "else\n" " h();"); + verifyFormat("if (a) {\n" + " f();\n" + "}\n" + "// or else ..\n" + "else {\n" + " g()\n" + "}"); } TEST_F(FormatTest, FormatsForLoop) { @@ -453,6 +545,10 @@ TEST_F(FormatTest, FormatsSwitchStatement) { " case a: \\\n" " foo = b; \\\n" " }", getLLVMStyleWithColumns(20)); + verifyFormat("#define OPERATION_CASE(name) \\\n" + " case OP_name: \\\n" + " return operations::Operation##name\n", + getLLVMStyleWithColumns(40)); verifyGoogleFormat("switch (x) {\n" " case 1:\n" @@ -473,7 +569,40 @@ TEST_F(FormatTest, FormatsSwitchStatement) { " }\n" "}"); verifyGoogleFormat("switch (test)\n" - " ;"); + " ;"); + + verifyGoogleFormat("#define OPERATION_CASE(name) \\\n" + " case OP_name: \\\n" + " return operations::Operation##name\n"); + verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n" + " // Get the correction operation class.\n" + " switch (OpCode) {\n" + " CASE(Add);\n" + " CASE(Subtract);\n" + " default:\n" + " return operations::Unknown;\n" + " }\n" + "#undef OPERATION_CASE\n" + "}"); + verifyFormat("DEBUG({\n" + " switch (x) {\n" + " case A:\n" + " f();\n" + " break;\n" + " // On B:\n" + " case B:\n" + " g();\n" + " break;\n" + " }\n" + "});"); +} + +TEST_F(FormatTest, CaseRanges) { + verifyFormat("switch (x) {\n" + "case 'A' ... 'Z':\n" + "case 1 ... 5:\n" + " break;\n" + "}"); } TEST_F(FormatTest, FormatsLabels) { @@ -505,6 +634,9 @@ TEST_F(FormatTest, UnderstandsSingleLineComments) { verifyFormat("void f() {\n" " // Doesn't do anything\n" "}"); + verifyFormat("SomeObject\n" + " // Calling someFunction on SomeObject\n" + " .someFunction();"); verifyFormat("void f(int i, // some comment (probably for i)\n" " int j, // some comment (probably for j)\n" " int k); // some comment (probably for k)"); @@ -543,6 +675,11 @@ TEST_F(FormatTest, UnderstandsSingleLineComments) { "#include \"a/b/c\" // comment"); verifyFormat("#include // comment\n" "#include // comment"); + EXPECT_EQ("#include \"a\" // comment\n" + "#include \"a/b/c\" // comment", + format("#include \\\n" + " \"a\" // comment\n" + "#include \"a/b/c\" // comment")); verifyFormat("enum E {\n" " // comment\n" @@ -571,14 +708,17 @@ TEST_F(FormatTest, UnderstandsSingleLineComments) { format("void f() { // This does something ..\n" " }\n" "int a; // This is unrelated")); - EXPECT_EQ("void f() { // This does something ..\n" - "} // awesome..\n" + EXPECT_EQ("class C {\n" + " void f() { // This does something ..\n" + " } // awesome..\n" "\n" - "int a; // This is unrelated", - format("void f() { // This does something ..\n" + " int a; // This is unrelated\n" + "};", + format("class C{void f() { // This does something ..\n" " } // awesome..\n" " \n" - "int a; // This is unrelated")); + "int a; // This is unrelated\n" + "};")); EXPECT_EQ("int i; // single line trailing comment", format("int i;\\\n// single line trailing comment")); @@ -598,7 +738,7 @@ TEST_F(FormatTest, UnderstandsSingleLineComments) { "};"); verifyGoogleFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n" - " aaaaaaaaaaaaaaaaaaaaaa); // 81 cols with this comment"); + " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment"); EXPECT_EQ("D(a, {\n" " // test\n" " int a;\n" @@ -607,6 +747,66 @@ TEST_F(FormatTest, UnderstandsSingleLineComments) { "// test\n" "int a;\n" "});")); + + EXPECT_EQ("lineWith(); // comment\n" + "// at start\n" + "otherLine();", + format("lineWith(); // comment\n" + "// at start\n" + "otherLine();")); + EXPECT_EQ("lineWith(); // comment\n" + " // at start\n" + "otherLine();", + format("lineWith(); // comment\n" + " // at start\n" + "otherLine();")); + + EXPECT_EQ("lineWith(); // comment\n" + "// at start\n" + "otherLine(); // comment", + format("lineWith(); // comment\n" + "// at start\n" + "otherLine(); // comment")); + EXPECT_EQ("lineWith();\n" + "// at start\n" + "otherLine(); // comment", + format("lineWith();\n" + " // at start\n" + "otherLine(); // comment")); + EXPECT_EQ("// first\n" + "// at start\n" + "otherLine(); // comment", + format("// first\n" + " // at start\n" + "otherLine(); // comment")); + EXPECT_EQ("f();\n" + "// first\n" + "// at start\n" + "otherLine(); // comment", + format("f();\n" + "// first\n" + " // at start\n" + "otherLine(); // comment")); + verifyFormat("f(); // comment\n" + "// first\n" + "// at start\n" + "otherLine();"); + EXPECT_EQ("f(); // comment\n" + "// first\n" + "// at start\n" + "otherLine();", + format("f(); // comment\n" + "// first\n" + " // at start\n" + "otherLine();")); + EXPECT_EQ("f(); // comment\n" + " // first\n" + "// at start\n" + "otherLine();", + format("f(); // comment\n" + " // first\n" + "// at start\n" + "otherLine();")); } TEST_F(FormatTest, CanFormatCommentsLocally) { @@ -636,10 +836,12 @@ TEST_F(FormatTest, RemovesTrailingWhitespaceOfComments) { EXPECT_EQ("int aaaaaaa, bbbbbbb; // comment", format("int aaaaaaa, bbbbbbb; // comment ", getLLVMStyleWithColumns(33))); + EXPECT_EQ("// comment\\\n", format("// comment\\\n \t \v \f ")); + EXPECT_EQ("// comment \\\n", format("// comment \\\n \t \v \f ")); } -TEST_F(FormatTest, UnderstandsMultiLineComments) { - verifyFormat("f(/*test=*/ true);"); +TEST_F(FormatTest, UnderstandsBlockComments) { + verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);"); EXPECT_EQ( "f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n" " bbbbbbbbbbbbbbbbbbbbbbbbb);", @@ -650,6 +852,15 @@ TEST_F(FormatTest, UnderstandsMultiLineComments) { " /* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);", format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \n" "/* Leading comment for bb... */ bbbbbbbbbbbbbbbbbbbbbbbbb);")); + EXPECT_EQ( + "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" + "}", + format("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaa ,\n" + " aaaaaaaaaaaaaaaaaa) { /*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*/\n" + "}")); FormatStyle NoBinPacking = getLLVMStyle(); NoBinPacking.BinPackParameters = false; @@ -660,7 +871,7 @@ TEST_F(FormatTest, UnderstandsMultiLineComments) { NoBinPacking); } -TEST_F(FormatTest, AlignsMultiLineComments) { +TEST_F(FormatTest, AlignsBlockComments) { EXPECT_EQ("/*\n" " * Really multi-line\n" " * comment.\n" @@ -696,11 +907,49 @@ TEST_F(FormatTest, AlignsMultiLineComments) { " 1.1.1. to keep the formatting.\n" " */")); EXPECT_EQ("/*\n" - " Don't try to outdent if there's not enough inentation.\n" - " */", + "Don't try to outdent if there's not enough indentation.\n" + "*/", format(" /*\n" - " Don't try to outdent if there's not enough inentation.\n" + " Don't try to outdent if there's not enough indentation.\n" " */")); + + EXPECT_EQ("int i; /* Comment with empty...\n" + " *\n" + " * line. */", + format("int i; /* Comment with empty...\n" + " *\n" + " * line. */")); +} + +TEST_F(FormatTest, CorrectlyHandlesLengthOfBlockComments) { + EXPECT_EQ("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */", + format("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */")); + EXPECT_EQ( + "void ffffffffffff(\n" + " int aaaaaaaa, int bbbbbbbb,\n" + " int cccccccccccc) { /*\n" + " aaaaaaaaaa\n" + " aaaaaaaaaaaaa\n" + " bbbbbbbbbbbbbb\n" + " bbbbbbbbbb\n" + " */\n" + "}", + format("void ffffffffffff(int aaaaaaaa, int bbbbbbbb, int cccccccccccc)\n" + "{ /*\n" + " aaaaaaaaaa aaaaaaaaaaaaa\n" + " bbbbbbbbbbbbbb bbbbbbbbbb\n" + " */\n" + "}", + getLLVMStyleWithColumns(40))); +} + +TEST_F(FormatTest, DontBreakNonTrailingBlockComments) { + EXPECT_EQ("void\n" + "ffffffffff(int aaaaa /* test */);", + format("void ffffffffff(int aaaaa /* test */);", + getLLVMStyleWithColumns(35))); } TEST_F(FormatTest, SplitsLongCxxComments) { @@ -727,10 +976,20 @@ TEST_F(FormatTest, SplitsLongCxxComments) { EXPECT_EQ("// Don't_touch_leading_whitespace", format("// Don't_touch_leading_whitespace", getLLVMStyleWithColumns(20))); - EXPECT_EQ( - "//Don't add leading\n" - "//whitespace", - format("//Don't add leading whitespace", getLLVMStyleWithColumns(20))); + EXPECT_EQ("// Add leading\n" + "// whitespace", + format("//Add leading whitespace", getLLVMStyleWithColumns(20))); + EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle())); + EXPECT_EQ("// Even if it makes the line exceed the column\n" + "// limit", + format("//Even if it makes the line exceed the column limit", + getLLVMStyleWithColumns(51))); + EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle())); + + EXPECT_EQ("// aa bb cc dd", + format("// aa bb cc dd ", + getLLVMStyleWithColumns(15))); + EXPECT_EQ("// A comment before\n" "// a macro\n" "// definition\n" @@ -738,6 +997,106 @@ TEST_F(FormatTest, SplitsLongCxxComments) { format("// A comment before a macro definition\n" "#define a b", getLLVMStyleWithColumns(20))); + EXPECT_EQ("void ffffff(int aaaaaaaaa, // wwww\n" + " int a, int bbb, // xxxxxxx\n" + " // yyyyyyyyy\n" + " int c, int d, int e) {}", + format("void ffffff(\n" + " int aaaaaaaaa, // wwww\n" + " int a,\n" + " int bbb, // xxxxxxx yyyyyyyyy\n" + " int c, int d, int e) {}", + getLLVMStyleWithColumns(40))); + EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + getLLVMStyleWithColumns(20))); + EXPECT_EQ( + "#define XXX // a b c d\n" + " // e f g h", + format("#define XXX // a b c d e f g h", getLLVMStyleWithColumns(22))); + EXPECT_EQ( + "#define XXX // q w e r\n" + " // t y u i", + format("#define XXX //q w e r t y u i", getLLVMStyleWithColumns(22))); +} + +TEST_F(FormatTest, DontSplitLineCommentsWithEscapedNewlines) { + EXPECT_EQ("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" + "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" + "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + format("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" + "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" + "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")); + EXPECT_EQ("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" + " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" + " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" + " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" + " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + getLLVMStyleWithColumns(50))); + // FIXME: One day we might want to implement adjustment of leading whitespace + // of the consecutive lines in this kind of comment: + EXPECT_EQ("int\n" + "a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" + " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" + " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + format("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" + " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" + " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + getLLVMStyleWithColumns(49))); +} + +TEST_F(FormatTest, PriorityOfCommentBreaking) { + EXPECT_EQ("if (xxx ==\n" + " yyy && // aaaaaaaaaaaa bbbbbbbbb\n" + " zzz)\n" + " q();", + format("if (xxx == yyy && // aaaaaaaaaaaa bbbbbbbbb\n" + " zzz) q();", + getLLVMStyleWithColumns(40))); + EXPECT_EQ("if (xxxxxxxxxx ==\n" + " yyy && // aaaaaa bbbbbbbb cccc\n" + " zzz)\n" + " q();", + format("if (xxxxxxxxxx == yyy && // aaaaaa bbbbbbbb cccc\n" + " zzz) q();", + getLLVMStyleWithColumns(40))); + EXPECT_EQ("if (xxxxxxxxxx &&\n" + " yyy || // aaaaaa bbbbbbbb cccc\n" + " zzz)\n" + " q();", + format("if (xxxxxxxxxx && yyy || // aaaaaa bbbbbbbb cccc\n" + " zzz) q();", + getLLVMStyleWithColumns(40))); + EXPECT_EQ("fffffffff(&xxx, // aaaaaaaaaaaa\n" + " // bbbbbbbbbbb\n" + " zzz);", + format("fffffffff(&xxx, // aaaaaaaaaaaa bbbbbbbbbbb\n" + " zzz);", + getLLVMStyleWithColumns(40))); +} + +TEST_F(FormatTest, MultiLineCommentsInDefines) { + EXPECT_EQ("#define A(x) /* \\\n" + " a comment \\\n" + " inside */ \\\n" + " f();", + format("#define A(x) /* \\\n" + " a comment \\\n" + " inside */ \\\n" + " f();", + getLLVMStyleWithColumns(17))); + EXPECT_EQ("#define A( \\\n" + " x) /* \\\n" + " a comment \\\n" + " inside */ \\\n" + " f();", + format("#define A( \\\n" + " x) /* \\\n" + " a comment \\\n" + " inside */ \\\n" + " f();", + getLLVMStyleWithColumns(17))); } TEST_F(FormatTest, ParsesCommentsAdjacentToPPDirectives) { @@ -858,7 +1217,8 @@ TEST_F(FormatTest, SplitsLongLinesInComments) { " */", getLLVMStyleWithColumns(20))); EXPECT_EQ("{\n" " if (something) /* This is a\n" - "long comment */\n" + " long\n" + " comment */\n" " ;\n" "}", format("{\n" @@ -866,6 +1226,48 @@ TEST_F(FormatTest, SplitsLongLinesInComments) { " ;\n" "}", getLLVMStyleWithColumns(30))); + + EXPECT_EQ("/* A comment before\n" + " * a macro\n" + " * definition */\n" + "#define a b", + format("/* A comment before a macro definition */\n" + "#define a b", + getLLVMStyleWithColumns(20))); + + EXPECT_EQ("/* some comment\n" + " * a comment\n" + "* that we break\n" + " * another comment\n" + "* we have to break\n" + "* a left comment\n" + " */", + format(" /* some comment\n" + " * a comment that we break\n" + " * another comment we have to break\n" + "* a left comment\n" + " */", + getLLVMStyleWithColumns(20))); + + EXPECT_EQ("/*\n" + "\n" + "\n" + " */\n", + format(" /* \n" + " \n" + " \n" + " */\n")); + + EXPECT_EQ("/* a a */", + format("/* a a */", getLLVMStyleWithColumns(15))); + EXPECT_EQ("/* a a bc */", + format("/* a a bc */", getLLVMStyleWithColumns(15))); + EXPECT_EQ("/* aaa aaa\n" + " * aaaaa */", + format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15))); + EXPECT_EQ("/* aaa aaa\n" + " * aaaaa */", + format("/* aaa aaa aaaaa */", getLLVMStyleWithColumns(15))); } TEST_F(FormatTest, SplitsLongLinesInCommentsInPreprocessor) { @@ -923,11 +1325,11 @@ TEST_F(FormatTest, CommentsInStaticInitializers) { " // comment for bb....\n" " bbbbbbbbbbb, ccccccccccc };"); verifyGoogleFormat( - "static SomeType type = { aaaaaaaaaaa, // comment for aa...\n" - " bbbbbbbbbbb, ccccccccccc };"); - verifyGoogleFormat("static SomeType type = { aaaaaaaaaaa,\n" - " // comment for bb....\n" - " bbbbbbbbbbb, ccccccccccc };"); + "static SomeType type = {aaaaaaaaaaa, // comment for aa...\n" + " bbbbbbbbbbb, ccccccccccc};"); + verifyGoogleFormat("static SomeType type = {aaaaaaaaaaa,\n" + " // comment for bb....\n" + " bbbbbbbbbbb, ccccccccccc};"); verifyFormat("S s = { { a, b, c }, // Group #1\n" " { d, e, f }, // Group #2\n" @@ -953,11 +1355,20 @@ TEST_F(FormatTest, CommentsInStaticInitializers) { " // Comment after empty line\n" " b\n" "}")); - EXPECT_EQ("S s = { a, b };", format("S s = {\n" - " a,\n" - "\n" - " b\n" - "};")); + EXPECT_EQ("S s = {\n" + " /* Some comment */\n" + " a,\n" + "\n" + " /* Comment after empty line */\n" + " b\n" + "}", + format("S s = {\n" + " /* Some comment */\n" + " a,\n" + " \n" + " /* Comment after empty line */\n" + " b\n" + "}")); verifyFormat("const uint8_t aaaaaaaaaaaaaaaaaaaaaa[0] = {\n" " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" " 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // comment\n" @@ -965,12 +1376,150 @@ TEST_F(FormatTest, CommentsInStaticInitializers) { "};"); } +TEST_F(FormatTest, IgnoresIf0Contents) { + EXPECT_EQ("#if 0\n" + "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" + "#endif\n" + "void f() {}", + format("#if 0\n" + "}{)(&*(^%%#%@! fsadj f;ldjs ,:;| <<<>>>][)(][\n" + "#endif\n" + "void f( ) { }")); + EXPECT_EQ("#if false\n" + "void f( ) { }\n" + "#endif\n" + "void g() {}\n", + format("#if false\n" + "void f( ) { }\n" + "#endif\n" + "void g( ) { }\n")); + EXPECT_EQ("enum E {\n" + " One,\n" + " Two,\n" + "#if 0\n" + "Three,\n" + " Four,\n" + "#endif\n" + " Five\n" + "};", + format("enum E {\n" + " One,Two,\n" + "#if 0\n" + "Three,\n" + " Four,\n" + "#endif\n" + " Five};")); + EXPECT_EQ("enum F {\n" + " One,\n" + "#if 1\n" + " Two,\n" + "#if 0\n" + "Three,\n" + " Four,\n" + "#endif\n" + " Five\n" + "#endif\n" + "};", + format("enum F {\n" + "One,\n" + "#if 1\n" + "Two,\n" + "#if 0\n" + "Three,\n" + " Four,\n" + "#endif\n" + "Five\n" + "#endif\n" + "};")); + EXPECT_EQ("enum G {\n" + " One,\n" + "#if 0\n" + "Two,\n" + "#else\n" + " Three,\n" + "#endif\n" + " Four\n" + "};", + format("enum G {\n" + "One,\n" + "#if 0\n" + "Two,\n" + "#else\n" + "Three,\n" + "#endif\n" + "Four\n" + "};")); + EXPECT_EQ("enum H {\n" + " One,\n" + "#if 0\n" + "#ifdef Q\n" + "Two,\n" + "#else\n" + "Three,\n" + "#endif\n" + "#endif\n" + " Four\n" + "};", + format("enum H {\n" + "One,\n" + "#if 0\n" + "#ifdef Q\n" + "Two,\n" + "#else\n" + "Three,\n" + "#endif\n" + "#endif\n" + "Four\n" + "};")); + EXPECT_EQ("enum I {\n" + " One,\n" + "#if /* test */ 0 || 1\n" + "Two,\n" + "Three,\n" + "#endif\n" + " Four\n" + "};", + format("enum I {\n" + "One,\n" + "#if /* test */ 0 || 1\n" + "Two,\n" + "Three,\n" + "#endif\n" + "Four\n" + "};")); + EXPECT_EQ("enum J {\n" + " One,\n" + "#if 0\n" + "#if 0\n" + "Two,\n" + "#else\n" + "Three,\n" + "#endif\n" + "Four,\n" + "#endif\n" + " Five\n" + "};", + format("enum J {\n" + "One,\n" + "#if 0\n" + "#if 0\n" + "Two,\n" + "#else\n" + "Three,\n" + "#endif\n" + "Four,\n" + "#endif\n" + "Five\n" + "};")); + +} + //===----------------------------------------------------------------------===// // Tests for classes, namespaces, etc. //===----------------------------------------------------------------------===// TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) { - verifyFormat("class A {\n};"); + verifyFormat("class A {};"); } TEST_F(FormatTest, UnderstandsAccessSpecifiers) { @@ -1009,34 +1558,49 @@ TEST_F(FormatTest, SeparatesLogicalBlocks) { "protected:\n" "int h;\n" "};")); + EXPECT_EQ("class A {\n" + "protected:\n" + "public:\n" + " void f();\n" + "};", + format("class A {\n" + "protected:\n" + "\n" + "public:\n" + "\n" + " void f();\n" + "};")); } TEST_F(FormatTest, FormatsClasses) { - verifyFormat("class A : public B {\n};"); - verifyFormat("class A : public ::B {\n};"); + verifyFormat("class A : public B {};"); + verifyFormat("class A : public ::B {};"); verifyFormat( "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" - " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {\n" - "};\n"); + " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" - " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {\n" - "};\n"); + " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); verifyFormat( - "class A : public B, public C, public D, public E, public F, public G {\n" - "};"); + "class A : public B, public C, public D, public E, public F {};"); verifyFormat("class AAAAAAAAAAAA : public B,\n" " public C,\n" " public D,\n" " public E,\n" " public F,\n" - " public G {\n" - "};"); + " public G {};"); verifyFormat("class\n" - " ReallyReallyLongClassName {\n};", + " ReallyReallyLongClassName {\n" + " int i;\n" + "};", getLLVMStyleWithColumns(32)); + verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" + " aaaaaaaaaaaaaaaa> {};"); + verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n" + " : public aaaaaaaaaaaaaaaaaaa {};"); } TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) { @@ -1054,14 +1618,82 @@ TEST_F(FormatTest, FormatsEnum) { " Four = (Zero && (One ^ Two)) | (One << Two),\n" " Five = (One, Two, Three, Four, 5)\n" "};"); - verifyFormat("enum Enum {\n" - "};"); + verifyGoogleFormat("enum {\n" + " Zero,\n" + " One = 1,\n" + " Two = One + 1,\n" + " Three = (One + Two),\n" + " Four = (Zero && (One ^ Two)) | (One << Two),\n" + " Five = (One, Two, Three, Four, 5)\n" + "};"); + verifyFormat("enum Enum {};"); + verifyFormat("enum {};"); + verifyFormat("enum X E {} d;"); + verifyFormat("enum __attribute__((...)) E {} d;"); + verifyFormat("enum __declspec__((...)) E {} d;"); + verifyFormat("enum X f() {\n a();\n return 42;\n}"); verifyFormat("enum {\n" + " Bar = Foo::value\n" + "};"); +} + +TEST_F(FormatTest, FormatsEnumsWithErrors) { + verifyFormat("enum Type {\n" + " One = 0;\n" // These semicolons should be commas. + " Two = 1;\n" + "};"); + verifyFormat("namespace n {\n" + "enum Type {\n" + " One,\n" + " Two,\n" // missing }; + " int i;\n" + "}\n" + "void g() {}"); +} + +TEST_F(FormatTest, FormatsEnumStruct) { + verifyFormat("enum struct {\n" + " Zero,\n" + " One = 1,\n" + " Two = One + 1,\n" + " Three = (One + Two),\n" + " Four = (Zero && (One ^ Two)) | (One << Two),\n" + " Five = (One, Two, Three, Four, 5)\n" + "};"); + verifyFormat("enum struct Enum {};"); + verifyFormat("enum struct {};"); + verifyFormat("enum struct X E {} d;"); + verifyFormat("enum struct __attribute__((...)) E {} d;"); + verifyFormat("enum struct __declspec__((...)) E {} d;"); + verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); +} + +TEST_F(FormatTest, FormatsEnumClass) { + verifyFormat("enum class {\n" + " Zero,\n" + " One = 1,\n" + " Two = One + 1,\n" + " Three = (One + Two),\n" + " Four = (Zero && (One ^ Two)) | (One << Two),\n" + " Five = (One, Two, Three, Four, 5)\n" + "};"); + verifyFormat("enum class Enum {};"); + verifyFormat("enum class {};"); + verifyFormat("enum class X E {} d;"); + verifyFormat("enum class __attribute__((...)) E {} d;"); + verifyFormat("enum class __declspec__((...)) E {} d;"); + verifyFormat("enum class X f() {\n a();\n return 42;\n}"); +} + +TEST_F(FormatTest, FormatsEnumTypes) { + verifyFormat("enum X : int {\n" + " A,\n" + " B\n" + "};"); + verifyFormat("enum X : std::uint32_t {\n" + " A,\n" + " B\n" "};"); - verifyFormat("enum X E {\n} d;"); - verifyFormat("enum __attribute__((...)) E {\n} d;"); - verifyFormat("enum __declspec__((...)) E {\n} d;"); - verifyFormat("enum X f() {\n a();\n return 42;\n}"); } TEST_F(FormatTest, FormatsBitfields) { @@ -1069,33 +1701,83 @@ TEST_F(FormatTest, FormatsBitfields) { " unsigned sClass : 8;\n" " unsigned ValueKind : 2;\n" "};"); + verifyFormat("struct A {\n" + " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n" + " bbbbbbbbbbbbbbbbbbbbbbbbb;\n" + "};"); } TEST_F(FormatTest, FormatsNamespaces) { verifyFormat("namespace some_namespace {\n" - "class A {\n};\n" + "class A {};\n" "void f() { f(); }\n" "}"); verifyFormat("namespace {\n" - "class A {\n};\n" + "class A {};\n" "void f() { f(); }\n" "}"); verifyFormat("inline namespace X {\n" - "class A {\n};\n" + "class A {};\n" "void f() { f(); }\n" "}"); verifyFormat("using namespace some_namespace;\n" - "class A {\n};\n" + "class A {};\n" "void f() { f(); }"); // This code is more common than we thought; if we // layout this correctly the semicolon will go into // its own line, which is undesireable. - verifyFormat("namespace {\n};"); + verifyFormat("namespace {};"); verifyFormat("namespace {\n" - "class A {\n" - "};\n" + "class A {};\n" "};"); + + verifyFormat("namespace {\n" + "int SomeVariable = 0; // comment\n" + "} // namespace"); + EXPECT_EQ("#ifndef HEADER_GUARD\n" + "#define HEADER_GUARD\n" + "namespace my_namespace {\n" + "int i;\n" + "} // my_namespace\n" + "#endif // HEADER_GUARD", + format("#ifndef HEADER_GUARD\n" + " #define HEADER_GUARD\n" + " namespace my_namespace {\n" + "int i;\n" + "} // my_namespace\n" + "#endif // HEADER_GUARD")); + + FormatStyle Style = getLLVMStyle(); + Style.NamespaceIndentation = FormatStyle::NI_All; + EXPECT_EQ("namespace out {\n" + " int i;\n" + " namespace in {\n" + " int i;\n" + " } // namespace\n" + "} // namespace", + format("namespace out {\n" + "int i;\n" + "namespace in {\n" + "int i;\n" + "} // namespace\n" + "} // namespace", + Style)); + + Style.NamespaceIndentation = FormatStyle::NI_Inner; + EXPECT_EQ("namespace out {\n" + "int i;\n" + "namespace in {\n" + " int i;\n" + "} // namespace\n" + "} // namespace", + format("namespace out {\n" + "int i;\n" + "namespace in {\n" + "int i;\n" + "} // namespace\n" + "} // namespace", + Style)); } TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); } @@ -1106,7 +1788,7 @@ TEST_F(FormatTest, FormatsInlineASM) { "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" " \"cpuid\\n\\t\"\n" " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" - " : \"=a\" (*rEAX), \"=S\" (*rEBX), \"=c\" (*rECX), \"=d\" (*rEDX)\n" + " : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n" " : \"a\"(value));"); } @@ -1152,22 +1834,46 @@ TEST_F(FormatTest, FormatObjCTryCatch) { TEST_F(FormatTest, StaticInitializers) { verifyFormat("static SomeClass SC = { 1, 'a' };"); - // FIXME: Format like enums if the static initializer does not fit on a line. verifyFormat( "static SomeClass WithALoooooooooooooooooooongName = {\n" " 100000000, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" "};"); - verifyFormat( - "static SomeClass = { a, b, c, d, e, f, g, h, i, j,\n" - " looooooooooooooooooooooooooooooooooongname,\n" - " looooooooooooooooooooooooooooooong };"); - // Allow bin-packing in static initializers as this would often lead to - // terrible results, e.g.: - verifyGoogleFormat( - "static SomeClass = { a, b, c, d, e, f, g, h, i, j,\n" - " looooooooooooooooooooooooooooooooooongname,\n" - " looooooooooooooooooooooooooooooong };"); + // Here, everything other than the "}" would fit on a line. + verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" + " 100000000000000000000000\n" + "};"); + EXPECT_EQ("S s = { a, b };", format("S s = {\n" + " a,\n" + "\n" + " b\n" + "};")); + + // FIXME: This would fit into the column limit if we'd fit "{ {" on the first + // line. However, the formatting looks a bit off and this probably doesn't + // happen often in practice. + verifyFormat("static int Variable[1] = {\n" + " { 1000000000000000000000000000000000000 }\n" + "};", + getLLVMStyleWithColumns(40)); +} + +TEST_F(FormatTest, DesignatedInitializers) { + verifyFormat("const struct A a = { .a = 1, .b = 2 };"); + verifyFormat("const struct A a = { .aaaaaaaaaa = 1,\n" + " .bbbbbbbbbb = 2,\n" + " .cccccccccc = 3,\n" + " .dddddddddd = 4,\n" + " .eeeeeeeeee = 5 };"); + verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" + " .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n" + " .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n" + " .ccccccccccccccccccccccccccc = 3,\n" + " .ddddddddddddddddddddddddddd = 4,\n" + " .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5\n" + "};"); + + verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); } TEST_F(FormatTest, NestedStaticInitializers) { @@ -1180,11 +1886,10 @@ TEST_F(FormatTest, NestedStaticInitializers) { " { kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL },\n" " { kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL }\n" "};"); - verifyGoogleFormat("somes Status::global_reps[3] = {\n" - " { kGlobalRef, OK_CODE, NULL, NULL, NULL },\n" - " { kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL },\n" - " { kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL }\n" - "};"); + verifyGoogleFormat("SomeType Status::global_reps[3] = {\n" + " {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n" + " {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n" + " {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};"); verifyFormat( "CGRect cg_rect = { { rect.fLeft, rect.fTop },\n" " { rect.fRight - rect.fLeft, rect.fBottom - rect.fTop" @@ -1202,15 +1907,21 @@ TEST_F(FormatTest, NestedStaticInitializers) { " 222222222222222222222222222222,\n" " 333333333333333333333333333333 } },\n" " { { 1, 2, 3 } }, { { 1, 2, 3 } } };"); + verifyGoogleFormat( + "SomeArrayOfSomeType a = {\n" + " {{1, 2, 3}}, {{1, 2, 3}},\n" + " {{111111111111111111111111111111, 222222222222222222222222222222,\n" + " 333333333333333333333333333333}},\n" + " {{1, 2, 3}}, {{1, 2, 3}}};"); - // FIXME: We might at some point want to handle this similar to parameter - // lists, where we have an option to put each on a single line. verifyFormat( "struct {\n" " unsigned bit;\n" " const char *const name;\n" - "} kBitsToOs[] = { { kOsMac, \"Mac\" }, { kOsWin, \"Windows\" },\n" - " { kOsLinux, \"Linux\" }, { kOsCrOS, \"Chrome OS\" } };"); + "} kBitsToOs[] = { { kOsMac, \"Mac\" },\n" + " { kOsWin, \"Windows\" },\n" + " { kOsLinux, \"Linux\" },\n" + " { kOsCrOS, \"Chrome OS\" } };"); } TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { @@ -1220,14 +1931,28 @@ TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { } TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { - verifyFormat( - "virtual void write(ELFWriter *writerrr,\n" - " OwningPtr &buffer) = 0;"); + verifyFormat("virtual void write(ELFWriter *writerrr,\n" + " OwningPtr &buffer) = 0;"); } -TEST_F(FormatTest, LayoutUnknownPPDirective) { - EXPECT_EQ("#123 \"A string literal\"", +TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { + verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", + getLLVMStyleWithColumns(40)); + verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", + getLLVMStyleWithColumns(40)); + EXPECT_EQ("#define Q \\\n" + " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" + " \"aaaaaaaa.cpp\"", + format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", + getLLVMStyleWithColumns(40))); +} + +TEST_F(FormatTest, UnderstandsLinePPDirective) { + EXPECT_EQ("# 123 \"A string literal\"", format(" # 123 \"A string literal\"")); +} + +TEST_F(FormatTest, LayoutUnknownPPDirective) { EXPECT_EQ("#;", format("#;")); verifyFormat("#\n;\n;\n;"); } @@ -1245,12 +1970,22 @@ TEST_F(FormatTest, EndOfFileEndsPPDirective) { EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B")); } +TEST_F(FormatTest, DoesntRemoveUnknownTokens) { + verifyFormat("#define A \\x20"); + verifyFormat("#define A \\ x20"); + EXPECT_EQ("#define A \\ x20", format("#define A \\ x20")); + verifyFormat("#define A ''"); + verifyFormat("#define A ''qqq"); + verifyFormat("#define A `qqq"); + verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); +} + TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) { verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13)); verifyFormat("#define A( \\\n BB)", getLLVMStyleWithColumns(12)); verifyFormat("#define A( \\\n A, B)", getLLVMStyleWithColumns(12)); // FIXME: We never break before the macro name. - verifyFormat("#define AA(\\\n B)", getLLVMStyleWithColumns(12)); + verifyFormat("#define AA( \\\n B)", getLLVMStyleWithColumns(12)); verifyFormat("#define A A\n#define A A"); verifyFormat("#define A(X) A\n#define A A"); @@ -1289,9 +2024,29 @@ TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } -TEST_F(FormatTest, LayoutSingleUnwrappedLineInMacro) { - EXPECT_EQ("# define A\\\n b;", - format("# define A b;", 11, 2, getLLVMStyleWithColumns(11))); +TEST_F(FormatTest, AlwaysFormatsEntireMacroDefinitions) { + EXPECT_EQ("int i;\n" + "#define A \\\n" + " int i; \\\n" + " int j\n" + "int k;", + format("int i;\n" + "#define A \\\n" + " int i ; \\\n" + " int j\n" + "int k;", + 8, 0, getGoogleStyle())); // 8: position of "#define". + EXPECT_EQ("int i;\n" + "#define A \\\n" + " int i; \\\n" + " int j\n" + "int k;", + format("int i;\n" + "#define A \\\n" + " int i ; \\\n" + " int j\n" + "int k;", + 45, 0, getGoogleStyle())); // 45: position of "j". } TEST_F(FormatTest, MacroDefinitionInsideStatement) { @@ -1302,10 +2057,11 @@ TEST_F(FormatTest, MacroDefinitionInsideStatement) { } TEST_F(FormatTest, HashInMacroDefinition) { + EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle())); verifyFormat("#define A \\\n b #c;", getLLVMStyleWithColumns(11)); - verifyFormat("#define A \\\n" - " { \\\n" - " f(#c);\\\n" + verifyFormat("#define A \\\n" + " { \\\n" + " f(#c); \\\n" " }", getLLVMStyleWithColumns(11)); @@ -1351,24 +2107,59 @@ TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { verifyFormat("#define A :"); - - // FIXME: Improve formatting of case labels in macros. verifyFormat("#define SOMECASES \\\n" " case 1: \\\n" " case 2\n", getLLVMStyleWithColumns(20)); - verifyFormat("#define A template "); verifyFormat("#define STR(x) #x\n" "f(STR(this_is_a_string_literal{));"); + verifyFormat("#pragma omp threadprivate( \\\n" + " y)), // expected-warning", + getLLVMStyleWithColumns(28)); +} + +TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { + verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. + EXPECT_EQ("class A : public QObject {\n" + " Q_OBJECT\n" + "\n" + " A() {}\n" + "};", + format("class A : public QObject {\n" + " Q_OBJECT\n" + "\n" + " A() {\n}\n" + "} ;")); + EXPECT_EQ("SOME_MACRO\n" + "namespace {\n" + "void f();\n" + "}", + format("SOME_MACRO\n" + " namespace {\n" + "void f( );\n" + "}")); + // Only if the identifier contains at least 5 characters. + EXPECT_EQ("HTTP f();", + format("HTTP\nf();")); + EXPECT_EQ("MACRO\nf();", + format("MACRO\nf();")); + // Only if everything is upper case. + EXPECT_EQ("class A : public QObject {\n" + " Q_Object A() {}\n" + "};", + format("class A : public QObject {\n" + " Q_Object\n" + "\n" + " A() {\n}\n" + "} ;")); } TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" - "class X {\n" - "};\n" + "class X {};\n" "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" "int *createScopDetectionPass() { return 0; }", format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" @@ -1389,6 +2180,8 @@ TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { " IPC_MESSAGE_HANDLER(xxx, qqq)\n" " IPC_END_MESSAGE_MAP()\n" "}")); + + // These must not be recognized as macros. EXPECT_EQ("int q() {\n" " f(x);\n" " f(x) {}\n" @@ -1472,6 +2265,13 @@ TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { "};")); } +TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { + verifyFormat("#define A \\\n" + " f({ \\\n" + " g(); \\\n" + " });", getLLVMStyleWithColumns(11)); +} + TEST_F(FormatTest, IndentPreprocessorDirectivesAtZero) { EXPECT_EQ("{\n {\n#define A\n }\n}", format("{{\n#define A\n}}")); } @@ -1487,10 +2287,15 @@ TEST_F(FormatTest, FormatUnbalancedStructuralElements) { format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); } -TEST_F(FormatTest, EscapedNewlineAtStartOfTokenInMacroDefinition) { +TEST_F(FormatTest, EscapedNewlineAtStartOfToken) { EXPECT_EQ( "#define A \\\n int i; \\\n int j;", format("#define A \\\nint i;\\\n int j;", getLLVMStyleWithColumns(11))); + EXPECT_EQ("template f();", format("\\\ntemplate f();")); +} + +TEST_F(FormatTest, NoEscapedNewlineHandlingInBlockComments) { + EXPECT_EQ("/* \\ \\ \\\n*/", format("\\\n/* \\ \\ \\\n*/")); } TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { @@ -1521,7 +2326,7 @@ TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { EXPECT_EQ("int\n" "#define A\n" " a;", - format("int\n#define A\na;")); + format("int\n#define A\na;", getGoogleStyle())); verifyFormat("functionCallTo(\n" " someOtherFunction(\n" " withSomeParameters, whichInSequence,\n" @@ -1532,13 +2337,106 @@ TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { " andMoreParameters),\n" " trailing);", getLLVMStyleWithColumns(69)); + verifyFormat("Foo::Foo()\n" + "#ifdef BAR\n" + " : baz(0)\n" + "#endif\n" + "{\n" + "}"); + verifyFormat("void f() {\n" + " if (true)\n" + "#ifdef A\n" + " f(42);\n" + " x();\n" + "#else\n" + " g();\n" + " x();\n" + "#endif\n" + "}"); + verifyFormat("void f(param1, param2,\n" + " param3,\n" + "#ifdef A\n" + " param4(param5,\n" + "#ifdef A1\n" + " param6,\n" + "#ifdef A2\n" + " param7),\n" + "#else\n" + " param8),\n" + " param9,\n" + "#endif\n" + " param10,\n" + "#endif\n" + " param11)\n" + "#else\n" + " param12)\n" + "#endif\n" + "{\n" + " x();\n" + "}", + getLLVMStyleWithColumns(28)); + verifyFormat("#if 1\n" + "int i;"); + verifyFormat( + "#if 1\n" + "#endif\n" + "#if 1\n" + "#else\n" + "#endif\n"); + verifyFormat("DEBUG({\n" + " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" + "});\n" + "#if a\n" + "#else\n" + "#endif"); +} + +TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { + FormatStyle SingleLine = getLLVMStyle(); + SingleLine.AllowShortIfStatementsOnASingleLine = true; + verifyFormat( + "#if 0\n" + "#elif 1\n" + "#endif\n" + "void foo() {\n" + " if (test) foo2();\n" + "}", + SingleLine); } TEST_F(FormatTest, LayoutBlockInsideParens) { + EXPECT_EQ("functionCall({ int i; });", format(" functionCall ( {int i;} );")); + EXPECT_EQ("functionCall({\n" + " int i;\n" + " int j;\n" + "});", + format(" functionCall ( {int i;int j;} );")); EXPECT_EQ("functionCall({\n" + " int i;\n" + " int j;\n" + " },\n" + " aaaa, bbbb, cccc);", + format(" functionCall ( {int i;int j;}, aaaa, bbbb, cccc);")); + EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });", + format(" functionCall (aaaa, bbbb, {int i;});")); + EXPECT_EQ("functionCall(aaaa, bbbb, {\n" " int i;\n" + " int j;\n" "});", - format(" functionCall ( {int i;} );")); + format(" functionCall (aaaa, bbbb, {int i;int j;});")); + EXPECT_EQ("functionCall(aaaa, bbbb, { int i; });", + format(" functionCall (aaaa, bbbb, {int i;});")); + verifyFormat( + "Aaa({\n" + " int i; // break\n" + " },\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" + " ccccccccccccccccc));"); + verifyFormat("DEBUG({\n" + " if (a)\n" + " f();\n" + "});"); } TEST_F(FormatTest, LayoutBlockInsideStatement) { @@ -1556,15 +2454,87 @@ TEST_F(FormatTest, LayoutNestedBlocks) { " for (int i = 0; i < 10; ++i)\n" " return;\n" "}"); + verifyFormat("call(parameter, {\n" + " something();\n" + " // Comment using all columns.\n" + " somethingelse();\n" + "});", + getLLVMStyleWithColumns(40)); + EXPECT_EQ("call(parameter, {\n" + " something();\n" + " // Comment too\n" + " // looooooooooong.\n" + " somethingElse();\n" + "});", + format("call(parameter, {\n" + " something();\n" + " // Comment too looooooooooong.\n" + " somethingElse();\n" + "});", + getLLVMStyleWithColumns(29))); + EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });")); + EXPECT_EQ("DEBUG({ // comment\n" + " int i;\n" + "});", + format("DEBUG({ // comment\n" + "int i;\n" + "});")); + EXPECT_EQ("DEBUG({\n" + " int i;\n" + "\n" + " // comment\n" + " int j;\n" + "});", + format("DEBUG({\n" + " int i;\n" + "\n" + " // comment\n" + " int j;\n" + "});")); + + verifyFormat("DEBUG({\n" + " if (a)\n" + " return;\n" + "});"); + verifyGoogleFormat("DEBUG({\n" + " if (a) return;\n" + "});"); + FormatStyle Style = getGoogleStyle(); + Style.ColumnLimit = 45; + verifyFormat("Debug(aaaaa, {\n" + " if (aaaaaaaaaaaaaaaaaaaaaaaa)\n" + " return;\n" + " },\n" + " a);", Style); + + EXPECT_EQ("Debug({\n" + " if (aaaaaaaaaaaaaaaaaaaaaaaa)\n" + " return;\n" + " },\n" + " a);", + format("Debug({\n" + " if (aaaaaaaaaaaaaaaaaaaaaaaa)\n" + " return;\n" + " },\n" + " a);", + 50, 1, getLLVMStyle())); +} + +TEST_F(FormatTest, IndividualStatementsOfNestedBlocks) { + EXPECT_EQ("DEBUG({\n" + " int i;\n" + " int j;\n" + "});", + format("DEBUG( {\n" + " int i;\n" + " int j;\n" + "} ) ;", + 40, 1, getLLVMStyle())); } TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { EXPECT_EQ("{}", format("{}")); - - // Negative test for enum. - verifyFormat("enum E {\n};"); - - // Note that when there's a missing ';', we still join... + verifyFormat("enum E {};"); verifyFormat("enum E {}"); } @@ -1572,30 +2542,23 @@ TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { // Line break tests. //===----------------------------------------------------------------------===// -TEST_F(FormatTest, FormatsFunctionDefinition) { - verifyFormat("void f(int a, int b, int c, int d, int e, int f, int g," - " int h, int j, int f,\n" - " int c, int ddddddddddddd) {}"); -} - -TEST_F(FormatTest, FormatsAwesomeMethodCall) { - verifyFormat( - "SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" - " parameter, parameter, parameter)),\n" - " SecondLongCall(parameter));"); -} - TEST_F(FormatTest, PreventConfusingIndents) { + verifyFormat( + "void f() {\n" + " SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n" + " parameter, parameter, parameter)),\n" + " SecondLongCall(parameter));\n" + "}"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( - "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[\n" - " aaaaaaaaaaaaaaaaaaaaaaaa[\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa],\n" - " aaaaaaaaaaaaaaaaaaaaaaaa];"); + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " [aaaaaaaaaaaaaaaaaaaaaaaa\n" + " [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n" + " [aaaaaaaaaaaaaaaaaaaaaaaa]];"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" " aaaaaaaaaaaaaaaaaaaaaaaa<\n" @@ -1606,17 +2569,86 @@ TEST_F(FormatTest, PreventConfusingIndents) { " ddd);"); } -TEST_F(FormatTest, ExpressionIndentation) { - verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" - " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" - " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" - " ccccccccccccccccccccccccccccccccccccccccc;"); - verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" +TEST_F(FormatTest, LineBreakingInBinaryExpressions) { + verifyFormat( + "bool aaaaaaa =\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n" + " bbbbbbbb();"); + verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" + " ccccccccc == ddddddddddd;"); + + verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" + " aaaaaa) &&\n" + " bbbbbb && cccccc;"); + verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" + " aaaaaa) >>\n" + " bbbbbb;"); + verifyFormat("Whitespaces.addUntouchableComment(\n" + " SourceMgr.getSpellingColumnNumber(\n" + " TheLine.Last->FormatTok.Tok.getLocation()) -\n" + " 1);"); + + verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" + " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" + " cccccc) {\n}"); + + // If the LHS of a comparison is not a binary expression itself, the + // additional linebreak confuses many people. + verifyFormat( + "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n" + "}"); + verifyFormat( + "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" + "}"); + verifyFormat( + "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" + "}"); + // Even explicit parentheses stress the precedence enough to make the + // additional break unnecessary. + verifyFormat( + "if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n" + "}"); + // This cases is borderline, but with the indentation it is still readable. + verifyFormat( + "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" + "}", + getLLVMStyleWithColumns(75)); + + // If the LHS is a binary expression, we should still use the additional break + // as otherwise the formatting hides the operator precedence. + verifyFormat( + "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" + " 5) {\n" + "}"); + + FormatStyle OnePerLine = getLLVMStyle(); + OnePerLine.BinPackParameters = false; + verifyFormat( + "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", + OnePerLine); +} + +TEST_F(FormatTest, ExpressionIndentation) { + verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" + " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n" + " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n" + " ccccccccccccccccccccccccccccccccccccccccc;"); + verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); @@ -1628,6 +2660,66 @@ TEST_F(FormatTest, ExpressionIndentation) { " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); + verifyFormat("if () {\n" + "} else if (aaaaa && bbbbb > // break\n" + " ccccc) {\n" + "}"); + + // Presence of a trailing comment used to change indentation of b. + verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n" + " b;\n" + "return aaaaaaaaaaaaaaaaaaa +\n" + " b; //", + getLLVMStyleWithColumns(30)); +} + +TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) { + // Not sure what the best system is here. Like this, the LHS can be found + // immediately above an operator (everything with the same or a higher + // indent). The RHS is aligned right of the operator and so compasses + // everything until something with the same indent as the operator is found. + // FIXME: Is this a good system? + FormatStyle Style = getLLVMStyle(); + Style.BreakBeforeBinaryOperators = true; + verifyFormat( + "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " > ccccccccccccccccccccccccccccccccccccccccc;", + Style); + verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", + Style); + verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", + Style); + verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}", + Style); + verifyFormat("if () {\n" + "} else if (aaaaa && bbbbb // break\n" + " > ccccc) {\n" + "}", + Style); + + // Forced by comments. + verifyFormat( + "unsigned ContentSize =\n" + " sizeof(int16_t) // DWARF ARange version number\n" + " + sizeof(int32_t) // Offset of CU in the .debug_info section\n" + " + sizeof(int8_t) // Pointer Size (in bytes)\n" + " + sizeof(int8_t); // Segment Size (in bytes)"); } TEST_F(FormatTest, ConstructorInitializers) { @@ -1667,6 +2759,13 @@ TEST_F(FormatTest, ConstructorInitializers) { verifyFormat("Constructor(int Parameter = 0)\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}"); + verifyFormat("Constructor()\n" + " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" + "}", + getLLVMStyleWithColumns(60)); + verifyFormat("Constructor()\n" + " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}"); // Here a line could be saved by splitting the second initializer onto two // lines, but that is not desireable. @@ -1723,6 +2822,53 @@ TEST_F(FormatTest, MemoizationTests) { " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" " aaaaa())))))))))))))))))))))))))))))))))))))));", getLLVMStyleWithColumns(65)); + verifyFormat( + "aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa(\n" + " aaaaa,\n" + " aaaaa))))))))))));", + getLLVMStyleWithColumns(65)); + verifyFormat( + "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a),\n" + " a)", + getLLVMStyleWithColumns(65)); // This test takes VERY long when memoization is broken. FormatStyle OnePerLine = getLLVMStyle(); @@ -1753,22 +2899,29 @@ TEST_F(FormatTest, BreaksFunctionDeclarations) { // 1) break amongst arguments. verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n" " Cccccccccccccc cccccccccccccc);"); + verifyFormat( + "template \n" + "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n" + " TemplateIt *stop) {}"); // 2) break after return type. verifyFormat( - "Aaaaaaaaaaaaaaaaaaaaaaaa\n" - " bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);"); + "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", + getGoogleStyle()); // 3) break after (. verifyFormat( "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" - " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);"); + " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", + getGoogleStyle()); // 4) break before after nested name specifiers. verifyFormat( "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " SomeClasssssssssssssssssssssssssssssssssssssss::\n" - " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);"); + " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", + getGoogleStyle()); // However, there are exceptions, if a sufficient amount of lines can be // saved. @@ -1780,10 +2933,11 @@ TEST_F(FormatTest, BreaksFunctionDeclarations) { " Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc);"); verifyFormat( - "Aaaaaaaaaaaaaaaaaa\n" + "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" - " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); + " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", + getGoogleStyle()); verifyFormat( "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc,\n" @@ -1803,6 +2957,85 @@ TEST_F(FormatTest, BreaksFunctionDeclarations) { " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " bbbb bbbb);"); + + // Treat overloaded operators like other functions. + verifyFormat("SomeLoooooooooooooooooooooooooogType\n" + "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); + verifyFormat("SomeLoooooooooooooooooooooooooogType\n" + "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); + verifyGoogleFormat( + "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" + " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); +} + +TEST_F(FormatTest, TrailingReturnType) { + verifyFormat("auto foo() -> int;\n"); + verifyFormat("struct S {\n" + " auto bar() const -> int;\n" + "};"); + verifyFormat("template \n" + "auto load_img(const std::string &filename)\n" + " -> alias::tensor {}"); + + // Not trailing return types. + verifyFormat("void f() { auto a = b->c(); }"); +} + +TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { + // Avoid breaking before trailing 'const' or other trailing annotations, if + // they are not function-like. + FormatStyle Style = getGoogleStyle(); + Style.ColumnLimit = 47; + verifyFormat("void\n" + "someLongFunction(int someLongParameter) const {\n}", + getLLVMStyleWithColumns(47)); + verifyFormat("LoooooongReturnType\n" + "someLoooooooongFunction() const {}", + getLLVMStyleWithColumns(47)); + verifyFormat("LoooooongReturnType someLoooooooongFunction()\n" + " const {}", + Style); + verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" + " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;"); + verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" + " aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;"); + verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n" + " aaaaa aaaaaaaaaaaaaaaaaaaa) override final;"); + + // Unless this would lead to the first parameter being broken. + verifyFormat("void someLongFunction(int someLongParameter)\n" + " const {}", + getLLVMStyleWithColumns(46)); + verifyFormat("void someLongFunction(int someLongParameter)\n" + " const {}", + Style); + verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n" + " aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" + " LONG_AND_UGLY_ANNOTATION;"); + + // Breaking before function-like trailing annotations is fine to keep them + // close to their arguments. + verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" + " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); + verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" + " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); + verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" + " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); + + verifyFormat( + "void aaaaaaaaaaaaaaaaaa()\n" + " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaaaaaaaaaaa));"); + verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " __attribute__((unused));"); + verifyFormat( + "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " GUARDED_BY(aaaaaaaaaaaa);", + getGoogleStyle()); + verifyFormat( + "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " GUARDED_BY(aaaaaaaaaaaa);", + getGoogleStyle()); } TEST_F(FormatTest, BreaksDesireably) { @@ -1842,9 +3075,15 @@ TEST_F(FormatTest, BreaksDesireably) { "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); verifyFormat( - "aaaaaaaaaaaaaaaaa(\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); + "aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); + + // Indent consistently indenpendent of call expression. + verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n" + " dddddddddddddddddddddddddddddd));\n" + "aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" + " dddddddddddddddddddddddddddddd));"); // This test case breaks on an incorrect memoization, i.e. an optimization not // taking into account the StopAt value. @@ -1859,6 +3098,20 @@ TEST_F(FormatTest, BreaksDesireably) { " Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n" " Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n" " }\n }\n}"); + + // Break on an outer level if there was a break on an inner level. + EXPECT_EQ("f(g(h(a, // comment\n" + " b, c),\n" + " d, e),\n" + " x, y);", + format("f(g(h(a, // comment\n" + " b, c), d, e), x, y);")); + + // Prefer breaking similar line breaks. + verifyFormat( + "const int kTrackingOptions = NSTrackingMouseMoved |\n" + " NSTrackingMouseEnteredAndExited |\n" + " NSTrackingActiveAlways;"); } TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { @@ -1882,8 +3135,10 @@ TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" " .aaaaaaaaaaaaaaaaaa();", NoBinPacking); - verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" - " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);", + verifyFormat("void f() {\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" + "}", NoBinPacking); verifyFormat( @@ -1916,48 +3171,104 @@ TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { " .aaaaaaa();\n" "}", NoBinPacking); + verifyFormat( + "template \n" + "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}", + NoBinPacking); +} + +TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { + FormatStyle Style = getLLVMStyleWithColumns(15); + Style.ExperimentalAutoDetectBinPacking = true; + EXPECT_EQ("aaa(aaaa,\n" + " aaaa,\n" + " aaaa);\n" + "aaa(aaaa,\n" + " aaaa,\n" + " aaaa);", + format("aaa(aaaa,\n" // one-per-line + " aaaa,\n" + " aaaa );\n" + "aaa(aaaa, aaaa, aaaa);", // inconclusive + Style)); + EXPECT_EQ("aaa(aaaa, aaaa,\n" + " aaaa);\n" + "aaa(aaaa, aaaa,\n" + " aaaa);", + format("aaa(aaaa, aaaa,\n" // bin-packed + " aaaa );\n" + "aaa(aaaa, aaaa, aaaa);", // inconclusive + Style)); } TEST_F(FormatTest, FormatsBuilderPattern) { verifyFormat( "return llvm::StringSwitch(name)\n" " .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n" - " .StartsWith(\".eh_frame\", ORDER_EH_FRAME).StartsWith(\".init\", ORDER_INIT)\n" - " .StartsWith(\".fini\", ORDER_FINI).StartsWith(\".hash\", ORDER_HASH)\n" + " .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n" + " .StartsWith(\".init\", ORDER_INIT)\n" + " .StartsWith(\".fini\", ORDER_FINI)\n" + " .StartsWith(\".hash\", ORDER_HASH)\n" " .Default(ORDER_TEXT);\n"); - + verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); verifyFormat( - "aaaaaaa->aaaaaaa\n" - " ->aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" + "aaaaaaa->aaaaaaa->aaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); verifyFormat( "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" " aaaaaaaaaaaaaa);"); verifyFormat( - "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa = aaaaaa->aaaaaaaaaaaa()\n" - " ->aaaaaaaaaaaaaaaa(\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" - " ->aaaaaaaaaaaaaaaaa();"); -} + "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n" + " aaaaaa->aaaaaaaaaaaa()\n" + " ->aaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" + " ->aaaaaaaaaaaaaaaaa();"); + verifyGoogleFormat( + "void f() {\n" + " someo->Add((new util::filetools::Handler(dir))\n" + " ->OnEvent1(NewPermanentCallback(\n" + " this, &HandlerHolderClass::EventHandlerCBA))\n" + " ->OnEvent2(NewPermanentCallback(\n" + " this, &HandlerHolderClass::EventHandlerCBB))\n" + " ->OnEvent3(NewPermanentCallback(\n" + " this, &HandlerHolderClass::EventHandlerCBC))\n" + " ->OnEvent5(NewPermanentCallback(\n" + " this, &HandlerHolderClass::EventHandlerCBD))\n" + " ->OnEvent6(NewPermanentCallback(\n" + " this, &HandlerHolderClass::EventHandlerCBE)));\n" + "}"); -TEST_F(FormatTest, DoesNotBreakTrailingAnnotation) { - verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" - " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); - verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" - " LOCKS_EXCLUDED(aaaaaaaaaaaaa);"); - verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n" - " LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}"); - verifyFormat( - "void aaaaaaaaaaaaaaaaaa()\n" - " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" - " aaaaaaaaaaaaaaaaaaaaaaaaa));"); - verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" - " __attribute__((unused));"); verifyFormat( - "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" - " GUARDED_BY(aaaaaaaaaaaa);"); + "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();"); + verifyFormat("aaaaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaa();"); + verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaa();"); + verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaa();"); + verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n" + " ->aaaaaaaaaaaaaae(0)\n" + " ->aaaaaaaaaaaaaaa();"); + + verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n" + " .has();"); + verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n" + " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();"); + + // Prefer not to break after empty parentheses. + verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n" + " First->LastNewlineOffset);"); } TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { @@ -1990,8 +3301,12 @@ TEST_F(FormatTest, BreaksAfterAssignments) { " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); verifyFormat( - "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa()\n" - " .aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); + "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);"); + verifyFormat("unsigned OriginalStartColumn =\n" + " SourceMgr.getSpellingColumnNumber(\n" + " Current.FormatTok.getStartOfNonWhitespace()) -\n" + " 1;"); } TEST_F(FormatTest, AlignsAfterAssignments) { @@ -2007,9 +3322,10 @@ TEST_F(FormatTest, AlignsAfterAssignments) { verifyFormat( "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaa);"); - verifyFormat("double LooooooooooooooooooooooooongResult =\n" - " aaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaa +\n" - " aaaaaaaaaaaaaaaaaaaaaaaa;"); + verifyFormat( + "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" + " aaaaaaaaaaaaaaaaaaaaaaaa +\n" + " aaaaaaaaaaaaaaaaaaaaaaaa;"); } TEST_F(FormatTest, AlignsAfterReturn) { @@ -2030,13 +3346,16 @@ TEST_F(FormatTest, AlignsAfterReturn) { verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); + verifyFormat("return\n" + " // true if code is one of a or b.\n" + " code == a || code == b;"); } TEST_F(FormatTest, BreaksConditionalExpressions) { verifyFormat( - "aaaa(aaaaaaaaaaaaaaaaaaaa,\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" - " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); + "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); @@ -2048,6 +3367,10 @@ TEST_F(FormatTest, BreaksConditionalExpressions) { " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaa);"); + verifyFormat( + "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaa);"); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" @@ -2060,7 +3383,11 @@ TEST_F(FormatTest, BreaksConditionalExpressions) { " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); - + verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); @@ -2083,6 +3410,16 @@ TEST_F(FormatTest, BreaksConditionalExpressions) { " : TheLine * 2,\n" " TheLine.InPPDirective, PreviousEndOfLineColumn);", getLLVMStyleWithColumns(70)); + verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" + " ? aaaaaaaaaaaaaaa\n" + " : bbbbbbbbbbbbbbb //\n" + " ? ccccccccccccccc\n" + " : ddddddddddddddd;"); + verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" + " ? aaaaaaaaaaaaaaa\n" + " : (bbbbbbbbbbbbbbb //\n" + " ? ccccccccccccccc\n" + " : ddddddddddddddd);"); FormatStyle NoBinPacking = getLLVMStyle(); NoBinPacking.BinPackParameters = false; @@ -2095,6 +3432,102 @@ TEST_F(FormatTest, BreaksConditionalExpressions) { " : aaaaaaaaaaaaaaa);\n" "}", NoBinPacking); + verifyFormat( + "void f() {\n" + " g(aaa,\n" + " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " ?: aaaaaaaaaaaaaaa);\n" + "}", + NoBinPacking); +} + +TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { + FormatStyle Style = getLLVMStyle(); + Style.BreakBeforeTernaryOperators = false; + Style.ColumnLimit = 70; + verifyFormat( + "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", + Style); + verifyFormat( + "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", + Style); + verifyFormat( + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n" + " aaaaaaaaaaaaa);", + Style); + verifyFormat( + "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaa);", + Style); + verifyFormat( + "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaa);", + Style); + verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", + Style); + verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", + Style); + verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaa);", + Style); + verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaa;", + Style); + verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", + Style); + verifyFormat( + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" + " aaaaaaaaaaaaaaa :\n" + " aaaaaaaaaaaaaaa;", + Style); + verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" + " aaaaaaaaa ?\n" + " b :\n" + " c);", + Style); + verifyFormat( + "unsigned Indent =\n" + " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0 ?\n" + " IndentForLevel[TheLine.Level] :\n" + " TheLine * 2,\n" + " TheLine.InPPDirective, PreviousEndOfLineColumn);", + Style); + verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" + " aaaaaaaaaaaaaaa :\n" + " bbbbbbbbbbbbbbb ? //\n" + " ccccccccccccccc :\n" + " ddddddddddddddd;", + Style); + verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n" + " aaaaaaaaaaaaaaa :\n" + " (bbbbbbbbbbbbbbb ? //\n" + " ccccccccccccccc :\n" + " ddddddddddddddd);", + Style); } TEST_F(FormatTest, DeclarationsOfMultipleVariables) { @@ -2118,9 +3551,10 @@ TEST_F(FormatTest, DeclarationsOfMultipleVariables) { " ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;"); // FIXME: If multiple variables are defined, the "*" needs to move to the new // line. Also fix indent for breaking after the type, this looks bad. - verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" + verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" - " *b = bbbbbbbbbbbbbbbbbbb;"); + " *b = bbbbbbbbbbbbbbbbbbb;", + getGoogleStyle()); // Not ideal, but pointer-with-type does not allow much here. verifyGoogleFormat( @@ -2161,11 +3595,78 @@ TEST_F(FormatTest, AlignsStringLiterals) { verifyFormat("a = a + \"a\"\n" " \"a\"\n" " \"a\";"); + verifyFormat("f(\"a\", \"b\"\n" + " \"c\");"); verifyFormat( "#define LL_FORMAT \"ll\"\n" "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n" " \"d, ddddddddd: %\" LL_FORMAT \"d\");"); + + verifyFormat("#define A(X) \\\n" + " \"aaaaa\" #X \"bbbbbb\" \\\n" + " \"ccccc\"", + getLLVMStyleWithColumns(23)); + verifyFormat("#define A \"def\"\n" + "f(\"abc\" A \"ghi\"\n" + " \"jkl\");"); +} + +TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) { + FormatStyle NoBreak = getLLVMStyle(); + NoBreak.AlwaysBreakBeforeMultilineStrings = false; + FormatStyle Break = getLLVMStyle(); + Break.AlwaysBreakBeforeMultilineStrings = true; + verifyFormat("aaaa = \"bbbb\"\n" + " \"cccc\";", + NoBreak); + verifyFormat("aaaa =\n" + " \"bbbb\"\n" + " \"cccc\";", + Break); + verifyFormat("aaaa(\"bbbb\"\n" + " \"cccc\");", + NoBreak); + verifyFormat("aaaa(\n" + " \"bbbb\"\n" + " \"cccc\");", + Break); + verifyFormat("aaaa(qqq, \"bbbb\"\n" + " \"cccc\");", + NoBreak); + verifyFormat("aaaa(qqq,\n" + " \"bbbb\"\n" + " \"cccc\");", + Break); + + // Don't break if there is no column gain. + verifyFormat("f(\"aaaa\"\n" + " \"bbbb\");", + Break); + + // Treat literals with escaped newlines like multi-line string literals. + EXPECT_EQ("x = \"a\\\n" + "b\\\n" + "c\";", + format("x = \"a\\\n" + "b\\\n" + "c\";", + NoBreak)); + EXPECT_EQ("x =\n" + " \"a\\\n" + "b\\\n" + "c\";", + format("x = \"a\\\n" + "b\\\n" + "c\";", + Break)); + + // Exempt ObjC strings for now. + EXPECT_EQ("NSString *const kString = @\"aaaa\"\n" + " \"bbbb\";", + format("NSString *const kString = @\"aaaa\"\n" + "\"bbbb\";", + Break)); } TEST_F(FormatTest, AlignsPipes) { @@ -2189,12 +3690,15 @@ TEST_F(FormatTest, AlignsPipes) { " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat("return out << \"somepacket = {\\n\"\n" - " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" - " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" - " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" - " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" + " << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n" + " << \" bbbb = \" << pkt.bbbb << \"\\n\"\n" + " << \" cccccc = \" << pkt.cccccc << \"\\n\"\n" + " << \" ddd = [\" << pkt.ddd << \"]\\n\"\n" " << \"}\";"); + verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" + " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" + " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); verifyFormat( "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" @@ -2203,10 +3707,43 @@ TEST_F(FormatTest, AlignsPipes) { " << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;"); verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n" " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); + verifyFormat( + "void f() {\n" + " llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n" + " << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" + "}"); + + // Breaking before the first "<<" is generally not desirable. + verifyFormat( + "llvm::errs()\n" + " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", + getLLVMStyleWithColumns(70)); + verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n" + " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " << \"aaaaaaaaaaaaaaaaaaa: \"\n" + " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " << \"aaaaaaaaaaaaaaaaaaa: \"\n" + " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", + getLLVMStyleWithColumns(70)); + + // But sometimes, breaking before the first "<<" is desirable. + verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n" + " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" + " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); + verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n" + " << BEF << IsTemplate << Description << E->getType();"); verifyFormat( "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); + + // Incomplete string literal. + EXPECT_EQ("llvm::errs() << \"\n" + " << a;", + format("llvm::errs() << \"\n<aaaaaaaaa());\n" + "}"); verifyFormat( "aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" - " .aaaaaaaaaaaaaaa(\n" - " aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); + " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" @@ -2294,11 +3838,23 @@ TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { " aaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", NoBinPacking); + + // If there is a subsequent call, change to hanging indentation. + verifyFormat( + "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n" + " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); + verifyFormat( + "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" + " aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));"); } TEST_F(FormatTest, WrapsTemplateDeclarations) { verifyFormat("template \n" "virtual void loooooooooooongFunction(int Param1, int Param2);"); + verifyFormat("template \n" + "// T should be one of {A, B}.\n" + "virtual void loooooooooooongFunction(int Param1, int Param2);"); verifyFormat( "template \n" "using comment_to_xml_conversion = comment_to_xml_conversion;"); @@ -2325,8 +3881,39 @@ TEST_F(FormatTest, WrapsTemplateDeclarations) { "aaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); - verifyFormat("a(\n" - " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));"); + verifyFormat("void f() {\n" + " a(\n" + " a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n" + "}"); + + verifyFormat("template class C {};"); + verifyFormat("template void f();"); + verifyFormat("template void f() {}"); + verifyFormat( + "aaaaaaaaaaaaa *aaaa =\n" + " new aaaaaaaaaaaaa(\n" + " bbbbbbbbbbbbbbbbbbbbbbbb);", + getLLVMStyleWithColumns(72)); + + FormatStyle AlwaysBreak = getLLVMStyle(); + AlwaysBreak.AlwaysBreakTemplateDeclarations = true; + verifyFormat("template \nclass C {};", AlwaysBreak); + verifyFormat("template \nvoid f();", AlwaysBreak); + verifyFormat("template \nvoid f() {}", AlwaysBreak); + verifyFormat("void aaaaaaaaaaaaaaaaaaa(\n" + " ccccccccccccccccccccccccccccccccccccccccccccccc);"); + verifyFormat("template