head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.15 netbsd-11-0-RC3:1.1.1.15 netbsd-11-0-RC2:1.1.1.15 netbsd-11-0-RC1:1.1.1.15 perseant-exfatfs-base-20250801:1.1.1.15 netbsd-11:1.1.1.15.0.10 netbsd-11-base:1.1.1.15 netbsd-10-1-RELEASE:1.1.1.15 perseant-exfatfs-base-20240630:1.1.1.15 perseant-exfatfs:1.1.1.15.0.8 perseant-exfatfs-base:1.1.1.15 netbsd-8-3-RELEASE:1.1.1.11 netbsd-9-4-RELEASE:1.1.1.14 netbsd-10-0-RELEASE:1.1.1.15 netbsd-10-0-RC6:1.1.1.15 netbsd-10-0-RC5:1.1.1.15 netbsd-10-0-RC4:1.1.1.15 netbsd-10-0-RC3:1.1.1.15 netbsd-10-0-RC2:1.1.1.15 netbsd-10-0-RC1:1.1.1.15 netbsd-10:1.1.1.15.0.6 netbsd-10-base:1.1.1.15 netbsd-9-3-RELEASE:1.1.1.14 cjep_sun2x:1.1.1.15.0.4 cjep_sun2x-base:1.1.1.15 cjep_staticlib_x-base1:1.1.1.15 netbsd-9-2-RELEASE:1.1.1.14 cjep_staticlib_x:1.1.1.15.0.2 cjep_staticlib_x-base:1.1.1.15 netbsd-9-1-RELEASE:1.1.1.14 phil-wifi-20200421:1.1.1.15 phil-wifi-20200411:1.1.1.15 phil-wifi-20200406:1.1.1.15 netbsd-8-2-RELEASE:1.1.1.11 netbsd-9-0-RELEASE:1.1.1.14 netbsd-9-0-RC2:1.1.1.14 netbsd-9-0-RC1:1.1.1.14 netbsd-9:1.1.1.14.0.2 netbsd-9-base:1.1.1.14 phil-wifi-20190609:1.1.1.14 netbsd-8-1-RELEASE:1.1.1.11 netbsd-8-1-RC1:1.1.1.11 pgoyette-compat-merge-20190127:1.1.1.13.2.1 pgoyette-compat-20190127:1.1.1.14 pgoyette-compat-20190118:1.1.1.14 pgoyette-compat-1226:1.1.1.14 pgoyette-compat-1126:1.1.1.14 pgoyette-compat-1020:1.1.1.14 pgoyette-compat-0930:1.1.1.14 pgoyette-compat-0906:1.1.1.14 netbsd-7-2-RELEASE:1.1.1.7.2.1 pgoyette-compat-0728:1.1.1.14 clang-337282:1.1.1.14 netbsd-8-0-RELEASE:1.1.1.11 phil-wifi:1.1.1.13.0.4 phil-wifi-base:1.1.1.13 pgoyette-compat-0625:1.1.1.13 netbsd-8-0-RC2:1.1.1.11 pgoyette-compat-0521:1.1.1.13 pgoyette-compat-0502:1.1.1.13 pgoyette-compat-0422:1.1.1.13 netbsd-8-0-RC1:1.1.1.11 pgoyette-compat-0415:1.1.1.13 pgoyette-compat-0407:1.1.1.13 pgoyette-compat-0330:1.1.1.13 pgoyette-compat-0322:1.1.1.13 pgoyette-compat-0315:1.1.1.13 netbsd-7-1-2-RELEASE:1.1.1.7.2.1 pgoyette-compat:1.1.1.13.0.2 pgoyette-compat-base:1.1.1.13 netbsd-7-1-1-RELEASE:1.1.1.7.2.1 clang-319952:1.1.1.13 matt-nb8-mediatek:1.1.1.11.0.8 matt-nb8-mediatek-base:1.1.1.11 clang-309604:1.1.1.12 perseant-stdc-iso10646:1.1.1.11.0.6 perseant-stdc-iso10646-base:1.1.1.11 netbsd-8:1.1.1.11.0.4 netbsd-8-base:1.1.1.11 prg-localcount2-base3:1.1.1.11 prg-localcount2-base2:1.1.1.11 prg-localcount2-base1:1.1.1.11 prg-localcount2:1.1.1.11.0.2 prg-localcount2-base:1.1.1.11 pgoyette-localcount-20170426:1.1.1.11 bouyer-socketcan-base1:1.1.1.11 pgoyette-localcount-20170320:1.1.1.11 netbsd-7-1:1.1.1.7.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.7.2.1 netbsd-7-1-RC2:1.1.1.7.2.1 clang-294123:1.1.1.11 netbsd-7-nhusb-base-20170116:1.1.1.7.2.1 bouyer-socketcan:1.1.1.10.0.2 bouyer-socketcan-base:1.1.1.10 clang-291444:1.1.1.10 pgoyette-localcount-20170107:1.1.1.9 netbsd-7-1-RC1:1.1.1.7.2.1 pgoyette-localcount-20161104:1.1.1.9 netbsd-7-0-2-RELEASE:1.1.1.7.2.1 localcount-20160914:1.1.1.9 netbsd-7-nhusb:1.1.1.7.2.1.0.4 netbsd-7-nhusb-base:1.1.1.7.2.1 clang-280599:1.1.1.9 pgoyette-localcount-20160806:1.1.1.9 pgoyette-localcount-20160726:1.1.1.9 pgoyette-localcount:1.1.1.9.0.2 pgoyette-localcount-base:1.1.1.9 netbsd-7-0-1-RELEASE:1.1.1.7.2.1 clang-261930:1.1.1.9 netbsd-7-0:1.1.1.7.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.7.2.1 netbsd-7-0-RC3:1.1.1.7.2.1 netbsd-7-0-RC2:1.1.1.7.2.1 netbsd-7-0-RC1:1.1.1.7.2.1 clang-237755:1.1.1.8 clang-232565:1.1.1.8 clang-227398:1.1.1.8 tls-maxphys-base:1.1.1.7 tls-maxphys:1.1.1.7.0.4 netbsd-7:1.1.1.7.0.2 netbsd-7-base:1.1.1.7 clang-215315:1.1.1.7 clang-209886:1.1.1.6 yamt-pagecache:1.1.1.5.0.4 yamt-pagecache-base9:1.1.1.5 tls-earlyentropy:1.1.1.5.0.2 tls-earlyentropy-base:1.1.1.6 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.5 riastradh-drm2-base3:1.1.1.5 clang-202566:1.1.1.5 clang-201163:1.1.1.4 clang-199312:1.1.1.3 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.48; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.48; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.00; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.01.15.21.26.18; author joerg; state Exp; branches; next 1.1.1.4; commitid NQXlzzA0SPkc5glx; 1.1.1.4 date 2014.02.14.20.07.03; author joerg; state Exp; branches; next 1.1.1.5; commitid annVkZ1sc17rF6px; 1.1.1.5 date 2014.03.04.19.53.25; author joerg; state Exp; branches 1.1.1.5.2.1 1.1.1.5.4.1; next 1.1.1.6; commitid 29z1hJonZISIXprx; 1.1.1.6 date 2014.05.30.18.14.50; author joerg; state Exp; branches; next 1.1.1.7; commitid 8q0kdlBlCn09GACx; 1.1.1.7 date 2014.08.10.17.08.25; author joerg; state Exp; branches 1.1.1.7.2.1 1.1.1.7.4.1; next 1.1.1.8; commitid N85tXAN6Ex9VZPLx; 1.1.1.8 date 2015.01.29.19.57.27; author joerg; state Exp; branches; next 1.1.1.9; commitid mlISSizlPKvepX7y; 1.1.1.9 date 2016.02.27.22.11.44; author joerg; state Exp; branches 1.1.1.9.2.1; next 1.1.1.10; commitid tIimz3oDlh1NpBWy; 1.1.1.10 date 2017.01.11.10.33.05; author joerg; state Exp; branches 1.1.1.10.2.1; next 1.1.1.11; commitid CNnUNfII1jgNmxBz; 1.1.1.11 date 2017.02.09.17.37.55; author joerg; state Exp; branches; next 1.1.1.12; commitid UxB8JMFWM7xyMiFz; 1.1.1.12 date 2017.08.01.19.34.42; author joerg; state Exp; branches; next 1.1.1.13; commitid pMuDy65V0VicSx1A; 1.1.1.13 date 2017.12.17.20.58.42; author joerg; state Exp; branches 1.1.1.13.2.1 1.1.1.13.4.1; next 1.1.1.14; commitid T7p9sjiUJyY1UhjA; 1.1.1.14 date 2018.07.17.18.32.12; author joerg; state Exp; branches; next 1.1.1.15; commitid wDzL46ALjrCZgwKA; 1.1.1.15 date 2019.11.13.22.23.10; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.5.2.1 date 2014.08.10.07.08.25; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.5.4.1 date 2014.03.04.19.53.25; author yamt; state dead; branches; next 1.1.1.5.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.5.4.2 date 2014.05.22.16.19.49; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.7.2.1 date 2015.06.04.20.04.47; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.7.4.1 date 2014.08.10.17.08.25; author tls; state dead; branches; next 1.1.1.7.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.7.4.2 date 2014.08.19.23.49.28; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.9.2.1 date 2017.03.20.06.53.39; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.10.2.1 date 2017.04.21.16.51.44; author bouyer; state Exp; branches; next ; commitid dUG7nkTKALCadqOz; 1.1.1.13.2.1 date 2018.07.28.04.34.18; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.13.4.1 date 2019.06.10.21.46.46; author christos; state Exp; branches; next 1.1.1.13.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.13.4.2 date 2020.04.13.07.50.38; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #define DEBUG_TYPE "format-test" #include "clang/Format/Format.h" #include "clang/Lex/Lexer.h" #include "llvm/Support/Debug.h" #include "gtest/gtest.h" namespace clang { namespace format { class FormatTest : public ::testing::Test { protected: std::string format(llvm::StringRef Code, unsigned Offset, unsigned Length, const FormatStyle &Style) { DEBUG(llvm::errs() << "---\n"); 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 format(llvm::StringRef Code, const FormatStyle &Style = getLLVMStyle()) { return format(Code, 0, Code.size(), Style); } std::string messUp(llvm::StringRef Code) { std::string MessedUp(Code.str()); bool InComment = false; bool InPreprocessorDirective = false; bool JustReplacedNewline = false; for (unsigned i = 0, e = MessedUp.size() - 1; i != e; ++i) { if (MessedUp[i] == '/' && MessedUp[i + 1] == '/') { if (JustReplacedNewline) MessedUp[i - 1] = '\n'; InComment = true; } else if (MessedUp[i] == '#' && (JustReplacedNewline || i == 0)) { if (i != 0) MessedUp[i - 1] = '\n'; InPreprocessorDirective = true; } else if (MessedUp[i] == '\\' && MessedUp[i + 1] == '\n') { MessedUp[i] = ' '; MessedUp[i + 1] = ' '; } else if (MessedUp[i] == '\n') { if (InComment) { InComment = false; } else if (InPreprocessorDirective) { InPreprocessorDirective = false; } else { JustReplacedNewline = true; MessedUp[i] = ' '; } } else if (MessedUp[i] != ' ') { JustReplacedNewline = false; } } 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) { FormatStyle Style = getLLVMStyle(); Style.ColumnLimit = ColumnLimit; return Style; } FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) { FormatStyle Style = getGoogleStyle(); Style.ColumnLimit = ColumnLimit; return Style; } void verifyFormat(llvm::StringRef Code, const FormatStyle &Style = getLLVMStyle()) { EXPECT_EQ(Code.str(), format(messUp(Code), Style)); } void verifyGoogleFormat(llvm::StringRef Code) { verifyFormat(Code, getGoogleStyle()); } void verifyIndependentOfContext(llvm::StringRef text) { verifyFormat(text); verifyFormat(llvm::Twine("void f() { " + text + " }").str()); } int ReplacementCount; }; TEST_F(FormatTest, MessUp) { EXPECT_EQ("1 2 3", messUp("1 2 3")); 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")); } //===----------------------------------------------------------------------===// // Basic function tests. //===----------------------------------------------------------------------===// 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 \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;")); } TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { EXPECT_EQ("int i;", format("int\ni;")); } TEST_F(FormatTest, FormatsNestedBlockStatements) { EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}")); } TEST_F(FormatTest, FormatsNestedCall) { verifyFormat("Method(f1, f2(f3));"); verifyFormat("Method(f1(f2, f3()));"); verifyFormat("Method(f1(f2, (f3())));"); } 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) { EXPECT_EQ("if (a) {\n" " f();\n" "}", format("if(a){f();}")); EXPECT_EQ(4, ReplacementCount); EXPECT_EQ("if (a) {\n" " f();\n" "}", format("if (a) {\n" " f();\n" "}")); EXPECT_EQ(0, ReplacementCount); } TEST_F(FormatTest, RemovesTrailingWhitespaceOfFormattedLine) { EXPECT_EQ("int a;\nint b;", format("int a; \nint b;", 0, 0, getLLVMStyle())); EXPECT_EQ("int a;", format("int a; ")); EXPECT_EQ("int a;\n", format("int a; \n \n \n ")); EXPECT_EQ("int a;\nint b; ", format("int a; \nint b; ", 0, 0, getLLVMStyle())); } TEST_F(FormatTest, FormatsCorrectRegionForLeadingWhitespace) { EXPECT_EQ("int b;\nint a;", format("int b;\n int a;", 7, 0, getLLVMStyle())); EXPECT_EQ("int b;\n int a;", format("int b;\n int a;", 6, 0, getLLVMStyle())); EXPECT_EQ("#define A \\\n" " int a; \\\n" " int b;", format("#define A \\\n" " int a; \\\n" " int b;", 26, 0, getLLVMStyleWithColumns(12))); EXPECT_EQ("#define A \\\n" " int a; \\\n" " int b;", format("#define A \\\n" " int a; \\\n" " int b;", 25, 0, getLLVMStyleWithColumns(12))); } TEST_F(FormatTest, RemovesWhitespaceWhenTriggeredOnEmptyLine) { EXPECT_EQ("int a;\n\n int b;", format("int a;\n \n\n int b;", 7, 0, getLLVMStyle())); EXPECT_EQ("int a;\n\n int b;", 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" " return static_cast(FETokenInfo);\n" "}\n" " int a; // <- Should not be formatted", format( "template\n" "T *getFETokenInfo() const { return static_cast(FETokenInfo); }\n" " int a; // <- Should not be formatted", 9, 5, getLLVMStyle())); } //===----------------------------------------------------------------------===// // Tests for control statements. //===----------------------------------------------------------------------===// 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 = 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" " f();\n", AllowsMergedIf); verifyFormat("if (a) /* still don't merge */\n" " f();", AllowsMergedIf); verifyFormat("if (a) { // Never merge this\n" " f();\n" "}", AllowsMergedIf); verifyFormat("if (a) { /* Never merge this */\n" " f();\n" "}", 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" " return;", AllowsMergedIf); AllowsMergedIf.ColumnLimit = 13; 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" " if (true)\n" " f();\n" " else\n" " g();\n" " else\n" " h();\n" "else\n" " i();"); verifyFormat("if (true)\n" " if (true)\n" " if (true) {\n" " if (true)\n" " f();\n" " } else {\n" " g();\n" " }\n" " else\n" " h();\n" "else {\n" " i();\n" "}"); verifyFormat("void f() {\n" " if (a) {\n" " } else {\n" " }\n" "}"); } TEST_F(FormatTest, ElseIf) { verifyFormat("if (a) {\n} else if (b) {\n}"); verifyFormat("if (a)\n" " f();\n" "else if (b)\n" " g();\n" "else\n" " h();"); verifyFormat("if (a) {\n" " f();\n" "}\n" "// or else ..\n" "else {\n" " g()\n" "}"); } TEST_F(FormatTest, FormatsForLoop) { verifyFormat( "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n" " ++VeryVeryLongLoopVariable)\n" " ;"); verifyFormat("for (;;)\n" " f();"); verifyFormat("for (;;) {\n}"); verifyFormat("for (;;) {\n" " f();\n" "}"); verifyFormat("for (int i = 0; (i < 10); ++i) {\n}"); verifyFormat( "for (std::vector::iterator I = UnwrappedLines.begin(),\n" " E = UnwrappedLines.end();\n" " I != E; ++I) {\n}"); verifyFormat( "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n" " ++IIIII) {\n}"); verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n" " aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n" " aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}"); verifyFormat("for (llvm::ArrayRef::iterator\n" " I = FD->getDeclsInPrototypeScope().begin(),\n" " E = FD->getDeclsInPrototypeScope().end();\n" " I != E; ++I) {\n}"); // FIXME: Not sure whether we want extra identation in line 3 here: verifyFormat( "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" " ++aaaaaaaaaaa) {\n}"); verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n" " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" "}"); verifyFormat("for (some_namespace::SomeIterator iter( // force break\n" " aaaaaaaaaa);\n" " iter; ++iter) {\n" "}"); FormatStyle NoBinPacking = getLLVMStyle(); NoBinPacking.BinPackParameters = false; verifyFormat("for (int aaaaaaaaaaa = 1;\n" " aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaa);\n" " aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n" "}", NoBinPacking); verifyFormat( "for (std::vector::iterator I = UnwrappedLines.begin(),\n" " E = UnwrappedLines.end();\n" " I != E;\n" " ++I) {\n}", NoBinPacking); } TEST_F(FormatTest, RangeBasedForLoops) { verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n" " aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}"); verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); } TEST_F(FormatTest, FormatsWhileLoop) { verifyFormat("while (true) {\n}"); verifyFormat("while (true)\n" " f();"); verifyFormat("while () {\n}"); verifyFormat("while () {\n" " f();\n" "}"); } TEST_F(FormatTest, FormatsDoWhile) { verifyFormat("do {\n" " do_something();\n" "} while (something());"); verifyFormat("do\n" " do_something();\n" "while (something());"); } TEST_F(FormatTest, FormatsSwitchStatement) { verifyFormat("switch (x) {\n" "case 1:\n" " f();\n" " break;\n" "case kFoo:\n" "case ns::kBar:\n" "case kBaz:\n" " break;\n" "default:\n" " g();\n" " break;\n" "}"); verifyFormat("switch (x) {\n" "case 1: {\n" " f();\n" " break;\n" "}\n" "}"); verifyFormat("switch (x) {\n" "case 1: {\n" " f();\n" " {\n" " g();\n" " h();\n" " }\n" " break;\n" "}\n" "}"); verifyFormat("switch (x) {\n" "case 1: {\n" " f();\n" " if (foo) {\n" " g();\n" " h();\n" " }\n" " break;\n" "}\n" "}"); verifyFormat("switch (x) {\n" "case 1: {\n" " f();\n" " g();\n" "} break;\n" "}"); verifyFormat("switch (test)\n" " ;"); verifyFormat("switch (x) {\n" "default: {\n" " // Do nothing.\n" "}\n" "}"); verifyFormat("switch (x) {\n" "// comment\n" "// if 1, do f()\n" "case 1:\n" " f();\n" "}"); verifyFormat("switch (x) {\n" "case 1:\n" " // Do amazing stuff\n" " {\n" " f();\n" " g();\n" " }\n" " break;\n" "}"); verifyFormat("#define A \\\n" " switch (x) { \\\n" " 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" " f();\n" " break;\n" " case kFoo:\n" " case ns::kBar:\n" " case kBaz:\n" " break;\n" " default:\n" " g();\n" " break;\n" "}"); verifyGoogleFormat("switch (x) {\n" " case 1: {\n" " f();\n" " break;\n" " }\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) { verifyFormat("void f() {\n" " some_code();\n" "test_label:\n" " some_other_code();\n" " {\n" " some_more_code();\n" " another_label:\n" " some_more_code();\n" " }\n" "}"); verifyFormat("some_code();\n" "test_label:\n" "some_other_code();"); } //===----------------------------------------------------------------------===// // Tests for comments. //===----------------------------------------------------------------------===// TEST_F(FormatTest, UnderstandsSingleLineComments) { verifyFormat("//* */"); verifyFormat("// line 1\n" "// line 2\n" "void f() {}\n"); 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)"); verifyFormat("void f(int i,\n" " // some comment (probably for j)\n" " int j,\n" " // some comment (probably for k)\n" " int k);"); verifyFormat("int i // This is a fancy variable\n" " = 5; // with nicely aligned comment."); verifyFormat("// Leading comment.\n" "int a; // Trailing comment."); verifyFormat("int a; // Trailing comment\n" " // on 2\n" " // or 3 lines.\n" "int b;"); verifyFormat("int a; // Trailing comment\n" "\n" "// Leading comment.\n" "int b;"); verifyFormat("int a; // Comment.\n" " // More details.\n" "int bbbb; // Another comment."); verifyFormat( "int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa; // comment\n" "int bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // comment\n" "int cccccccccccccccccccccccccccccc; // comment\n" "int ddd; // looooooooooooooooooooooooong comment\n" "int aaaaaaaaaaaaaaaaaaaaaaa; // comment\n" "int bbbbbbbbbbbbbbbbbbbbb; // comment\n" "int ccccccccccccccccccc; // comment"); verifyFormat("#include \"a\" // comment\n" "#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" " VAL_A, // comment\n" " VAL_B\n" "};"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb; // Trailing comment"); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" " // Comment inside a statement.\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); verifyFormat( "bool aaaaaaaaaaaaa = // comment\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat("int aaaa; // aaaaa\n" "int aa; // aaaaaaa", getLLVMStyleWithColumns(20)); EXPECT_EQ("void f() { // This does something ..\n" "}\n" "int a; // This is unrelated", format("void f() { // This does something ..\n" " }\n" "int a; // This is unrelated")); EXPECT_EQ("class C {\n" " void f() { // This does something ..\n" " } // awesome..\n" "\n" " int a; // This is unrelated\n" "};", format("class C{void f() { // This does something ..\n" " } // awesome..\n" " \n" "int a; // This is unrelated\n" "};")); EXPECT_EQ("int i; // single line trailing comment", format("int i;\\\n// single line trailing comment")); verifyGoogleFormat("int a; // Trailing comment."); verifyFormat("someFunction(anotherFunction( // Force break.\n" " parameter));"); verifyGoogleFormat("#endif // HEADER_GUARD"); verifyFormat("const char *test[] = {\n" " // A\n" " \"aaaa\",\n" " // B\n" " \"aaaaa\",\n" "};"); verifyGoogleFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaa); // 81_cols_with_this_comment"); EXPECT_EQ("D(a, {\n" " // test\n" " int a;\n" "});", format("D(a, {\n" "// 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) { EXPECT_EQ("int a; // comment\n" "int b; // comment", format("int a; // comment\n" "int b; // comment", 0, 0, getLLVMStyle())); EXPECT_EQ("int a; // comment\n" " // line 2\n" "int b;", format("int a; // comment\n" " // line 2\n" "int b;", 28, 0, getLLVMStyle())); EXPECT_EQ("int aaaaaa; // comment\n" "int b;\n" "int c; // unrelated comment", format("int aaaaaa; // comment\n" "int b;\n" "int c; // unrelated comment", 31, 0, getLLVMStyle())); } TEST_F(FormatTest, RemovesTrailingWhitespaceOfComments) { EXPECT_EQ("// comment", format("// comment ")); 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, UnderstandsBlockComments) { verifyFormat("f(/*noSpaceAfterParameterNamingComment=*/true);"); EXPECT_EQ( "f(aaaaaaaaaaaaaaaaaaaaaaaaa, /* Trailing comment for aa... */\n" " bbbbbbbbbbbbbbbbbbbbbbbbb);", format("f(aaaaaaaaaaaaaaaaaaaaaaaaa , \\\n/* Trailing comment for aa... */\n" " bbbbbbbbbbbbbbbbbbbbbbbbb);")); EXPECT_EQ( "f(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" " /* 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; verifyFormat("aaaaaaaa(/* parameter 1 */ aaaaaa,\n" " /* parameter 2 */ aaaaaa,\n" " /* parameter 3 */ aaaaaa,\n" " /* parameter 4 */ aaaaaa);", NoBinPacking); } TEST_F(FormatTest, AlignsBlockComments) { EXPECT_EQ("/*\n" " * Really multi-line\n" " * comment.\n" " */\n" "void f() {}", format(" /*\n" " * Really multi-line\n" " * comment.\n" " */\n" " void f() {}")); EXPECT_EQ("class C {\n" " /*\n" " * Another multi-line\n" " * comment.\n" " */\n" " void f() {}\n" "};", format("class C {\n" "/*\n" " * Another multi-line\n" " * comment.\n" " */\n" "void f() {}\n" "};")); EXPECT_EQ("/*\n" " 1. This is a comment with non-trivial formatting.\n" " 1.1. We have to indent/outdent all lines equally\n" " 1.1.1. to keep the formatting.\n" " */", format(" /*\n" " 1. This is a comment with non-trivial formatting.\n" " 1.1. We have to indent/outdent all lines equally\n" " 1.1.1. to keep the formatting.\n" " */")); EXPECT_EQ("/*\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 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) { EXPECT_EQ("// A comment that\n" "// doesn't fit on\n" "// one line", format("// A comment that doesn't fit on one line", getLLVMStyleWithColumns(20))); EXPECT_EQ("// a b c d\n" "// e f g\n" "// h i j k", format("// a b c d e f g h i j k", getLLVMStyleWithColumns(10))); EXPECT_EQ("// a b c d\n" "// e f g\n" "// h i j k", format("\\\n// a b c d e f g h i j k", getLLVMStyleWithColumns(10))); EXPECT_EQ("if (true) // A comment that\n" " // doesn't fit on\n" " // one line", format("if (true) // A comment that doesn't fit on one line ", getLLVMStyleWithColumns(30))); EXPECT_EQ("// Don't_touch_leading_whitespace", format("// Don't_touch_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" "#define a b", 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) { EXPECT_EQ("namespace {}\n// Test\n#define A", format("namespace {}\n // Test\n#define A")); EXPECT_EQ("namespace {}\n/* Test */\n#define A", format("namespace {}\n /* Test */\n#define A")); EXPECT_EQ("namespace {}\n/* Test */ #define A", format("namespace {}\n /* Test */ #define A")); } TEST_F(FormatTest, SplitsLongLinesInComments) { EXPECT_EQ("/* This is a long\n" " * comment that\n" " * doesn't\n" " * fit on one line.\n" " */", format("/* " "This is a long " "comment that " "doesn't " "fit on one line. */", getLLVMStyleWithColumns(20))); EXPECT_EQ("/* a b c d\n" " * e f g\n" " * h i j k\n" " */", format("/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10))); EXPECT_EQ("/* a b c d\n" " * e f g\n" " * h i j k\n" " */", format("\\\n/* a b c d e f g h i j k */", getLLVMStyleWithColumns(10))); EXPECT_EQ("/*\n" "This is a long\n" "comment that doesn't\n" "fit on one line.\n" "*/", format("/*\n" "This is a long " "comment that doesn't " "fit on one line. \n" "*/", getLLVMStyleWithColumns(20))); EXPECT_EQ("/*\n" " * This is a long\n" " * comment that\n" " * doesn't fit on\n" " * one line.\n" " */", format("/* \n" " * This is a long " " comment that " " doesn't fit on " " one line. \n" " */", getLLVMStyleWithColumns(20))); EXPECT_EQ("/*\n" " * This_is_a_comment_with_words_that_dont_fit_on_one_line\n" " * so_it_should_be_broken\n" " * wherever_a_space_occurs\n" " */", format("/*\n" " * This_is_a_comment_with_words_that_dont_fit_on_one_line " " so_it_should_be_broken " " wherever_a_space_occurs \n" " */", getLLVMStyleWithColumns(20))); EXPECT_EQ("/*\n" " * This_comment_can_not_be_broken_into_lines\n" " */", format("/*\n" " * This_comment_can_not_be_broken_into_lines\n" " */", getLLVMStyleWithColumns(20))); EXPECT_EQ("{\n" " /*\n" " This is another\n" " long comment that\n" " doesn't fit on one\n" " line 1234567890\n" " */\n" "}", format("{\n" "/*\n" "This is another " " long comment that " " doesn't fit on one" " line 1234567890\n" "*/\n" "}", getLLVMStyleWithColumns(20))); EXPECT_EQ("{\n" " /*\n" " * This i s\n" " * another comment\n" " * t hat doesn' t\n" " * fit on one l i\n" " * n e\n" " */\n" "}", format("{\n" "/*\n" " * This i s" " another comment" " t hat doesn' t" " fit on one l i" " n e\n" " */\n" "}", getLLVMStyleWithColumns(20))); EXPECT_EQ("/*\n" " * This is a long\n" " * comment that\n" " * doesn't fit on\n" " * one line\n" " */", format(" /*\n" " * This is a long comment that doesn't fit on one line\n" " */", getLLVMStyleWithColumns(20))); EXPECT_EQ("{\n" " if (something) /* This is a\n" " long\n" " comment */\n" " ;\n" "}", format("{\n" " if (something) /* This is a long comment */\n" " ;\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) { EXPECT_EQ("#define X \\\n" " /* \\\n" " Test \\\n" " Macro comment \\\n" " with a long \\\n" " line \\\n" " */ \\\n" " A + B", format("#define X \\\n" " /*\n" " Test\n" " Macro comment with a long line\n" " */ \\\n" " A + B", getLLVMStyleWithColumns(20))); EXPECT_EQ("#define X \\\n" " /* Macro comment \\\n" " with a long \\\n" " line */ \\\n" " A + B", format("#define X \\\n" " /* Macro comment with a long\n" " line */ \\\n" " A + B", getLLVMStyleWithColumns(20))); EXPECT_EQ("#define X \\\n" " /* Macro comment \\\n" " * with a long \\\n" " * line */ \\\n" " A + B", format("#define X \\\n" " /* Macro comment with a long line */ \\\n" " A + B", getLLVMStyleWithColumns(20))); } TEST_F(FormatTest, CommentsInStaticInitializers) { EXPECT_EQ( "static SomeType type = { aaaaaaaaaaaaaaaaaaaa, /* comment */\n" " aaaaaaaaaaaaaaaaaaaa /* comment */,\n" " /* comment */ aaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaa, // comment\n" " aaaaaaaaaaaaaaaaaaaa };", format("static SomeType type = { aaaaaaaaaaaaaaaaaaaa , /* comment */\n" " aaaaaaaaaaaaaaaaaaaa /* comment */ ,\n" " /* comment */ aaaaaaaaaaaaaaaaaaaa ,\n" " aaaaaaaaaaaaaaaaaaaa , // comment\n" " aaaaaaaaaaaaaaaaaaaa };")); verifyFormat("static SomeType type = { aaaaaaaaaaa, // comment for aa...\n" " bbbbbbbbbbb, ccccccccccc };"); verifyFormat("static SomeType type = { aaaaaaaaaaa,\n" " // 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};"); verifyFormat("S s = { { a, b, c }, // Group #1\n" " { d, e, f }, // Group #2\n" " { g, h, i } }; // Group #3"); verifyFormat("S s = { { // Group #1\n" " a, b, c },\n" " { // Group #2\n" " d, e, f },\n" " { // Group #3\n" " g, h, i } };"); 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" "}")); 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" " 0x00, 0x00, 0x00, 0x00 // comment\n" "};"); } 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 {};"); } TEST_F(FormatTest, UnderstandsAccessSpecifiers) { verifyFormat("class A {\n" "public:\n" "public: // comment\n" "protected:\n" "private:\n" " void f() {}\n" "};"); verifyGoogleFormat("class A {\n" " public:\n" " protected:\n" " private:\n" " void f() {}\n" "};"); } TEST_F(FormatTest, SeparatesLogicalBlocks) { EXPECT_EQ("class A {\n" "public:\n" " void f();\n" "\n" "private:\n" " void g() {}\n" " // test\n" "protected:\n" " int h;\n" "};", format("class A {\n" "public:\n" "void f();\n" "private:\n" "void g() {}\n" "// test\n" "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 {};"); verifyFormat("class A : public ::B {};"); verifyFormat( "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};"); verifyFormat( "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 {};"); verifyFormat("class\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) { verifyFormat("class A {\n} a, b;"); verifyFormat("struct A {\n} a, b;"); verifyFormat("union A {\n} a;"); } TEST_F(FormatTest, FormatsEnum) { verifyFormat("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" "};"); 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" "};"); } TEST_F(FormatTest, FormatsBitfields) { verifyFormat("struct Bitfields {\n" " 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" "void f() { f(); }\n" "}"); verifyFormat("namespace {\n" "class A {};\n" "void f() { f(); }\n" "}"); verifyFormat("inline namespace X {\n" "class A {};\n" "void f() { f(); }\n" "}"); verifyFormat("using namespace some_namespace;\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 {};"); verifyFormat("namespace {\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;"); } TEST_F(FormatTest, FormatsInlineASM) { verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); verifyFormat( "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\"(value));"); } TEST_F(FormatTest, FormatTryCatch) { // FIXME: Handle try-catch explicitly in the UnwrappedLineParser, then we'll // also not create single-line-blocks. verifyFormat("try {\n" " throw a * b;\n" "}\n" "catch (int a) {\n" " // Do nothing.\n" "}\n" "catch (...) {\n" " exit(42);\n" "}"); // Function-level try statements. verifyFormat("int f() try { return 4; }\n" "catch (...) {\n" " return 5;\n" "}"); verifyFormat("class A {\n" " int a;\n" " A() try : a(0) {}\n" " catch (...) {\n" " throw;\n" " }\n" "};\n"); } TEST_F(FormatTest, FormatObjCTryCatch) { verifyFormat("@@try {\n" " f();\n" "}\n" "@@catch (NSException e) {\n" " @@throw;\n" "}\n" "@@finally {\n" " exit(42);\n" "}"); } TEST_F(FormatTest, StaticInitializers) { verifyFormat("static SomeClass SC = { 1, 'a' };"); verifyFormat( "static SomeClass WithALoooooooooooooooooooongName = {\n" " 100000000, \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" "};"); // 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) { verifyFormat("static A x = { { {} } };\n"); verifyFormat("static A x = { { { init1, init2, init3, init4 },\n" " { init1, init2, init3, init4 } } };"); verifyFormat("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" " } };"); verifyFormat( "SomeArrayOfSomeType a = { { { 1, 2, 3 }, { 1, 2, 3 },\n" " { 111111111111111111111111111111,\n" " 222222222222222222222222222222,\n" " 333333333333333333333333333333 },\n" " { 1, 2, 3 }, { 1, 2, 3 } } };"); verifyFormat( "SomeArrayOfSomeType a = { { { 1, 2, 3 } }, { { 1, 2, 3 } },\n" " { { 111111111111111111111111111111,\n" " 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}}};"); verifyFormat( "struct {\n" " unsigned bit;\n" " const char *const name;\n" "} kBitsToOs[] = { { kOsMac, \"Mac\" },\n" " { kOsWin, \"Windows\" },\n" " { kOsLinux, \"Linux\" },\n" " { kOsCrOS, \"Chrome OS\" } };"); } TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" " \\\n" " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); } TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { verifyFormat("virtual void write(ELFWriter *writerrr,\n" " OwningPtr &buffer) = 0;"); } 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;"); } TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { EXPECT_EQ("#line 42 \"test\"\n", format("# \\\n line \\\n 42 \\\n \"test\"\n")); EXPECT_EQ("#define A B\n", format("# \\\n define \\\n A \\\n B\n", getLLVMStyleWithColumns(12))); } TEST_F(FormatTest, EndOfFileEndsPPDirective) { EXPECT_EQ("#line 42 \"test\"", format("# \\\n line \\\n 42 \\\n \"test\"")); 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 A A\n#define A A"); verifyFormat("#define A(X) A\n#define A A"); verifyFormat("#define Something Other", getLLVMStyleWithColumns(23)); verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22)); } TEST_F(FormatTest, HandlePreprocessorDirectiveContext) { EXPECT_EQ("// somecomment\n" "#include \"a.h\"\n" "#define A( \\\n" " A, B)\n" "#include \"b.h\"\n" "// somecomment\n", format(" // somecomment\n" " #include \"a.h\"\n" "#define A(A,\\\n" " B)\n" " #include \"b.h\"\n" " // somecomment\n", getLLVMStyleWithColumns(13))); } TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); } TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { EXPECT_EQ("#define A \\\n" " c; \\\n" " e;\n" "f;", format("#define A c; e;\n" "f;", getLLVMStyleWithColumns(14))); } TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); } 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) { EXPECT_EQ("int x,\n" "#define A\n" " y;", format("int x,\n#define A\ny;")); } 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" " }", getLLVMStyleWithColumns(11)); verifyFormat("#define A(X) \\\n" " void function##X()", getLLVMStyleWithColumns(22)); verifyFormat("#define A(a, b, c) \\\n" " void a##b##c()", getLLVMStyleWithColumns(22)); verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22)); } TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { verifyFormat("#define A (1)"); } TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { EXPECT_EQ("#define A b;", format("#define A \\\n" " \\\n" " b;", getLLVMStyleWithColumns(25))); EXPECT_EQ("#define A \\\n" " \\\n" " a; \\\n" " b;", format("#define A \\\n" " \\\n" " a; \\\n" " b;", getLLVMStyleWithColumns(11))); EXPECT_EQ("#define A \\\n" " a; \\\n" " \\\n" " b;", format("#define A \\\n" " a; \\\n" " \\\n" " b;", getLLVMStyleWithColumns(11))); } TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { verifyFormat("#define A :"); 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" "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" "int *createScopDetectionPass() { return 0; }", format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n" " INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n" " INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n" " class X {};\n" " INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n" " int *createScopDetectionPass() { return 0; }")); // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as // braces, so that inner block is indented one level more. EXPECT_EQ("int q() {\n" " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" " IPC_MESSAGE_HANDLER(xxx, qqq)\n" " IPC_END_MESSAGE_MAP()\n" "}", format("int q() {\n" " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" " 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" " f(x)->g();\n" " f(x)->*g();\n" " f(x).g();\n" " f(x) = x;\n" " f(x) += x;\n" " f(x) -= x;\n" " f(x) *= x;\n" " f(x) /= x;\n" " f(x) %= x;\n" " f(x) &= x;\n" " f(x) |= x;\n" " f(x) ^= x;\n" " f(x) >>= x;\n" " f(x) <<= x;\n" " f(x)[y].z();\n" " LOG(INFO) << x;\n" " ifstream(x) >> x;\n" "}\n", format("int q() {\n" " f(x)\n;\n" " f(x)\n {}\n" " f(x)\n->g();\n" " f(x)\n->*g();\n" " f(x)\n.g();\n" " f(x)\n = x;\n" " f(x)\n += x;\n" " f(x)\n -= x;\n" " f(x)\n *= x;\n" " f(x)\n /= x;\n" " f(x)\n %= x;\n" " f(x)\n &= x;\n" " f(x)\n |= x;\n" " f(x)\n ^= x;\n" " f(x)\n >>= x;\n" " f(x)\n <<= x;\n" " f(x)\n[y].z();\n" " LOG(INFO)\n << x;\n" " ifstream(x)\n >> x;\n" "}\n")); EXPECT_EQ("int q() {\n" " f(x)\n" " if (1) {\n" " }\n" " f(x)\n" " while (1) {\n" " }\n" " f(x)\n" " g(x);\n" " f(x)\n" " try {\n" " q();\n" " }\n" " catch (...) {\n" " }\n" "}\n", format("int q() {\n" "f(x)\n" "if (1) {}\n" "f(x)\n" "while (1) {}\n" "f(x)\n" "g(x);\n" "f(x)\n" "try { q(); } catch (...) {}\n" "}\n")); EXPECT_EQ("class A {\n" " A() : t(0) {}\n" " A(X x)\n" // FIXME: function-level try blocks are broken. " try : t(0) {\n" " }\n" " catch (...) {\n" " }\n" "};", format("class A {\n" " A()\n : t(0) {}\n" " A(X x)\n" " try : t(0) {} catch (...) {}\n" "};")); } 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}}")); } TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { verifyFormat("{\n { a #c; }\n}"); } TEST_F(FormatTest, FormatUnbalancedStructuralElements) { EXPECT_EQ("#define A \\\n { \\\n {\nint i;", format("#define A { {\nint i;", getLLVMStyleWithColumns(11))); EXPECT_EQ("#define A \\\n } \\\n }\nint i;", format("#define A } }\nint i;", getLLVMStyleWithColumns(11))); } 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) { verifyFormat("#define A \\\n" " int v( \\\n" " a); \\\n" " int i;", getLLVMStyleWithColumns(11)); } TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { EXPECT_EQ( "#define ALooooooooooooooooooooooooooooooooooooooongMacro(" " \\\n" " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" "\n" "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n", format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro(" "\\\n" "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" " \n" " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n")); } TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { EXPECT_EQ("int\n" "#define A\n" " a;", format("int\n#define A\na;", getGoogleStyle())); verifyFormat("functionCallTo(\n" " someOtherFunction(\n" " withSomeParameters, whichInSequence,\n" " areLongerThanALine(andAnotherCall,\n" "#define A B\n" " withMoreParamters,\n" " whichStronglyInfluenceTheLayout),\n" " 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 (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) { EXPECT_EQ("SOME_MACRO { int i; }\n" "int i;", format(" SOME_MACRO {int i;} int i;")); } TEST_F(FormatTest, LayoutNestedBlocks) { verifyFormat("void AddOsStrings(unsigned bitmask) {\n" " struct s {\n" " int i;\n" " };\n" " s kBitsToOs[] = { { 10 } };\n" " 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("{}")); verifyFormat("enum E {};"); verifyFormat("enum E {}"); } //===----------------------------------------------------------------------===// // Line break tests. //===----------------------------------------------------------------------===// 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]];"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n" " aaaaaaaaaaaaaaaaaaaaaaaa<\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n" " aaaaaaaaaaaaaaaaaaaaaaaa>;"); verifyFormat("int a = bbbb && ccc && fffff(\n" "#define A Just forcing a new line\n" " ddd);"); } 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}"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n" " 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) { verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}", getLLVMStyleWithColumns(45)); verifyFormat("Constructor()\n" " : Inttializer(FitsOnTheLine) {}", getLLVMStyleWithColumns(44)); verifyFormat("Constructor()\n" " : Inttializer(FitsOnTheLine) {}", getLLVMStyleWithColumns(43)); verifyFormat( "SomeClass::Constructor()\n" " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); verifyFormat( "SomeClass::Constructor()\n" " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}"); verifyFormat( "SomeClass::Constructor()\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}"); verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaaaa() {}"); verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); 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. verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaa(aaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); FormatStyle OnePerLine = getLLVMStyle(); OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; verifyFormat("SomeClass::Constructor()\n" " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", OnePerLine); verifyFormat("SomeClass::Constructor()\n" " : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", OnePerLine); verifyFormat("MyClass::MyClass(int var)\n" " : some_var_(var), // 4 space indent\n" " some_other_var_(var + 1) { // lined up\n" "}", OnePerLine); verifyFormat("Constructor()\n" " : aaaaa(aaaaaa),\n" " aaaaa(aaaaaa),\n" " aaaaa(aaaaaa),\n" " aaaaa(aaaaaa),\n" " aaaaa(aaaaaa) {}", OnePerLine); verifyFormat("Constructor()\n" " : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaa) {}", OnePerLine); } TEST_F(FormatTest, MemoizationTests) { // This breaks if the memoization lookup does not take \c Indent and // \c LastSpace into account. verifyFormat( "extern CFRunLoopTimerRef\n" "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n" " CFTimeInterval interval, CFOptionFlags flags,\n" " CFIndex order, CFRunLoopTimerCallBack callout,\n" " CFRunLoopTimerContext *context) {}"); // Deep nesting somewhat works around our memoization. verifyFormat( "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" " aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n" " 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(); OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true; OnePerLine.BinPackParameters = false; std::string input = "Constructor()\n" " : aaaa(a,\n"; for (unsigned i = 0, e = 80; i != e; ++i) { input += " a,\n"; } input += " a) {}"; verifyFormat(input, OnePerLine); } TEST_F(FormatTest, BreaksAsHighAsPossible) { verifyFormat( "void f() {\n" " if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n" " (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n" " f();\n" "}"); verifyFormat("if (Intervals[i].getRange().getFirst() <\n" " Intervals[i - 1].getRange().getLast()) {\n}"); } TEST_F(FormatTest, BreaksFunctionDeclarations) { // Principially, we break function declarations in a certain order: // 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( "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);", getGoogleStyle()); // 3) break after (. verifyFormat( "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);", getGoogleStyle()); // 4) break before after nested name specifiers. verifyFormat( "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " SomeClasssssssssssssssssssssssssssssssssssssss::\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);", getGoogleStyle()); // However, there are exceptions, if a sufficient amount of lines can be // saved. // FIXME: The precise cut-offs wrt. the number of saved lines might need some // more adjusting. verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc);"); verifyFormat( "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);", getGoogleStyle()); verifyFormat( "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc);"); verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); // Break after multi-line parameters. verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " 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) { verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n" " aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" "}"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); verifyFormat( "aaaaaaaa(aaaaaaaaaaaaa, aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));"); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( "void f() {\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" "}"); verifyFormat( "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); verifyFormat( "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));"); verifyFormat( "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. verifyFormat( "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" " aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n" " aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n" " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("{\n {\n {\n" " Annotation.SpaceRequiredBefore =\n" " 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) { FormatStyle NoBinPacking = getGoogleStyle(); NoBinPacking.BinPackParameters = false; verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);", NoBinPacking); verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n" " aaaaaaaaaaaaa,\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));", NoBinPacking); verifyFormat( "aaaaaaaa(aaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n" " aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));", NoBinPacking); verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" " .aaaaaaaaaaaaaaaaaa();", NoBinPacking); verifyFormat("void f() {\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n" "}", NoBinPacking); verifyFormat( "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaa,\n" " aaaaaaaaaaaa);", NoBinPacking); verifyFormat( "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n" " ddddddddddddddddddddddddddddd),\n" " test);", NoBinPacking); verifyFormat("std::vector aaaaaaaaaaaaaaaaaa;", NoBinPacking); verifyFormat("a(\"a\"\n" " \"a\",\n" " a);"); NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n" " aaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", NoBinPacking); verifyFormat( "void f() {\n" " aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n" " .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)\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->aaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); verifyFormat( "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n" " aaaaaaaaaaaaaa);"); verifyFormat( "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" "}"); verifyFormat( "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) { verifyFormat( "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" " ccccccccccccccccccccccccc) {\n}"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" " ccccccccccccccccccccccccc) {\n}"); verifyFormat( "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" " ccccccccccccccccccccccccc) {\n}"); verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" " aaaaaaaaaaaaaaa != aa) {\n}"); } TEST_F(FormatTest, BreaksAfterAssignments) { verifyFormat( "unsigned Cost =\n" " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" " SI->getPointerAddressSpaceee());\n"); verifyFormat( "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n" " Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());"); verifyFormat( "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) { verifyFormat( "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaa;"); } TEST_F(FormatTest, AlignsAfterReturn) { verifyFormat( "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" " aaaaaaaaaaaaaaaaaaaaaa();"); verifyFormat( "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n" " aaaaaaaaaaaaaaaaaaaaaa());"); verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 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, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n" " : aaaaaaaaaaaaa);"); verifyFormat( "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaa);"); verifyFormat( "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaa);"); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaa;"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaa;"); verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n" " aaaaaaaaa\n" " ? b\n" " : c);"); verifyFormat( "unsigned Indent =\n" " format(TheLine.First, IndentForLevel[TheLine.Level] >= 0\n" " ? IndentForLevel[TheLine.Level]\n" " : 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; verifyFormat( "void f() {\n" " g(aaa,\n" " aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaa\n" " : 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) { verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n" " aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();"); verifyFormat("bool a = true, b = false;"); verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n" " bbbbbbbbbbbbbbbbbbbbbbbbb =\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);"); verifyFormat( "bool aaaaaaaaaaaaaaaaaaaaa =\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n" " d = e && f;"); verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n" " c = cccccccccccccccccccc, d = dddddddddddddddddddd;"); verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" " *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;"); verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n" " ***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" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" " *b = bbbbbbbbbbbbbbbbbbb;", getGoogleStyle()); // Not ideal, but pointer-with-type does not allow much here. verifyGoogleFormat( "aaaaaaaaa* a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;"); } TEST_F(FormatTest, ConditionalExpressionsInBrackets) { verifyFormat("arr[foo ? bar : baz];"); verifyFormat("f()[foo ? bar : baz];"); verifyFormat("(a + b)[foo ? bar : baz];"); verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];"); } TEST_F(FormatTest, AlignsStringLiterals) { verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n" " \"short literal\");"); verifyFormat( "looooooooooooooooooooooooongFunction(\n" " \"short literal\"\n" " \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");"); verifyFormat("someFunction(\"Always break between multi-line\"\n" " \" string literals\",\n" " and, other, parameters);"); EXPECT_EQ("fun + \"1243\" /* comment */\n" " \"5678\";", format("fun + \"1243\" /* comment */\n" " \"5678\";", getLLVMStyleWithColumns(28))); EXPECT_EQ( "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" " \"aaaaaaaaaaaaaaaaaaaaa\"\n" " \"aaaaaaaaaaaaaaaa\";", format("aaaaaa =" "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa " "aaaaaaaaaaaaaaaaaaaaa\" " "\"aaaaaaaaaaaaaaaa\";")); 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) { verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" " << aaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); verifyFormat( "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " << 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" " << \"}\";"); verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n" " << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;"); verifyFormat( "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n" " << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n" " << \"ccccccccccccccccc = \" << ccccccccccccccccc\n" " << \"ddddddddddddddddd = \" << ddddddddddddddddd\n" " << \"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<looooooooooooooooooooooooooooooooooooooongFunction();"); verifyFormat( "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n" " Parameter2);"); verifyFormat( "ShortObject->shortFunction(\n" " LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n" " LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);"); verifyFormat("loooooooooooooongFunction(\n" " LoooooooooooooongObject->looooooooooooooooongFunction());"); verifyFormat( "function(LoooooooooooooooooooooooooooooooooooongObject\n" " ->loooooooooooooooooooooooooooooooooooooooongFunction());"); verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" " .WillRepeatedly(Return(SomeValue));"); verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)]\n" " .insert(ccccccccccccccccccccccc);"); verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).aaaaa(aaaaa),\n" " aaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("void f() {\n" " aaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n" "}"); verifyFormat( "aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa));"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n" "}"); // Here, it is not necessary to wrap at "." or "->". verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n" " aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); verifyFormat( "aaaaaaaaaaa->aaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());"); verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n" " aaaaaaaaa()->aaaaaa()->aaaaa());"); verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n" " aaaaaaaaa()->aaaaaa()->aaaaa());"); // FIXME: Should we break before .a()? verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa).a();"); FormatStyle NoBinPacking = getLLVMStyle(); NoBinPacking.BinPackParameters = false; verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" " .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n" " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n" " 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;"); verifyFormat("template \n" "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n" " int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);"); verifyFormat( "template \n" "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n" " int Paaaaaaaaaaaaaaaaaaaaram2);"); verifyFormat( "template \n" "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("template \n" "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " int aaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( "template \n" "void f();"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 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