//===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #include "FormatTestBase.h" #define DEBUG_TYPE "format-test" namespace clang { namespace format { namespace test { namespace { class FormatTest : public test::FormatTestBase {}; TEST_F(FormatTest, MessUp) { EXPECT_EQ("1 2 3", messUp("1 2 3")); EXPECT_EQ("1 2 3", messUp("1\n2\n3")); 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")); } TEST_F(FormatTest, DefaultLLVMStyleIsCpp) { EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language); } TEST_F(FormatTest, LLVMStyleOverride) { EXPECT_EQ(FormatStyle::LK_Proto, getLLVMStyle(FormatStyle::LK_Proto).Language); } //===----------------------------------------------------------------------===// // Basic function tests. //===----------------------------------------------------------------------===// TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { verifyFormat(";"); } TEST_F(FormatTest, FormatsGlobalStatementsAt0) { verifyFormat("int i;", " int i;"); verifyFormat("\nint i;", " \n\t \v \f int i;"); verifyFormat("int i;\nint j;", " int i; int j;"); verifyFormat("int i;\nint j;", " int i;\n int j;"); auto Style = getLLVMStyle(); Style.KeepEmptyLines.AtStartOfFile = false; verifyFormat("int i;", " \n\t \v \f int i;", Style); } TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) { verifyFormat("int i;", "int\ni;"); } TEST_F(FormatTest, FormatsNestedBlockStatements) { verifyFormat("{\n" " {\n" " {\n" " }\n" " }\n" "}", "{{{}}}"); } 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;"); verifyFormat("static constexpr bool Bar = typeof(bar())::value;"); verifyFormat("static constexpr bool Bar = __underlying_type(bar())::value;"); verifyFormat("static constexpr bool Bar = _Atomic(bar())::value;"); verifyFormat("bool a = 2 < ::SomeFunction();"); verifyFormat("ALWAYS_INLINE ::std::string getName();"); verifyFormat("some::string getName();"); } TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) { verifyFormat("if (a) {\n" " f();\n" "}", "if(a){f();}"); EXPECT_EQ(4, ReplacementCount); verifyNoChange("if (a) {\n" " f();\n" "}"); EXPECT_EQ(0, ReplacementCount); verifyNoChange("/*\r\n" "\r\n" "*/"); EXPECT_EQ(0, ReplacementCount); } TEST_F(FormatTest, RemovesEmptyLines) { verifyFormat("class C {\n" " int i;\n" "};", "class C {\n" " int i;\n" "\n" "};"); // Don't remove empty lines at the start of namespaces or extern "C" blocks. verifyFormat("namespace N {\n" "\n" "int i;\n" "}", "namespace N {\n" "\n" "int i;\n" "}", getGoogleStyle()); verifyFormat("/* something */ namespace N {\n" "\n" "int i;\n" "}", "/* something */ namespace N {\n" "\n" "int i;\n" "}", getGoogleStyle()); verifyFormat("inline namespace N {\n" "\n" "int i;\n" "}", "inline namespace N {\n" "\n" "int i;\n" "}", getGoogleStyle()); verifyFormat("/* something */ inline namespace N {\n" "\n" "int i;\n" "}", "/* something */ inline namespace N {\n" "\n" "int i;\n" "}", getGoogleStyle()); verifyFormat("export namespace N {\n" "\n" "int i;\n" "}", "export namespace N {\n" "\n" "int i;\n" "}", getGoogleStyle()); verifyFormat("extern /**/ \"C\" /**/ {\n" "\n" "int i;\n" "}", "extern /**/ \"C\" /**/ {\n" "\n" "int i;\n" "}", getGoogleStyle()); auto CustomStyle = getLLVMStyle(); CustomStyle.BreakBeforeBraces = FormatStyle::BS_Custom; CustomStyle.BraceWrapping.AfterNamespace = true; CustomStyle.KeepEmptyLines.AtStartOfBlock = false; verifyFormat("namespace N\n" "{\n" "\n" "int i;\n" "}", "namespace N\n" "{\n" "\n" "\n" "int i;\n" "}", CustomStyle); verifyFormat("/* something */ namespace N\n" "{\n" "\n" "int i;\n" "}", "/* something */ namespace N {\n" "\n" "\n" "int i;\n" "}", CustomStyle); verifyFormat("inline namespace N\n" "{\n" "\n" "int i;\n" "}", "inline namespace N\n" "{\n" "\n" "\n" "int i;\n" "}", CustomStyle); verifyFormat("/* something */ inline namespace N\n" "{\n" "\n" "int i;\n" "}", "/* something */ inline namespace N\n" "{\n" "\n" "int i;\n" "}", CustomStyle); verifyFormat("export namespace N\n" "{\n" "\n" "int i;\n" "}", "export namespace N\n" "{\n" "\n" "int i;\n" "}", CustomStyle); verifyFormat("namespace a\n" "{\n" "namespace b\n" "{\n" "\n" "class AA {};\n" "\n" "} // namespace b\n" "} // namespace a", "namespace a\n" "{\n" "namespace b\n" "{\n" "\n" "\n" "class AA {};\n" "\n" "\n" "}\n" "}", CustomStyle); verifyFormat("namespace A /* comment */\n" "{\n" "class B {}\n" "} // namespace A", "namespace A /* comment */ { class B {} }", CustomStyle); verifyFormat("namespace A\n" "{ /* comment */\n" "class B {}\n" "} // namespace A", "namespace A {/* comment */ class B {} }", CustomStyle); verifyFormat("namespace A\n" "{ /* comment */\n" "\n" "class B {}\n" "\n" "" "} // namespace A", "namespace A { /* comment */\n" "\n" "\n" "class B {}\n" "\n" "\n" "}", CustomStyle); verifyFormat("namespace A /* comment */\n" "{\n" "\n" "class B {}\n" "\n" "} // namespace A", "namespace A/* comment */ {\n" "\n" "\n" "class B {}\n" "\n" "\n" "}", CustomStyle); // ...but do keep inlining and removing empty lines for non-block extern "C" // functions. verifyGoogleFormat("extern \"C\" int f() { return 42; }"); verifyFormat("extern \"C\" int f() {\n" " int i = 42;\n" " return i;\n" "}", "extern \"C\" int f() {\n" "\n" " int i = 42;\n" " return i;\n" "}", getGoogleStyle()); // Remove empty lines at the beginning and end of blocks. verifyFormat("void f() {\n" "\n" " if (a) {\n" "\n" " f();\n" " }\n" "}", "void f() {\n" "\n" " if (a) {\n" "\n" " f();\n" "\n" " }\n" "\n" "}"); verifyFormat("void f() {\n" " if (a) {\n" " f();\n" " }\n" "}", "void f() {\n" "\n" " if (a) {\n" "\n" " f();\n" "\n" " }\n" "\n" "}", getGoogleStyle()); // Don't remove empty lines in more complex control statements. verifyFormat("void f() {\n" " if (a) {\n" " f();\n" "\n" " } else if (b) {\n" " f();\n" " }\n" "}", "void f() {\n" " if (a) {\n" " f();\n" "\n" " } else if (b) {\n" " f();\n" "\n" " }\n" "\n" "}"); // Don't remove empty lines before namespace endings. FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); LLVMWithNoNamespaceFix.FixNamespaceComments = false; verifyNoChange("namespace {\n" "int i;\n" "\n" "}", LLVMWithNoNamespaceFix); verifyFormat("namespace {\n" "int i;\n" "}", LLVMWithNoNamespaceFix); verifyNoChange("namespace {\n" "int i;\n" "\n" "};", LLVMWithNoNamespaceFix); verifyFormat("namespace {\n" "int i;\n" "};", LLVMWithNoNamespaceFix); verifyNoChange("namespace {\n" "int i;\n" "\n" "}"); verifyFormat("namespace {\n" "int i;\n" "\n" "} // namespace", "namespace {\n" "int i;\n" "\n" "} // namespace"); FormatStyle Style = getLLVMStyle(); Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; Style.MaxEmptyLinesToKeep = 2; Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterClass = true; Style.BraceWrapping.AfterFunction = true; Style.KeepEmptyLines.AtStartOfBlock = false; verifyFormat("class Foo\n" "{\n" " Foo() {}\n" "\n" " void funk() {}\n" "};", "class Foo\n" "{\n" " Foo()\n" " {\n" " }\n" "\n" " void funk() {}\n" "};", Style); } TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) { verifyFormat("x = (a) and (b);"); verifyFormat("x = (a) or (b);"); verifyFormat("x = (a) bitand (b);"); verifyFormat("x = (a) bitor (b);"); verifyFormat("x = (a) not_eq (b);"); verifyFormat("x = (a) and_eq (b);"); verifyFormat("x = (a) or_eq (b);"); verifyFormat("x = (a) xor (b);"); } TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) { verifyFormat("x = compl(a);"); verifyFormat("x = not(a);"); verifyFormat("x = bitand(a);"); // Unary operator must not be merged with the next identifier verifyFormat("x = compl a;"); verifyFormat("x = not a;"); verifyFormat("x = bitand a;"); } //===----------------------------------------------------------------------===// // 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();"); verifyFormat("if constexpr (true)\n" " f();\ng();"); verifyFormat("if CONSTEXPR (true)\n" " f();\ng();"); verifyFormat("if constexpr (a)\n" " if constexpr (b)\n" " if constexpr (c)\n" " g();\n" "h();"); verifyFormat("if CONSTEXPR (a)\n" " if CONSTEXPR (b)\n" " if CONSTEXPR (c)\n" " g();\n" "h();"); verifyFormat("if constexpr (a)\n" " if constexpr (b) {\n" " f();\n" " }\n" "g();"); verifyFormat("if CONSTEXPR (a)\n" " if CONSTEXPR (b) {\n" " f();\n" " }\n" "g();"); verifyFormat("if consteval {\n}"); verifyFormat("if !consteval {\n}"); verifyFormat("if not consteval {\n}"); verifyFormat("if consteval {\n} else {\n}"); verifyFormat("if !consteval {\n} else {\n}"); verifyFormat("if consteval {\n" " f();\n" "}"); verifyFormat("if !consteval {\n" " f();\n" "}"); verifyFormat("if consteval {\n" " f();\n" "} else {\n" " g();\n" "}"); verifyFormat("if CONSTEVAL {\n" " f();\n" "}"); verifyFormat("if !CONSTEVAL {\n" " f();\n" "}"); verifyFormat("if (a)\n" " g();"); verifyFormat("if (a) {\n" " g()\n" "};"); verifyFormat("if (a)\n" " g();\n" "else\n" " g();"); verifyFormat("if (a) {\n" " g();\n" "} else\n" " g();"); verifyFormat("if (a)\n" " g();\n" "else {\n" " g();\n" "}"); verifyFormat("if (a) {\n" " g();\n" "} else {\n" " g();\n" "}"); verifyFormat("if (a)\n" " g();\n" "else if (b)\n" " g();\n" "else\n" " g();"); verifyFormat("if (a) {\n" " g();\n" "} else if (b)\n" " g();\n" "else\n" " g();"); verifyFormat("if (a)\n" " g();\n" "else if (b) {\n" " g();\n" "} else\n" " g();"); verifyFormat("if (a)\n" " g();\n" "else if (b)\n" " g();\n" "else {\n" " g();\n" "}"); verifyFormat("if (a)\n" " g();\n" "else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}"); verifyFormat("if (a) {\n" " g();\n" "} else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}"); FormatStyle AllowsMergedIf = getLLVMStyle(); AllowsMergedIf.IfMacros.push_back("MYIF"); AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; verifyFormat("if (a)\n" " // comment\n" " f();", AllowsMergedIf); verifyFormat("{\n" " if (a)\n" " label:\n" " f();\n" "}", AllowsMergedIf); verifyFormat("#define A \\\n" " if (a) \\\n" " label: \\\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();", 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); verifyFormat("MYIF (a)\n" " // comment\n" " f();", AllowsMergedIf); verifyFormat("{\n" " MYIF (a)\n" " label:\n" " f();\n" "}", AllowsMergedIf); verifyFormat("#define A \\\n" " MYIF (a) \\\n" " label: \\\n" " f()", AllowsMergedIf); verifyFormat("MYIF (a)\n" " ;", AllowsMergedIf); verifyFormat("MYIF (a)\n" " MYIF (b) return;", AllowsMergedIf); verifyFormat("MYIF (a) // Can't merge this\n" " f();", AllowsMergedIf); verifyFormat("MYIF (a) /* still don't merge */\n" " f();", AllowsMergedIf); verifyFormat("MYIF (a) { // Never merge this\n" " f();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) { /* Never merge this */\n" " f();\n" "}", AllowsMergedIf); AllowsMergedIf.ColumnLimit = 14; // Where line-lengths matter, a 2-letter synonym that maintains line length. // Not IF to avoid any confusion that IF is somehow special. AllowsMergedIf.IfMacros.push_back("FI"); verifyFormat("if (a) return;", AllowsMergedIf); verifyFormat("if (aaaaaaaaa)\n" " return;", AllowsMergedIf); verifyFormat("FI (a) return;", AllowsMergedIf); verifyFormat("FI (aaaaaaaaa)\n" " return;", AllowsMergedIf); AllowsMergedIf.ColumnLimit = 13; verifyFormat("if (a)\n return;", AllowsMergedIf); verifyFormat("FI (a)\n return;", AllowsMergedIf); FormatStyle AllowsMergedIfElse = getLLVMStyle(); AllowsMergedIfElse.IfMacros.push_back("MYIF"); AllowsMergedIfElse.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_AllIfsAndElse; verifyFormat("if (a)\n" " // comment\n" " f();\n" "else\n" " // comment\n" " f();", AllowsMergedIfElse); verifyFormat("{\n" " if (a)\n" " label:\n" " f();\n" " else\n" " label:\n" " f();\n" "}", AllowsMergedIfElse); verifyFormat("if (a)\n" " ;\n" "else\n" " ;", AllowsMergedIfElse); verifyFormat("if (a) {\n" "} else {\n" "}", AllowsMergedIfElse); verifyFormat("if (a) return;\n" "else if (b) return;\n" "else return;", AllowsMergedIfElse); verifyFormat("if (a) {\n" "} else return;", AllowsMergedIfElse); verifyFormat("if (a) {\n" "} else if (b) return;\n" "else return;", AllowsMergedIfElse); verifyFormat("if (a) return;\n" "else if (b) {\n" "} else return;", AllowsMergedIfElse); verifyFormat("if (a)\n" " if (b) return;\n" " else return;", AllowsMergedIfElse); verifyFormat("if constexpr (a)\n" " if constexpr (b) return;\n" " else if constexpr (c) return;\n" " else return;", AllowsMergedIfElse); verifyFormat("MYIF (a)\n" " // comment\n" " f();\n" "else\n" " // comment\n" " f();", AllowsMergedIfElse); verifyFormat("{\n" " MYIF (a)\n" " label:\n" " f();\n" " else\n" " label:\n" " f();\n" "}", AllowsMergedIfElse); verifyFormat("MYIF (a)\n" " ;\n" "else\n" " ;", AllowsMergedIfElse); verifyFormat("MYIF (a) {\n" "} else {\n" "}", AllowsMergedIfElse); verifyFormat("MYIF (a) return;\n" "else MYIF (b) return;\n" "else return;", AllowsMergedIfElse); verifyFormat("MYIF (a) {\n" "} else return;", AllowsMergedIfElse); verifyFormat("MYIF (a) {\n" "} else MYIF (b) return;\n" "else return;", AllowsMergedIfElse); verifyFormat("MYIF (a) return;\n" "else MYIF (b) {\n" "} else return;", AllowsMergedIfElse); verifyFormat("MYIF (a)\n" " MYIF (b) return;\n" " else return;", AllowsMergedIfElse); verifyFormat("MYIF constexpr (a)\n" " MYIF constexpr (b) return;\n" " else MYIF constexpr (c) return;\n" " else return;", AllowsMergedIfElse); } TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) { FormatStyle AllowsMergedIf = getLLVMStyle(); AllowsMergedIf.IfMacros.push_back("MYIF"); AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left; AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; verifyFormat("if (a)\n" " f();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a)\n" " f();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("if (a) g();", AllowsMergedIf); verifyFormat("if (a) {\n" " g()\n" "};", AllowsMergedIf); verifyFormat("if (a)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else\n" " g();", AllowsMergedIf); verifyFormat("if (a)\n" " g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a)\n" " g();\n" "else if (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else if (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("if (a)\n" " g();\n" "else if (b) {\n" " g();\n" "} else\n" " g();", AllowsMergedIf); verifyFormat("if (a)\n" " g();\n" "else if (b)\n" " g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a)\n" " g();\n" "else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a)\n" " f();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a)\n" " f();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g()\n" "};", AllowsMergedIf); verifyFormat("MYIF (a)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a)\n" " g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a)\n" " g();\n" "else MYIF (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a)\n" " g();\n" "else if (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else MYIF (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else if (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a)\n" " g();\n" "else MYIF (b) {\n" " g();\n" "} else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a)\n" " g();\n" "else if (b) {\n" " g();\n" "} else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a)\n" " g();\n" "else MYIF (b)\n" " g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a)\n" " g();\n" "else if (b)\n" " g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a)\n" " g();\n" "else MYIF (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a)\n" " g();\n" "else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else MYIF (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_OnlyFirstIf; verifyFormat("if (a) f();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) f();\n" "else {\n" " if (a) f();\n" " else {\n" " g();\n" " }\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) g();", AllowsMergedIf); verifyFormat("if (a) {\n" " g()\n" "};", AllowsMergedIf); verifyFormat("if (a) g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else\n" " g();", AllowsMergedIf); verifyFormat("if (a) g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) g();\n" "else if (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else if (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("if (a) g();\n" "else if (b) {\n" " g();\n" "} else\n" " g();", AllowsMergedIf); verifyFormat("if (a) g();\n" "else if (b)\n" " g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) g();\n" "else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) f();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) f();\n" "else {\n" " if (a) f();\n" " else {\n" " g();\n" " }\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g()\n" "};", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else MYIF (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else if (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else MYIF (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else if (b)\n" " g();\n" "else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else MYIF (b) {\n" " g();\n" "} else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else if (b) {\n" " g();\n" "} else\n" " g();", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else MYIF (b)\n" " g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else if (b)\n" " g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else MYIF (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else MYIF (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_AllIfsAndElse; verifyFormat("if (a) f();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) f();\n" "else {\n" " if (a) f();\n" " else {\n" " g();\n" " }\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) g();", AllowsMergedIf); verifyFormat("if (a) {\n" " g()\n" "};", AllowsMergedIf); verifyFormat("if (a) g();\n" "else g();", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else g();", AllowsMergedIf); verifyFormat("if (a) g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) g();\n" "else if (b) g();\n" "else g();", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else if (b) g();\n" "else g();", AllowsMergedIf); verifyFormat("if (a) g();\n" "else if (b) {\n" " g();\n" "} else g();", AllowsMergedIf); verifyFormat("if (a) g();\n" "else if (b) g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) g();\n" "else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("if (a) {\n" " g();\n" "} else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) f();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) f();\n" "else {\n" " if (a) f();\n" " else {\n" " g();\n" " }\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g()\n" "};", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else g();", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else MYIF (b) g();\n" "else g();", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else if (b) g();\n" "else g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else MYIF (b) g();\n" "else g();", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else if (b) g();\n" "else g();", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else MYIF (b) {\n" " g();\n" "} else g();", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else if (b) {\n" " g();\n" "} else g();", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else MYIF (b) g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else if (b) g();\n" "else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else MYIF (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) g();\n" "else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else MYIF (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); verifyFormat("MYIF (a) {\n" " g();\n" "} else if (b) {\n" " g();\n" "} else {\n" " g();\n" "}", AllowsMergedIf); } TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) { verifyFormat("while (true)\n" " ;"); verifyFormat("for (;;)\n" " ;"); FormatStyle AllowsMergedLoops = getLLVMStyle(); AllowsMergedLoops.AllowShortLoopsOnASingleLine = true; verifyFormat("while (true) continue;", AllowsMergedLoops); verifyFormat("for (;;) continue;", AllowsMergedLoops); verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops); verifyFormat("BOOST_FOREACH (int &v, vec) v *= 2;", AllowsMergedLoops); verifyFormat("while (true);", AllowsMergedLoops); verifyFormat("for (;;);", AllowsMergedLoops); verifyFormat("for (;;)\n" " for (;;) continue;", AllowsMergedLoops); verifyFormat("for (;;)\n" " while (true) continue;", AllowsMergedLoops); verifyFormat("while (true)\n" " for (;;) continue;", AllowsMergedLoops); verifyFormat("BOOST_FOREACH (int &v, vec)\n" " for (;;) continue;", AllowsMergedLoops); verifyFormat("for (;;)\n" " BOOST_FOREACH (int &v, vec) continue;", AllowsMergedLoops); verifyFormat("for (;;) // Can't merge this\n" " continue;", AllowsMergedLoops); verifyFormat("for (;;) /* still don't merge */\n" " continue;", AllowsMergedLoops); verifyFormat("do a++;\n" "while (true);", AllowsMergedLoops); verifyFormat("do /* Don't merge */\n" " a++;\n" "while (true);", AllowsMergedLoops); verifyFormat("do // Don't merge\n" " a++;\n" "while (true);", AllowsMergedLoops); verifyFormat("do\n" " // Don't merge\n" " a++;\n" "while (true);", AllowsMergedLoops); // Without braces labels are interpreted differently. verifyFormat("{\n" " do\n" " label:\n" " a++;\n" " while (true);\n" "}", AllowsMergedLoops); // Don't merge if there are comments before the null statement. verifyFormat("while (1) //\n" " ;", AllowsMergedLoops); verifyFormat("for (;;) /**/\n" " ;", AllowsMergedLoops); verifyFormat("while (true) /**/\n" " ;", "while (true) /**/;", AllowsMergedLoops); } TEST_F(FormatTest, FormatShortBracedStatements) { FormatStyle AllowSimpleBracedStatements = getLLVMStyle(); EXPECT_EQ(AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine, false); EXPECT_EQ(AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never); EXPECT_EQ(AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine, false); EXPECT_EQ(AllowSimpleBracedStatements.BraceWrapping.AfterFunction, false); verifyFormat("for (;;) {\n" " f();\n" "}"); verifyFormat("/*comment*/ for (;;) {\n" " f();\n" "}"); verifyFormat("BOOST_FOREACH (int v, vec) {\n" " f();\n" "}"); verifyFormat("/*comment*/ BOOST_FOREACH (int v, vec) {\n" " f();\n" "}"); verifyFormat("while (true) {\n" " f();\n" "}"); verifyFormat("/*comment*/ while (true) {\n" " f();\n" "}"); verifyFormat("if (true) {\n" " f();\n" "}"); verifyFormat("/*comment*/ if (true) {\n" " f();\n" "}"); AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; verifyFormat("if (true) {}", AllowSimpleBracedStatements); verifyFormat("if (i) break;", AllowSimpleBracedStatements); verifyFormat("if (i > 0) {\n" " return i;\n" "}", AllowSimpleBracedStatements); AllowSimpleBracedStatements.IfMacros.push_back("MYIF"); // Where line-lengths matter, a 2-letter synonym that maintains line length. // Not IF to avoid any confusion that IF is somehow special. AllowSimpleBracedStatements.IfMacros.push_back("FI"); AllowSimpleBracedStatements.ColumnLimit = 40; AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom; AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true; AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false; verifyFormat("if (true) {}", AllowSimpleBracedStatements); verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); verifyFormat("if consteval {}", AllowSimpleBracedStatements); verifyFormat("if !consteval {}", AllowSimpleBracedStatements); verifyFormat("if CONSTEVAL {}", AllowSimpleBracedStatements); verifyFormat("MYIF (true) {}", AllowSimpleBracedStatements); verifyFormat("MYIF constexpr (true) {}", AllowSimpleBracedStatements); verifyFormat("MYIF CONSTEXPR (true) {}", AllowSimpleBracedStatements); verifyFormat("while (true) {}", AllowSimpleBracedStatements); verifyFormat("for (;;) {}", AllowSimpleBracedStatements); verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("if consteval { f(); }", AllowSimpleBracedStatements); verifyFormat("if CONSTEVAL { f(); }", AllowSimpleBracedStatements); verifyFormat("MYIF (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("MYIF constexpr (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("MYIF CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("MYIF consteval { f(); }", AllowSimpleBracedStatements); verifyFormat("MYIF CONSTEVAL { f(); }", AllowSimpleBracedStatements); verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); verifyFormat("if (true) { fffffffffffffffffffffff(); }", AllowSimpleBracedStatements); verifyFormat("if (true) {\n" " ffffffffffffffffffffffff();\n" "}", AllowSimpleBracedStatements); verifyFormat("if (true) {\n" " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" "}", AllowSimpleBracedStatements); verifyFormat("if (true) { //\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("if (true) {\n" " f();\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("if (true) {\n" " f();\n" "} else {\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("FI (true) { fffffffffffffffffffffff(); }", AllowSimpleBracedStatements); verifyFormat("MYIF (true) {\n" " ffffffffffffffffffffffff();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true) {\n" " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true) { //\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true) {\n" " f();\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true) {\n" " f();\n" "} else {\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("struct A2 {\n" " int X;\n" "};", AllowSimpleBracedStatements); verifyFormat("typedef struct A2 {\n" " int X;\n" "} A2_t;", AllowSimpleBracedStatements); verifyFormat("template struct A2 {\n" " struct B {};\n" "};", AllowSimpleBracedStatements); AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never; verifyFormat("if (true) {}", AllowSimpleBracedStatements); verifyFormat("if (true) {\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("if (true) {\n" " f();\n" "} else {\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true) {}", AllowSimpleBracedStatements); verifyFormat("MYIF (true) {\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true) {\n" " f();\n" "} else {\n" " f();\n" "}", AllowSimpleBracedStatements); AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; verifyFormat("while (true) {}", AllowSimpleBracedStatements); verifyFormat("while (true) {\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("for (;;) {}", AllowSimpleBracedStatements); verifyFormat("for (;;) {\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("BOOST_FOREACH (int v, vec) {}", AllowSimpleBracedStatements); verifyFormat("BOOST_FOREACH (int v, vec) {\n" " f();\n" "}", AllowSimpleBracedStatements); AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true; AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; verifyFormat("if (true) {}", AllowSimpleBracedStatements); verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements); verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements); verifyFormat("MYIF (true) {}", AllowSimpleBracedStatements); verifyFormat("MYIF constexpr (true) {}", AllowSimpleBracedStatements); verifyFormat("MYIF CONSTEXPR (true) {}", AllowSimpleBracedStatements); verifyFormat("while (true) {}", AllowSimpleBracedStatements); verifyFormat("for (;;) {}", AllowSimpleBracedStatements); verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("MYIF (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("MYIF constexpr (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("MYIF CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements); verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements); verifyFormat("if (true) { fffffffffffffffffffffff(); }", AllowSimpleBracedStatements); verifyFormat("if (true)\n" "{\n" " ffffffffffffffffffffffff();\n" "}", AllowSimpleBracedStatements); verifyFormat("if (true)\n" "{\n" " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" "}", AllowSimpleBracedStatements); verifyFormat("if (true)\n" "{ //\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("if (true)\n" "{\n" " f();\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("if (true)\n" "{\n" " f();\n" "} else\n" "{\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("FI (true) { fffffffffffffffffffffff(); }", AllowSimpleBracedStatements); verifyFormat("MYIF (true)\n" "{\n" " ffffffffffffffffffffffff();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true)\n" "{\n" " ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true)\n" "{ //\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true)\n" "{\n" " f();\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true)\n" "{\n" " f();\n" "} else\n" "{\n" " f();\n" "}", AllowSimpleBracedStatements); AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never; verifyFormat("if (true) {}", AllowSimpleBracedStatements); verifyFormat("if (true)\n" "{\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("if (true)\n" "{\n" " f();\n" "} else\n" "{\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true) {}", AllowSimpleBracedStatements); verifyFormat("MYIF (true)\n" "{\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("MYIF (true)\n" "{\n" " f();\n" "} else\n" "{\n" " f();\n" "}", AllowSimpleBracedStatements); AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false; verifyFormat("while (true) {}", AllowSimpleBracedStatements); verifyFormat("while (true)\n" "{\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("for (;;) {}", AllowSimpleBracedStatements); verifyFormat("for (;;)\n" "{\n" " f();\n" "}", AllowSimpleBracedStatements); verifyFormat("BOOST_FOREACH (int v, vec) {}", AllowSimpleBracedStatements); verifyFormat("BOOST_FOREACH (int v, vec)\n" "{\n" " f();\n" "}", AllowSimpleBracedStatements); FormatStyle Style = getLLVMStyle(); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; verifyFormat("while (i > 0)\n" "{\n" " --i;\n" "}", Style); verifyFormat("if (a)\n" "{\n" " ++b;\n" "}", Style); verifyFormat("if (a)\n" "{\n" " b = 1;\n" "} else\n" "{\n" " b = 0;\n" "}", Style); verifyFormat("if (a)\n" "{\n" " b = 1;\n" "} else if (c)\n" "{\n" " b = 2;\n" "} else\n" "{\n" " b = 0;\n" "}", Style); Style.BraceWrapping.BeforeElse = true; verifyFormat("if (a)\n" "{\n" " b = 1;\n" "}\n" "else\n" "{\n" " b = 0;\n" "}", Style); verifyFormat("if (a)\n" "{\n" " b = 1;\n" "}\n" "else if (c)\n" "{\n" " b = 2;\n" "}\n" "else\n" "{\n" " b = 0;\n" "}", Style); } TEST_F(FormatTest, UnderstandsMacros) { verifyFormat("#define A (parentheses)"); verifyFormat("/* comment */ #define A (parentheses)"); verifyFormat("/* comment */ /* another comment */ #define A (parentheses)"); // Even the partial code should never be merged. verifyNoChange("/* comment */ #define A (parentheses)\n" "#"); verifyFormat("/* comment */ #define A (parentheses)\n" "#\n"); verifyFormat("/* comment */ #define A (parentheses)\n" "#define B (parentheses)"); verifyFormat("#define true ((int)1)"); verifyFormat("#define and(x)"); verifyFormat("#define if(x) x"); verifyFormat("#define return(x) (x)"); verifyFormat("#define while(x) for (; x;)"); verifyFormat("#define xor(x) (^(x))"); verifyFormat("#define __except(x)"); verifyFormat("#define __try(x)"); // https://llvm.org/PR54348. verifyFormat( "#define A" " " "\\\n" " class & {}"); FormatStyle Style = getLLVMStyle(); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterFunction = true; // Test that a macro definition never gets merged with the following // definition. // FIXME: The AAA macro definition probably should not be split into 3 lines. verifyFormat("#define AAA " " \\\n" " N " " \\\n" " {\n" "#define BBB }", Style); // verifyFormat("#define AAA N { //", Style); verifyFormat("MACRO(return)"); verifyFormat("MACRO(co_await)"); verifyFormat("MACRO(co_return)"); verifyFormat("MACRO(co_yield)"); verifyFormat("MACRO(return, something)"); verifyFormat("MACRO(co_return, something)"); verifyFormat("MACRO(something##something)"); verifyFormat("MACRO(return##something)"); verifyFormat("MACRO(co_return##something)"); verifyFormat("#define A x:"); verifyFormat("#define Foo(Bar) {#Bar}", "#define Foo(Bar) \\\n" " { \\\n" " #Bar \\\n" " }"); verifyFormat("#define Foo(Bar) {#Bar}", "#define Foo(Bar) \\\n" " { #Bar }"); } TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) { FormatStyle Style = getLLVMStyleWithColumns(60); Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; Style.BreakBeforeBraces = FormatStyle::BS_Allman; verifyFormat("#define A \\\n" " if (HANDLEwernufrnuLwrmviferuvnierv) \\\n" " { \\\n" " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" " }\n" "X;", "#define A \\\n" " if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n" " RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n" " }\n" "X;", Style); } 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("if (true)\n" " if constexpr (true)\n" " if (true) {\n" " if constexpr (true)\n" " f();\n" " } else {\n" " g();\n" " }\n" " else\n" " h();\n" "else {\n" " i();\n" "}"); verifyFormat("if (true)\n" " if CONSTEXPR (true)\n" " if (true) {\n" " if CONSTEXPR (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" "else // comment\n" " if (b) {\n" " g();\n" " h();\n" " }"); verifyFormat("if constexpr (a)\n" " f();\n" "else if constexpr (b)\n" " g();\n" "else\n" " h();"); verifyFormat("if CONSTEXPR (a)\n" " f();\n" "else if CONSTEXPR (b)\n" " g();\n" "else\n" " h();"); verifyFormat("if (a) {\n" " f();\n" "}\n" "// or else ..\n" "else {\n" " g()\n" "}"); verifyFormat("if (a) {\n" "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" "}"); verifyFormat("if (a) {\n" "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" "}"); verifyFormat("if (a) {\n" "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n" "}"); verifyFormat("if (a) {\n" "} else if (\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" "}", getLLVMStyleWithColumns(62)); verifyFormat("if (a) {\n" "} else if constexpr (\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" "}", getLLVMStyleWithColumns(62)); verifyFormat("if (a) {\n" "} else if CONSTEXPR (\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" "}", getLLVMStyleWithColumns(62)); } TEST_F(FormatTest, SeparatePointerReferenceAlignment) { FormatStyle Style = getLLVMStyle(); EXPECT_EQ(Style.PointerAlignment, FormatStyle::PAS_Right); EXPECT_EQ(Style.ReferenceAlignment, FormatStyle::RAS_Pointer); verifyFormat("int *f1(int *a, int &b, int &&c);", Style); verifyFormat("int &f2(int &&c, int *a, int &b);", Style); verifyFormat("int &&f3(int &b, int &&c, int *a);", Style); verifyFormat("int *f1(int &a) const &;", Style); verifyFormat("int *f1(int &a) const & = 0;", Style); verifyFormat("int *a = f1();", Style); verifyFormat("int &b = f2();", Style); verifyFormat("int &&c = f3();", Style); verifyFormat("int f3() { return sizeof(Foo &); }", Style); verifyFormat("int f4() { return sizeof(Foo &&); }", Style); verifyFormat("void f5() { int f6(Foo &, Bar &); }", Style); verifyFormat("void f5() { int f6(Foo &&, Bar &&); }", Style); verifyFormat("for (auto a = 0, b = 0; const auto &c : {1, 2, 3})", Style); verifyFormat("for (auto a = 0, b = 0; const int &c : {1, 2, 3})", Style); verifyFormat("for (auto a = 0, b = 0; const Foo &c : {1, 2, 3})", Style); verifyFormat("for (auto a = 0, b = 0; const Foo *c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b = 0; const auto &c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b = 0; const int &c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b = 0; const Foo &c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const auto &c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const int &c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const Foo &c : {1, 2, 3})", Style); verifyFormat("for (auto x = 0; auto &c : {1, 2, 3})", Style); verifyFormat("for (auto x = 0; int &c : {1, 2, 3})", Style); verifyFormat("for (int x = 0; auto &c : {1, 2, 3})", Style); verifyFormat("for (int x = 0; int &c : {1, 2, 3})", Style); verifyFormat("for (f(); auto &c : {1, 2, 3})", Style); verifyFormat("for (f(); int &c : {1, 2, 3})", Style); verifyFormat( "function res1 = [](int &a) { return 0000000000000; },\n" " res2 = [](int &a) { return 0000000000000; };", Style); Style.AlignConsecutiveDeclarations.Enabled = true; Style.AlignConsecutiveDeclarations.AlignFunctionPointers = true; verifyFormat("Const unsigned int *c;\n" "const unsigned int *d;\n" "Const unsigned int &e;\n" "const unsigned int &f;\n" "int *f1(int *a, int &b, int &&c);\n" "double *(*f2)(int *a, double &&b);\n" "const unsigned &&g;\n" "Const unsigned h;", Style); Style.AlignConsecutiveDeclarations.AlignFunctionPointers = false; verifyFormat("Const unsigned int *c;\n" "const unsigned int *d;\n" "Const unsigned int &e;\n" "const unsigned int &f;\n" "int *f1(int *a, int &b, int &&c);\n" "double *(*f2)(int *a, double &&b);\n" "const unsigned &&g;\n" "Const unsigned h;", Style); Style.PointerAlignment = FormatStyle::PAS_Left; verifyFormat("int* f1(int* a, int& b, int&& c);", Style); verifyFormat("int& f2(int&& c, int* a, int& b);", Style); verifyFormat("int&& f3(int& b, int&& c, int* a);", Style); verifyFormat("int* f1(int& a) const& = 0;", Style); verifyFormat("int* a = f1();", Style); verifyFormat("int& b = f2();", Style); verifyFormat("int&& c = f3();", Style); verifyFormat("int f3() { return sizeof(Foo&); }", Style); verifyFormat("int f4() { return sizeof(Foo&&); }", Style); verifyFormat("void f5() { int f6(Foo&, Bar&); }", Style); verifyFormat("void f5() { int f6(Foo&&, Bar&&); }", Style); verifyFormat("for (auto a = 0, b = 0; const auto& c : {1, 2, 3})", Style); verifyFormat("for (auto a = 0, b = 0; const int& c : {1, 2, 3})", Style); verifyFormat("for (auto a = 0, b = 0; const Foo& c : {1, 2, 3})", Style); verifyFormat("for (auto a = 0, b = 0; const Foo* c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b = 0; const auto& c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b = 0; const int& c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b = 0; const Foo& c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b = 0; const Foo* c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const auto& c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const int& c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const Foo& c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const Foo* c : {1, 2, 3})", Style); verifyFormat("for (auto x = 0; auto& c : {1, 2, 3})", Style); verifyFormat("for (auto x = 0; int& c : {1, 2, 3})", Style); verifyFormat("for (int x = 0; auto& c : {1, 2, 3})", Style); verifyFormat("for (int x = 0; int& c : {1, 2, 3})", Style); verifyFormat("for (f(); auto& c : {1, 2, 3})", Style); verifyFormat("for (f(); int& c : {1, 2, 3})", Style); verifyFormat( "function res1 = [](int& a) { return 0000000000000; },\n" " res2 = [](int& a) { return 0000000000000; };", Style); verifyFormat("[](decltype(foo)& Bar) {}", Style); Style.AlignConsecutiveDeclarations.Enabled = true; Style.AlignConsecutiveDeclarations.AlignFunctionPointers = true; verifyFormat("Const unsigned int* c;\n" "const unsigned int* d;\n" "Const unsigned int& e;\n" "const unsigned int& f;\n" "int* f1(int* a, int& b, int&& c);\n" "double* (*f2)(int* a, double&& b);\n" "const unsigned&& g;\n" "Const unsigned h;", Style); Style.AlignConsecutiveDeclarations.AlignFunctionPointers = false; verifyFormat("Const unsigned int* c;\n" "const unsigned int* d;\n" "Const unsigned int& e;\n" "const unsigned int& f;\n" "int* f1(int* a, int& b, int&& c);\n" "double* (*f2)(int* a, double&& b);\n" "const unsigned&& g;\n" "Const unsigned h;", Style); Style.PointerAlignment = FormatStyle::PAS_Right; Style.ReferenceAlignment = FormatStyle::RAS_Left; verifyFormat("int *f1(int *a, int& b, int&& c);", Style); verifyFormat("int& f2(int&& c, int *a, int& b);", Style); verifyFormat("int&& f3(int& b, int&& c, int *a);", Style); verifyFormat("int *a = f1();", Style); verifyFormat("int& b = f2();", Style); verifyFormat("int&& c = f3();", Style); verifyFormat("int f3() { return sizeof(Foo&); }", Style); verifyFormat("int f4() { return sizeof(Foo&&); }", Style); verifyFormat("void f5() { int f6(Foo&, Bar&); }", Style); verifyFormat("void f5() { int f6(Foo&&, Bar&&); }", Style); verifyFormat("for (auto a = 0, b = 0; const Foo *c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b = 0; const Foo *c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const Foo *c : {1, 2, 3})", Style); Style.AlignConsecutiveDeclarations.Enabled = true; Style.AlignConsecutiveDeclarations.AlignFunctionPointers = true; verifyFormat("Const unsigned int *c;\n" "const unsigned int *d;\n" "Const unsigned int& e;\n" "const unsigned int& f;\n" "int *f1(int *a, int& b, int&& c);\n" "double *(*f2)(int *a, double&& b);\n" "const unsigned&& g;\n" "Const unsigned h;", Style); Style.AlignConsecutiveDeclarations.AlignFunctionPointers = false; verifyFormat("Const unsigned int *c;\n" "const unsigned int *d;\n" "Const unsigned int& e;\n" "const unsigned int& f;\n" "int *f1(int *a, int& b, int&& c);\n" "double *(*f2)(int *a, double&& b);\n" "const unsigned&& g;\n" "Const unsigned h;", Style); Style.PointerAlignment = FormatStyle::PAS_Left; Style.ReferenceAlignment = FormatStyle::RAS_Middle; verifyFormat("int* f1(int* a, int & b, int && c);", Style); verifyFormat("int & f2(int && c, int* a, int & b);", Style); verifyFormat("int && f3(int & b, int && c, int* a);", Style); verifyFormat("int* a = f1();", Style); verifyFormat("int & b = f2();", Style); verifyFormat("int && c = f3();", Style); verifyFormat("int f3() { return sizeof(Foo &); }", Style); verifyFormat("int f4() { return sizeof(Foo &&); }", Style); verifyFormat("void f5() { int f6(Foo &, Bar &); }", Style); verifyFormat("void f5() { int f6(Foo &&, Bar &&); }", Style); verifyFormat("for (auto a = 0, b = 0; const auto & c : {1, 2, 3})", Style); verifyFormat("for (auto a = 0, b = 0; const int & c : {1, 2, 3})", Style); verifyFormat("for (auto a = 0, b = 0; const Foo & c : {1, 2, 3})", Style); verifyFormat("for (auto a = 0, b = 0; const Foo* c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const auto & c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const int & c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const Foo & c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const Foo* c : {1, 2, 3})", Style); verifyFormat("for (auto x = 0; auto & c : {1, 2, 3})", Style); verifyFormat("for (auto x = 0; int & c : {1, 2, 3})", Style); verifyFormat("for (int x = 0; auto & c : {1, 2, 3})", Style); verifyFormat("for (int x = 0; int & c : {1, 2, 3})", Style); verifyFormat("for (f(); auto & c : {1, 2, 3})", Style); verifyFormat("for (f(); int & c : {1, 2, 3})", Style); verifyFormat( "function res1 = [](int & a) { return 0000000000000; },\n" " res2 = [](int & a) { return 0000000000000; };", Style); Style.AlignConsecutiveDeclarations.Enabled = true; Style.AlignConsecutiveDeclarations.AlignFunctionPointers = true; verifyFormat("Const unsigned int* c;\n" "const unsigned int* d;\n" "Const unsigned int & e;\n" "const unsigned int & f;\n" "int* f1(int* a, int & b, int && c);\n" "double* (*f2)(int* a, double && b);\n" "const unsigned && g;\n" "Const unsigned h;", Style); Style.AlignConsecutiveDeclarations.AlignFunctionPointers = false; verifyFormat("Const unsigned int* c;\n" "const unsigned int* d;\n" "Const unsigned int & e;\n" "const unsigned int & f;\n" "int* f1(int* a, int & b, int && c);\n" "double* (*f2)(int* a, double && b);\n" "const unsigned && g;\n" "Const unsigned h;", Style); Style.PointerAlignment = FormatStyle::PAS_Middle; Style.ReferenceAlignment = FormatStyle::RAS_Right; verifyFormat("int * f1(int * a, int &b, int &&c);", Style); verifyFormat("int &f2(int &&c, int * a, int &b);", Style); verifyFormat("int &&f3(int &b, int &&c, int * a);", Style); verifyFormat("int * a = f1();", Style); verifyFormat("int &b = f2();", Style); verifyFormat("int &&c = f3();", Style); verifyFormat("int f3() { return sizeof(Foo &); }", Style); verifyFormat("int f4() { return sizeof(Foo &&); }", Style); verifyFormat("void f5() { int f6(Foo &, Bar &); }", Style); verifyFormat("void f5() { int f6(Foo &&, Bar &&); }", Style); verifyFormat("for (auto a = 0, b = 0; const Foo * c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b = 0; const Foo * c : {1, 2, 3})", Style); verifyFormat("for (int a = 0, b++; const Foo * c : {1, 2, 3})", Style); Style.AlignConsecutiveDeclarations.Enabled = true; Style.AlignConsecutiveDeclarations.AlignFunctionPointers = true; verifyFormat("Const unsigned int * c;\n" "const unsigned int * d;\n" "Const unsigned int &e;\n" "const unsigned int &f;\n" "int * f1(int * a, int &b, int &&c);\n" "double * (*f2)(int * a, double &&b);\n" "const unsigned &&g;\n" "Const unsigned h;", Style); Style.AlignConsecutiveDeclarations.AlignFunctionPointers = false; verifyFormat("Const unsigned int * c;\n" "const unsigned int * d;\n" "Const unsigned int &e;\n" "const unsigned int &f;\n" "int * f1(int * a, int &b, int &&c);\n" "double * (*f2)(int * a, double &&b);\n" "const unsigned &&g;\n" "Const unsigned h;", Style); // FIXME: we don't handle this yet, so output may be arbitrary until it's // specifically handled // verifyFormat("int Add2(BTree * &Root, char * szToAdd)", Style); } 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}"); verifyFormat("for (SmallVectorImpl::iterator\n" " I = Container.begin(),\n" " E = Container.end();\n" " I != E; ++I) {\n}", getLLVMStyleWithColumns(76)); verifyFormat( "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" " ++aaaaaaaaaaa) {\n}"); verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" " bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n" " ++i) {\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" "}"); verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n" " ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {"); // These should not be formatted as Objective-C for-in loops. verifyFormat("for (Foo *x = 0; x != in; x++) {\n}"); verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}"); verifyFormat("Foo *x;\nfor (x in y) {\n}"); verifyFormat( "for (const Foo &baz = in.value(); !baz.at_end(); ++baz) {\n}"); FormatStyle NoBinPacking = getLLVMStyle(); NoBinPacking.BinPackParameters = FormatStyle::BPPS_OnePerLine; 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); FormatStyle AlignLeft = getLLVMStyle(); AlignLeft.PointerAlignment = FormatStyle::PAS_Left; verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft); } 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}"); verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n" " aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}"); } TEST_F(FormatTest, ForEachLoops) { FormatStyle Style = getLLVMStyle(); EXPECT_EQ(Style.AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); EXPECT_EQ(Style.AllowShortLoopsOnASingleLine, false); verifyFormat("void f() {\n" " for (;;) {\n" " }\n" " foreach (Item *item, itemlist) {\n" " }\n" " Q_FOREACH (Item *item, itemlist) {\n" " }\n" " BOOST_FOREACH (Item *item, itemlist) {\n" " }\n" " UNKNOWN_FOREACH(Item * item, itemlist) {}\n" "}", Style); verifyFormat("void f() {\n" " for (;;)\n" " int j = 1;\n" " Q_FOREACH (int v, vec)\n" " v *= 2;\n" " for (;;) {\n" " int j = 1;\n" " }\n" " Q_FOREACH (int v, vec) {\n" " v *= 2;\n" " }\n" "}", Style); FormatStyle ShortBlocks = getLLVMStyle(); ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; EXPECT_EQ(ShortBlocks.AllowShortLoopsOnASingleLine, false); verifyFormat("void f() {\n" " for (;;)\n" " int j = 1;\n" " Q_FOREACH (int &v, vec)\n" " v *= 2;\n" " for (;;) {\n" " int j = 1;\n" " }\n" " Q_FOREACH (int &v, vec) {\n" " int j = 1;\n" " }\n" "}", ShortBlocks); FormatStyle ShortLoops = getLLVMStyle(); ShortLoops.AllowShortLoopsOnASingleLine = true; EXPECT_EQ(ShortLoops.AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never); verifyFormat("void f() {\n" " for (;;) int j = 1;\n" " Q_FOREACH (int &v, vec) int j = 1;\n" " for (;;) {\n" " int j = 1;\n" " }\n" " Q_FOREACH (int &v, vec) {\n" " int j = 1;\n" " }\n" "}", ShortLoops); FormatStyle ShortBlocksAndLoops = getLLVMStyle(); ShortBlocksAndLoops.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; ShortBlocksAndLoops.AllowShortLoopsOnASingleLine = true; verifyFormat("void f() {\n" " for (;;) int j = 1;\n" " Q_FOREACH (int &v, vec) int j = 1;\n" " for (;;) { int j = 1; }\n" " Q_FOREACH (int &v, vec) { int j = 1; }\n" "}", ShortBlocksAndLoops); Style.SpaceBeforeParens = FormatStyle::SBPO_ControlStatementsExceptControlMacros; verifyFormat("void f() {\n" " for (;;) {\n" " }\n" " foreach(Item *item, itemlist) {\n" " }\n" " Q_FOREACH(Item *item, itemlist) {\n" " }\n" " BOOST_FOREACH(Item *item, itemlist) {\n" " }\n" " UNKNOWN_FOREACH(Item * item, itemlist) {}\n" "}", Style); // As function-like macros. verifyFormat("#define foreach(x, y)\n" "#define Q_FOREACH(x, y)\n" "#define BOOST_FOREACH(x, y)\n" "#define UNKNOWN_FOREACH(x, y)"); // Not as function-like macros. verifyFormat("#define foreach (x, y)\n" "#define Q_FOREACH (x, y)\n" "#define BOOST_FOREACH (x, y)\n" "#define UNKNOWN_FOREACH (x, y)"); // handle microsoft non standard extension verifyFormat("for each (char c in x->MyStringProperty)"); } 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" "case 2: {\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", getLLVMStyleWithColumns(40)); verifyFormat("switch (x) {\n" "case 1:;\n" "default:;\n" " int i;\n" "}"); 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"); 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" " // fallthrough\n" " case B:\n" " g();\n" " break;\n" " }\n" "});"); verifyNoChange("DEBUG({\n" " switch (x) {\n" " case A:\n" " f();\n" " break;\n" " // On B:\n" " case B:\n" " g();\n" " break;\n" " }\n" "});"); verifyFormat("switch (n) {\n" "case 0: {\n" " return false;\n" "}\n" "default: {\n" " return true;\n" "}\n" "}", "switch (n)\n" "{\n" "case 0: {\n" " return false;\n" "}\n" "default: {\n" " return true;\n" "}\n" "}"); verifyFormat("switch (a) {\n" "case (b):\n" " return;\n" "}"); verifyFormat("switch (a) {\n" "case some_namespace::\n" " some_constant:\n" " return;\n" "}", getLLVMStyleWithColumns(34)); verifyFormat("switch (a) {\n" "[[likely]] case 1:\n" " return;\n" "}"); verifyFormat("switch (a) {\n" "[[likely]] [[other::likely]] case 1:\n" " return;\n" "}"); verifyFormat("switch (x) {\n" "case 1:\n" " return;\n" "[[likely]] case 2:\n" " return;\n" "}"); verifyFormat("switch (a) {\n" "case 1:\n" "[[likely]] case 2:\n" " return;\n" "}"); FormatStyle Attributes = getLLVMStyle(); Attributes.AttributeMacros.push_back("LIKELY"); Attributes.AttributeMacros.push_back("OTHER_LIKELY"); verifyFormat("switch (a) {\n" "LIKELY case b:\n" " return;\n" "}", Attributes); verifyFormat("switch (a) {\n" "LIKELY OTHER_LIKELY() case b:\n" " return;\n" "}", Attributes); verifyFormat("switch (a) {\n" "case 1:\n" " return;\n" "LIKELY case 2:\n" " return;\n" "}", Attributes); verifyFormat("switch (a) {\n" "case 1:\n" "LIKELY case 2:\n" " return;\n" "}", Attributes); FormatStyle Style = getLLVMStyle(); Style.IndentCaseLabels = true; Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterCaseLabel = true; Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; verifyFormat("switch (n)\n" "{\n" " case 0:\n" " {\n" " return false;\n" " }\n" " default:\n" " {\n" " return true;\n" " }\n" "}", "switch (n) {\n" " case 0: {\n" " return false;\n" " }\n" " default: {\n" " return true;\n" " }\n" "}", Style); Style.BraceWrapping.AfterCaseLabel = false; verifyFormat("switch (n)\n" "{\n" " case 0: {\n" " return false;\n" " }\n" " default: {\n" " return true;\n" " }\n" "}", "switch (n) {\n" " case 0:\n" " {\n" " return false;\n" " }\n" " default:\n" " {\n" " return true;\n" " }\n" "}", Style); Style.IndentCaseLabels = false; Style.IndentCaseBlocks = true; verifyFormat("switch (n)\n" "{\n" "case 0:\n" " {\n" " return false;\n" " }\n" "case 1:\n" " break;\n" "default:\n" " {\n" " return true;\n" " }\n" "}", "switch (n) {\n" "case 0: {\n" " return false;\n" "}\n" "case 1:\n" " break;\n" "default: {\n" " return true;\n" "}\n" "}", Style); Style.IndentCaseLabels = true; Style.IndentCaseBlocks = true; verifyFormat("switch (n)\n" "{\n" " case 0:\n" " {\n" " return false;\n" " }\n" " case 1:\n" " break;\n" " default:\n" " {\n" " return true;\n" " }\n" "}", "switch (n) {\n" "case 0: {\n" " return false;\n" "}\n" "case 1:\n" " break;\n" "default: {\n" " return true;\n" "}\n" "}", Style); } TEST_F(FormatTest, CaseRanges) { verifyFormat("switch (x) {\n" "case 'A' ... 'Z':\n" "case 1 ... 5:\n" "case a ... b:\n" " break;\n" "}"); } TEST_F(FormatTest, ShortEnums) { FormatStyle Style = getLLVMStyle(); EXPECT_TRUE(Style.AllowShortEnumsOnASingleLine); EXPECT_FALSE(Style.BraceWrapping.AfterEnum); verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style); verifyFormat("typedef enum { A, B, C } ShortEnum1, ShortEnum2;", Style); Style.AllowShortEnumsOnASingleLine = false; verifyFormat("enum {\n" " A,\n" " B,\n" " C\n" "} ShortEnum1, ShortEnum2;", Style); verifyFormat("typedef enum {\n" " A,\n" " B,\n" " C\n" "} ShortEnum1, ShortEnum2;", Style); verifyFormat("enum {\n" " A,\n" "} ShortEnum1, ShortEnum2;", Style); verifyFormat("typedef enum {\n" " A,\n" "} ShortEnum1, ShortEnum2;", Style); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterEnum = true; verifyFormat("enum\n" "{\n" " A,\n" " B,\n" " C\n" "} ShortEnum1, ShortEnum2;", Style); verifyFormat("typedef enum\n" "{\n" " A,\n" " B,\n" " C\n" "} ShortEnum1, ShortEnum2;", Style); } TEST_F(FormatTest, ShortCompoundRequirement) { FormatStyle Style = getLLVMStyle(); EXPECT_TRUE(Style.AllowShortCompoundRequirementOnASingleLine); verifyFormat("template \n" "concept c = requires(T x) {\n" " { x + 1 } -> std::same_as;\n" "};", Style); verifyFormat("template \n" "concept c = requires(T x) {\n" " { x + 1 } -> std::same_as;\n" " { x + 2 } -> std::same_as;\n" "};", Style); Style.AllowShortCompoundRequirementOnASingleLine = false; verifyFormat("template \n" "concept c = requires(T x) {\n" " {\n" " x + 1\n" " } -> std::same_as;\n" "};", Style); verifyFormat("template \n" "concept c = requires(T x) {\n" " {\n" " x + 1\n" " } -> std::same_as;\n" " {\n" " x + 2\n" " } -> std::same_as;\n" "};", Style); } TEST_F(FormatTest, ShortCaseLabels) { FormatStyle Style = getLLVMStyle(); Style.AllowShortCaseLabelsOnASingleLine = true; verifyFormat("switch (a) {\n" "case 1: x = 1; break;\n" "case 2: return;\n" "case 3:\n" "case 4:\n" "case 5: return;\n" "case 6: // comment\n" " return;\n" "case 7:\n" " // comment\n" " return;\n" "case 8:\n" " x = 8; // comment\n" " break;\n" "default: y = 1; break;\n" "}", Style); verifyFormat("switch (a) {\n" "case 0: return; // comment\n" "case 1: break; // comment\n" "case 2: return;\n" "// comment\n" "case 3: return;\n" "// comment 1\n" "// comment 2\n" "// comment 3\n" "case 4: break; /* comment */\n" "case 5:\n" " // comment\n" " break;\n" "case 6: /* comment */ x = 1; break;\n" "case 7: x = /* comment */ 1; break;\n" "case 8:\n" " x = 1; /* comment */\n" " break;\n" "case 9:\n" " break; // comment line 1\n" " // comment line 2\n" "}", Style); verifyFormat("switch (a) {\n" "case 1:\n" " x = 8;\n" " // fall through\n" "case 2: x = 8;\n" "// comment\n" "case 3:\n" " return; /* comment line 1\n" " * comment line 2 */\n" "case 4: i = 8;\n" "// something else\n" "#if FOO\n" "case 5: break;\n" "#endif\n" "}", "switch (a) {\n" "case 1: x = 8;\n" " // fall through\n" "case 2:\n" " x = 8;\n" "// comment\n" "case 3:\n" " return; /* comment line 1\n" " * comment line 2 */\n" "case 4:\n" " i = 8;\n" "// something else\n" "#if FOO\n" "case 5: break;\n" "#endif\n" "}", Style); verifyFormat("switch (a) {\n" "case 0:\n" " return; // long long long long long long long long long long " "long long comment\n" " // line\n" "}", "switch (a) {\n" "case 0: return; // long long long long long long long long " "long long long long comment line\n" "}", Style); verifyFormat("switch (a) {\n" "case 0:\n" " return; /* long long long long long long long long long long " "long long comment\n" " line */\n" "}", "switch (a) {\n" "case 0: return; /* long long long long long long long long " "long long long long comment line */\n" "}", Style); verifyFormat("switch (a) {\n" "#if FOO\n" "case 0: return 0;\n" "#endif\n" "}", Style); verifyFormat("switch (a) {\n" "case 1: {\n" "}\n" "case 2: {\n" " return;\n" "}\n" "case 3: {\n" " x = 1;\n" " return;\n" "}\n" "case 4:\n" " if (x)\n" " return;\n" "}", Style); Style.ColumnLimit = 21; verifyFormat("#define X \\\n" " case 0: break;\n" "#include \"f\"", Style); verifyFormat("switch (a) {\n" "case 1: x = 1; break;\n" "case 2: return;\n" "case 3:\n" "case 4:\n" "case 5: return;\n" "default:\n" " y = 1;\n" " break;\n" "}", Style); Style.ColumnLimit = 80; Style.AllowShortCaseLabelsOnASingleLine = false; Style.IndentCaseLabels = true; verifyFormat("switch (n) {\n" " default /*comments*/:\n" " return true;\n" " case 0:\n" " return false;\n" "}", "switch (n) {\n" "default/*comments*/:\n" " return true;\n" "case 0:\n" " return false;\n" "}", Style); Style.AllowShortCaseLabelsOnASingleLine = true; Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterCaseLabel = true; Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; verifyFormat("switch (n)\n" "{\n" " case 0:\n" " {\n" " return false;\n" " }\n" " default:\n" " {\n" " return true;\n" " }\n" "}", "switch (n) {\n" " case 0: {\n" " return false;\n" " }\n" " default:\n" " {\n" " return true;\n" " }\n" "}", Style); } 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("{\n" " some_code();\n" "test_label:\n" " some_other_code();\n" "}"); verifyFormat("{\n" " some_code();\n" "test_label:;\n" " int i = 0;\n" "}"); verifyFormat("{\n" " some_code();\n" "test_label: { some_other_code(); }\n" "}"); verifyFormat("{\n" " some_code();\n" "test_label: {\n" " some_other_code();\n" " some_other_code();\n" "}\n" "}"); verifyFormat("{\n" "L0:\n" "[[foo]] L1:\n" "[[bar]] [[baz]] L2:\n" " g();\n" "}"); verifyFormat("{\n" "[[foo]] L1: {\n" "[[bar]] [[baz]] L2:\n" " g();\n" "}\n" "}"); verifyFormat("{\n" "[[foo]] L1:\n" " f();\n" " {\n" " [[bar]] [[baz]] L2:\n" " g();\n" " }\n" "}"); FormatStyle Style = getLLVMStyle(); Style.IndentGotoLabels = false; 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" "}", Style); verifyFormat("{\n" " some_code();\n" "test_label:\n" " some_other_code();\n" "}", Style); verifyFormat("{\n" " some_code();\n" "test_label:;\n" " int i = 0;\n" "}", Style); verifyFormat("{\n" " some_code();\n" "test_label: { some_other_code(); }\n" "}", Style); verifyFormat("{\n" "[[foo]] L1:\n" " f();\n" " {\n" "[[bar]] [[baz]] L2:\n" " g();\n" " }\n" "}", Style); Style.ColumnLimit = 15; verifyFormat("#define FOO \\\n" "label: \\\n" " break;", Style); // The opening brace may either be on the same unwrapped line as the colon or // on a separate one. The formatter should recognize both. Style = getLLVMStyle(); Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Allman; verifyFormat("{\n" " some_code();\n" "test_label:\n" "{\n" " some_other_code();\n" "}\n" "}", Style); verifyFormat("{\n" "[[foo]] L1:\n" "{\n" "[[bar]] [[baz]] L2:\n" " g();\n" "}\n" "}", Style); } TEST_F(FormatTest, MultiLineControlStatements) { FormatStyle Style = getLLVMStyleWithColumns(20); Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; // Short lines should keep opening brace on same line. verifyFormat("if (foo) {\n" " bar();\n" "}", "if(foo){bar();}", Style); verifyFormat("if (foo) {\n" " bar();\n" "} else {\n" " baz();\n" "}", "if(foo){bar();}else{baz();}", Style); verifyFormat("if (foo && bar) {\n" " baz();\n" "}", "if(foo&&bar){baz();}", Style); verifyFormat("if (foo) {\n" " bar();\n" "} else if (baz) {\n" " quux();\n" "}", "if(foo){bar();}else if(baz){quux();}", Style); verifyFormat("if (foo) {\n" " bar();\n" "} else if (baz) {\n" " quux();\n" "} else {\n" " foobar();\n" "}", "if(foo){bar();}else if(baz){quux();}else{foobar();}", Style); verifyFormat("for (;;) {\n" " foo();\n" "}", "for(;;){foo();}"); verifyFormat("while (1) {\n" " foo();\n" "}", "while(1){foo();}", Style); verifyFormat("switch (foo) {\n" "case bar:\n" " return;\n" "}", "switch(foo){case bar:return;}", Style); verifyFormat("try {\n" " foo();\n" "} catch (...) {\n" " bar();\n" "}", "try{foo();}catch(...){bar();}", Style); verifyFormat("do {\n" " foo();\n" "} while (bar &&\n" " baz);", "do{foo();}while(bar&&baz);", Style); // Long lines should put opening brace on new line. verifyFormat("void f() {\n" " if (a1 && a2 &&\n" " a3)\n" " {\n" " quux();\n" " }\n" "}", "void f(){if(a1&&a2&&a3){quux();}}", Style); verifyFormat("if (foo && bar &&\n" " baz)\n" "{\n" " quux();\n" "}", "if(foo&&bar&&baz){quux();}", Style); verifyFormat("if (foo && bar &&\n" " baz)\n" "{\n" " quux();\n" "}", "if (foo && bar &&\n" " baz) {\n" " quux();\n" "}", Style); verifyFormat("if (foo) {\n" " bar();\n" "} else if (baz ||\n" " quux)\n" "{\n" " foobar();\n" "}", "if(foo){bar();}else if(baz||quux){foobar();}", Style); verifyFormat("if (foo) {\n" " bar();\n" "} else if (baz ||\n" " quux)\n" "{\n" " foobar();\n" "} else {\n" " barbaz();\n" "}", "if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", Style); verifyFormat("for (int i = 0;\n" " i < 10; ++i)\n" "{\n" " foo();\n" "}", "for(int i=0;i<10;++i){foo();}", Style); verifyFormat("foreach (int i,\n" " list)\n" "{\n" " foo();\n" "}", "foreach(int i, list){foo();}", Style); Style.ColumnLimit = 40; // to concentrate at brace wrapping, not line wrap due to column limit verifyFormat("foreach (int i, list) {\n" " foo();\n" "}", "foreach(int i, list){foo();}", Style); Style.ColumnLimit = 20; // to concentrate at brace wrapping, not line wrap due to column limit verifyFormat("while (foo || bar ||\n" " baz)\n" "{\n" " quux();\n" "}", "while(foo||bar||baz){quux();}", Style); verifyFormat("switch (\n" " foo = barbaz)\n" "{\n" "case quux:\n" " return;\n" "}", "switch(foo=barbaz){case quux:return;}", Style); verifyFormat("try {\n" " foo();\n" "} catch (\n" " Exception &bar)\n" "{\n" " baz();\n" "}", "try{foo();}catch(Exception&bar){baz();}", Style); Style.ColumnLimit = 40; // to concentrate at brace wrapping, not line wrap due to column limit verifyFormat("try {\n" " foo();\n" "} catch (Exception &bar) {\n" " baz();\n" "}", "try{foo();}catch(Exception&bar){baz();}", Style); Style.ColumnLimit = 20; // to concentrate at brace wrapping, not line wrap due to column limit Style.BraceWrapping.BeforeElse = true; verifyFormat("if (foo) {\n" " bar();\n" "}\n" "else if (baz ||\n" " quux)\n" "{\n" " foobar();\n" "}\n" "else {\n" " barbaz();\n" "}", "if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}", Style); Style.BraceWrapping.BeforeCatch = true; verifyFormat("try {\n" " foo();\n" "}\n" "catch (...) {\n" " baz();\n" "}", "try{foo();}catch(...){baz();}", Style); Style.BraceWrapping.AfterFunction = true; Style.BraceWrapping.AfterStruct = false; Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine; Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; Style.ColumnLimit = 80; verifyFormat("void shortfunction() { bar(); }", Style); verifyFormat("struct T shortfunction() { return bar(); }", Style); verifyFormat("struct T {};", Style); Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; verifyFormat("void shortfunction()\n" "{\n" " bar();\n" "}", Style); verifyFormat("struct T shortfunction()\n" "{\n" " return bar();\n" "}", Style); verifyFormat("struct T {};", Style); Style.BraceWrapping.AfterFunction = false; Style.BraceWrapping.AfterStruct = true; Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; verifyFormat("void shortfunction() { bar(); }", Style); verifyFormat("struct T shortfunction() { return bar(); }", Style); verifyFormat("struct T\n" "{\n" "};", Style); Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; verifyFormat("void shortfunction() {\n" " bar();\n" "}", Style); verifyFormat("struct T shortfunction() {\n" " return bar();\n" "}", Style); verifyFormat("struct T\n" "{\n" "};", Style); } TEST_F(FormatTest, BeforeWhile) { FormatStyle Style = getLLVMStyle(); Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom; verifyFormat("do {\n" " foo();\n" "} while (1);", Style); Style.BraceWrapping.BeforeWhile = true; verifyFormat("do {\n" " foo();\n" "}\n" "while (1);", Style); } //===----------------------------------------------------------------------===// // 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" "};"); verifyFormat("export 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" "};"); verifyGoogleFormat("export class A {\n" " public:\n" " protected:\n" " private:\n" " void f() {}\n" "};"); verifyFormat("class A {\n" "public slots:\n" " void f1() {}\n" "public Q_SLOTS:\n" " void f2() {}\n" "protected slots:\n" " void f3() {}\n" "protected Q_SLOTS:\n" " void f4() {}\n" "private slots:\n" " void f5() {}\n" "private Q_SLOTS:\n" " void f6() {}\n" "signals:\n" " void g1();\n" "Q_SIGNALS:\n" " void g2();\n" "};"); // Don't interpret 'signals' the wrong way. verifyFormat("signals.set();"); verifyFormat("for (Signals signals : f()) {\n}"); verifyFormat("{\n" " signals.set(); // This needs indentation.\n" "}"); verifyFormat("void f() {\n" "label:\n" " signals.baz();\n" "}"); verifyFormat("private[1];"); verifyFormat("testArray[public] = 1;"); verifyFormat("public();"); verifyFormat("myFunc(public);"); verifyFormat("std::vector testVec = {private};"); verifyFormat("private.p = 1;"); verifyFormat("void function(private...) {};"); verifyFormat("if (private && public)"); verifyFormat("private &= true;"); verifyFormat("int x = private * public;"); verifyFormat("public *= private;"); verifyFormat("int x = public + private;"); verifyFormat("private++;"); verifyFormat("++private;"); verifyFormat("public += private;"); verifyFormat("public = public - private;"); verifyFormat("public->foo();"); verifyFormat("private--;"); verifyFormat("--private;"); verifyFormat("public -= 1;"); verifyFormat("if (!private && !public)"); verifyFormat("public != private;"); verifyFormat("int x = public / private;"); verifyFormat("public /= 2;"); verifyFormat("public = public % 2;"); verifyFormat("public %= 2;"); verifyFormat("if (public < private)"); verifyFormat("public << private;"); verifyFormat("public <<= private;"); verifyFormat("if (public > private)"); verifyFormat("public >> private;"); verifyFormat("public >>= private;"); verifyFormat("public ^ private;"); verifyFormat("public ^= private;"); verifyFormat("public | private;"); verifyFormat("public |= private;"); verifyFormat("auto x = private ? 1 : 2;"); verifyFormat("if (public == private)"); verifyFormat("void foo(public, private)"); verifyFormat("public::foo();"); verifyFormat("class A {\n" "public:\n" " std::unique_ptr b() { return nullptr; }\n" "\n" "private:\n" " int c;\n" "};\n" "class B {\n" "public:\n" " std::unique_ptr b() { return nullptr; }\n" "\n" "private:\n" " int c;\n" "};"); } TEST_F(FormatTest, SeparatesLogicalBlocks) { verifyFormat("class A {\n" "public:\n" " void f();\n" "\n" "private:\n" " void g() {}\n" " // test\n" "protected:\n" " int h;\n" "};", "class A {\n" "public:\n" "void f();\n" "private:\n" "void g() {}\n" "// test\n" "protected:\n" "int h;\n" "};"); verifyFormat("class A {\n" "protected:\n" "public:\n" " void f();\n" "};", "class A {\n" "protected:\n" "\n" "public:\n" "\n" " void f();\n" "};"); // Even ensure proper spacing inside macros. verifyFormat("#define B \\\n" " class A { \\\n" " protected: \\\n" " public: \\\n" " void f(); \\\n" " };", "#define B \\\n" " class A { \\\n" " protected: \\\n" " \\\n" " public: \\\n" " \\\n" " void f(); \\\n" " };", getGoogleStyle()); // But don't remove empty lines after macros ending in access specifiers. verifyFormat("#define A private:\n" "\n" "int i;", "#define A private:\n" "\n" "int i;"); } 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 {};"); verifyFormat("template \n" "struct Aaaaaaaaaaaaaaaaa\n" " : Aaaaaaaaaaaaaaaaa {};"); verifyFormat("class ::A::B {};"); } TEST_F(FormatTest, BreakInheritanceStyle) { FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle(); StyleWithInheritanceBreakBeforeComma.BreakInheritanceList = FormatStyle::BILS_BeforeComma; verifyFormat("class MyClass : public X {};", StyleWithInheritanceBreakBeforeComma); verifyFormat("class MyClass\n" " : public X\n" " , public Y {};", StyleWithInheritanceBreakBeforeComma); verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n" " : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n" " , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", StyleWithInheritanceBreakBeforeComma); verifyFormat("struct aaaaaaaaaaaaa\n" " : public aaaaaaaaaaaaaaaaaaa< // break\n" " aaaaaaaaaaaaaaaa> {};", StyleWithInheritanceBreakBeforeComma); FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle(); StyleWithInheritanceBreakAfterColon.BreakInheritanceList = FormatStyle::BILS_AfterColon; verifyFormat("class MyClass : public X {};", StyleWithInheritanceBreakAfterColon); verifyFormat("class MyClass : public X, public Y {};", StyleWithInheritanceBreakAfterColon); verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n" " public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};", StyleWithInheritanceBreakAfterColon); verifyFormat("struct aaaaaaaaaaaaa :\n" " public aaaaaaaaaaaaaaaaaaa< // break\n" " aaaaaaaaaaaaaaaa> {};", StyleWithInheritanceBreakAfterColon); FormatStyle StyleWithInheritanceBreakAfterComma = getLLVMStyle(); StyleWithInheritanceBreakAfterComma.BreakInheritanceList = FormatStyle::BILS_AfterComma; verifyFormat("class MyClass : public X {};", StyleWithInheritanceBreakAfterComma); verifyFormat("class MyClass : public X,\n" " public Y {};", StyleWithInheritanceBreakAfterComma); verifyFormat( "class AAAAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n" " public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC " "{};", StyleWithInheritanceBreakAfterComma); verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n" " aaaaaaaaaaaaaaaa> {};", StyleWithInheritanceBreakAfterComma); verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n" " : public OnceBreak,\n" " public AlwaysBreak,\n" " EvenBasesFitInOneLine {};", StyleWithInheritanceBreakAfterComma); } TEST_F(FormatTest, FormatsVariableDeclarationsAfterRecord) { verifyFormat("class A {\n} a, b;"); verifyFormat("struct A {\n} a, b;"); verifyFormat("union A {\n} a, b;"); verifyFormat("constexpr class A {\n} a, b;"); verifyFormat("constexpr struct A {\n} a, b;"); verifyFormat("constexpr union A {\n} a, b;"); verifyFormat("namespace {\nclass A {\n} a, b;\n} // namespace"); verifyFormat("namespace {\nstruct A {\n} a, b;\n} // namespace"); verifyFormat("namespace {\nunion A {\n} a, b;\n} // namespace"); verifyFormat("namespace {\nconstexpr class A {\n} a, b;\n} // namespace"); verifyFormat("namespace {\nconstexpr struct A {\n} a, b;\n} // namespace"); verifyFormat("namespace {\nconstexpr union A {\n} a, b;\n} // namespace"); verifyFormat("namespace ns {\n" "class {\n" "} a, b;\n" "} // namespace ns"); verifyFormat("namespace ns {\n" "const class {\n" "} a, b;\n" "} // namespace ns"); verifyFormat("namespace ns {\n" "constexpr class C {\n" "} a, b;\n" "} // namespace ns"); verifyFormat("namespace ns {\n" "class { /* comment */\n" "} a, b;\n" "} // namespace ns"); verifyFormat("namespace ns {\n" "const class { /* comment */\n" "} a, b;\n" "} // namespace ns"); } 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 [[nodiscard]] E {} d;"); verifyFormat("enum {\n" " Bar = Foo::value\n" "};", getLLVMStyleWithColumns(30)); verifyFormat("enum ShortEnum { A, B, C };"); verifyGoogleFormat("enum ShortEnum { A, B, C };"); verifyFormat("enum KeepEmptyLines {\n" " ONE,\n" "\n" " TWO,\n" "\n" " THREE\n" "}", "enum KeepEmptyLines {\n" " ONE,\n" "\n" " TWO,\n" "\n" "\n" " THREE\n" "}"); verifyFormat("enum E { // comment\n" " ONE,\n" " TWO\n" "};\n" "int i;"); FormatStyle EightIndent = getLLVMStyle(); EightIndent.IndentWidth = 8; verifyFormat("enum {\n" " VOID,\n" " CHAR,\n" " SHORT,\n" " INT,\n" " LONG,\n" " SIGNED,\n" " UNSIGNED,\n" " BOOL,\n" " FLOAT,\n" " DOUBLE,\n" " COMPLEX\n" "};", EightIndent); verifyFormat("enum [[nodiscard]] E {\n" " ONE,\n" " TWO,\n" "};"); verifyFormat("enum [[nodiscard]] E {\n" " // Comment 1\n" " ONE,\n" " // Comment 2\n" " TWO,\n" "};"); verifyFormat("enum [[clang::enum_extensibility(open)]] E {\n" " // Comment 1\n" " ONE,\n" " // Comment 2\n" " TWO\n" "};"); verifyFormat("enum [[nodiscard]] [[clang::enum_extensibility(open)]] E {\n" " // Comment 1\n" " ONE,\n" " // Comment 2\n" " TWO\n" "};"); verifyFormat("enum [[clang::enum_extensibility(open)]] E { // foo\n" " A,\n" " // bar\n" " B\n" "};", "enum [[clang::enum_extensibility(open)]] E{// foo\n" " A,\n" " // bar\n" " B};"); // Not enums. verifyFormat("enum X f() {\n" " a();\n" " return 42;\n" "}"); verifyFormat("enum X Type::f() {\n" " a();\n" " return 42;\n" "}"); verifyFormat("enum ::X f() {\n" " a();\n" " return 42;\n" "}"); verifyFormat("enum ns::X f() {\n" " a();\n" " return 42;\n" "}"); } TEST_F(FormatTest, FormatsEnumsWithErrors) { verifyFormat("enum Type {\n" " One = 0; // These semicolons should be commas.\n" " Two = 1;\n" "};"); verifyFormat("namespace n {\n" "enum Type {\n" " One,\n" " Two, // missing };\n" " 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 [[nodiscard]] E {} d;"); verifyFormat("enum struct X f() {\n a();\n return 42;\n}"); verifyFormat("enum struct [[nodiscard]] E {\n" " ONE,\n" " TWO,\n" "};"); verifyFormat("enum struct [[nodiscard]] E {\n" " // Comment 1\n" " ONE,\n" " // Comment 2\n" " TWO,\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 [[nodiscard]] E {} d;"); verifyFormat("enum class X f() {\n a();\n return 42;\n}"); verifyFormat("enum class [[nodiscard]] E {\n" " ONE,\n" " TWO,\n" "};"); verifyFormat("enum class [[nodiscard]] E {\n" " // Comment 1\n" " ONE,\n" " // Comment 2\n" " TWO,\n" "};"); } TEST_F(FormatTest, FormatsEnumTypes) { verifyFormat("enum X : int {\n" " A, // Force multiple lines.\n" " B\n" "};"); verifyFormat("enum X : int { A, B };"); verifyFormat("enum X : std::uint32_t { A, B };"); } TEST_F(FormatTest, FormatsTypedefEnum) { FormatStyle Style = getLLVMStyleWithColumns(40); verifyFormat("typedef enum {} EmptyEnum;"); verifyFormat("typedef enum { A, B, C } ShortEnum;"); verifyFormat("typedef enum {\n" " ZERO = 0,\n" " ONE = 1,\n" " TWO = 2,\n" " THREE = 3\n" "} LongEnum;", Style); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterEnum = true; verifyFormat("typedef enum {} EmptyEnum;"); verifyFormat("typedef enum { A, B, C } ShortEnum;"); verifyFormat("typedef enum\n" "{\n" " ZERO = 0,\n" " ONE = 1,\n" " TWO = 2,\n" " THREE = 3\n" "} LongEnum;", Style); } TEST_F(FormatTest, FormatsNSEnums) { verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }"); verifyGoogleFormat( "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }"); verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n" " // Information about someDecentlyLongValue.\n" " someDecentlyLongValue,\n" " // Information about anotherDecentlyLongValue.\n" " anotherDecentlyLongValue,\n" " // Information about aThirdDecentlyLongValue.\n" " aThirdDecentlyLongValue\n" "};"); verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n" " // Information about someDecentlyLongValue.\n" " someDecentlyLongValue,\n" " // Information about anotherDecentlyLongValue.\n" " anotherDecentlyLongValue,\n" " // Information about aThirdDecentlyLongValue.\n" " aThirdDecentlyLongValue\n" "};"); verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n" " a = 1,\n" " b = 2,\n" " c = 3,\n" "};"); verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n" " a = 1,\n" " b = 2,\n" " c = 3,\n" "};"); verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n" " a = 1,\n" " b = 2,\n" " c = 3,\n" "};"); verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n" " a = 1,\n" " b = 2,\n" " c = 3,\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" "};"); verifyFormat("struct MyStruct {\n" " uchar data;\n" " uchar : 8;\n" " uchar : 8;\n" " uchar other;\n" "};"); FormatStyle Style = getLLVMStyle(); Style.BitFieldColonSpacing = FormatStyle::BFCS_None; verifyFormat("struct Bitfields {\n" " unsigned sClass:8;\n" " unsigned ValueKind:2;\n" " uchar other;\n" "};", Style); verifyFormat("struct A {\n" " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:1,\n" " bbbbbbbbbbbbbbbbbbbbbbbbb:2;\n" "};", Style); Style.BitFieldColonSpacing = FormatStyle::BFCS_Before; verifyFormat("struct Bitfields {\n" " unsigned sClass :8;\n" " unsigned ValueKind :2;\n" " uchar other;\n" "};", Style); Style.BitFieldColonSpacing = FormatStyle::BFCS_After; verifyFormat("struct Bitfields {\n" " unsigned sClass: 8;\n" " unsigned ValueKind: 2;\n" " uchar other;\n" "};", Style); } TEST_F(FormatTest, FormatsNamespaces) { FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle(); LLVMWithNoNamespaceFix.FixNamespaceComments = false; verifyFormat("namespace some_namespace {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("#define M(x) x##x\n" "namespace M(x) {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("#define M(x) x##x\n" "namespace N::inline M(x) {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("#define M(x) x##x\n" "namespace M(x)::inline N {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("#define M(x) x##x\n" "namespace N::M(x) {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("#define M(x) x##x\n" "namespace M::N(x) {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("namespace N::inline D {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("namespace N::inline D::E {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("/* something */ namespace some_namespace {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("namespace {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("/* something */ namespace {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("inline namespace X {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("/* something */ inline namespace X {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("export namespace X {\n" "class A {};\n" "void f() { f(); }\n" "}", LLVMWithNoNamespaceFix); verifyFormat("using namespace some_namespace;\n" "class A {};\n" "void f() { f(); }", LLVMWithNoNamespaceFix); // This code is more common than we thought; if we // layout this correctly the semicolon will go into // its own line, which is undesirable. verifyFormat("namespace {};", LLVMWithNoNamespaceFix); verifyFormat("namespace {\n" "class A {};\n" "};", LLVMWithNoNamespaceFix); verifyFormat("namespace {\n" "int SomeVariable = 0; // comment\n" "} // namespace", LLVMWithNoNamespaceFix); verifyFormat("#ifndef HEADER_GUARD\n" "#define HEADER_GUARD\n" "namespace my_namespace {\n" "int i;\n" "} // my_namespace\n" "#endif // HEADER_GUARD", "#ifndef HEADER_GUARD\n" " #define HEADER_GUARD\n" " namespace my_namespace {\n" "int i;\n" "} // my_namespace\n" "#endif // HEADER_GUARD", LLVMWithNoNamespaceFix); verifyFormat("namespace A::B {\n" "class C {};\n" "}", LLVMWithNoNamespaceFix); FormatStyle Style = getLLVMStyle(); Style.NamespaceIndentation = FormatStyle::NI_All; verifyFormat("namespace out {\n" " int i;\n" " namespace in {\n" " int i;\n" " } // namespace in\n" "} // namespace out", "namespace out {\n" "int i;\n" "namespace in {\n" "int i;\n" "} // namespace in\n" "} // namespace out", Style); FormatStyle ShortInlineFunctions = getLLVMStyle(); ShortInlineFunctions.NamespaceIndentation = FormatStyle::NI_All; ShortInlineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; verifyFormat("namespace {\n" " void f() {\n" " return;\n" " }\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace { /* comment */\n" " void f() {\n" " return;\n" " }\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace { // comment\n" " void f() {\n" " return;\n" " }\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace {\n" " int some_int;\n" " void f() {\n" " return;\n" " }\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace interface {\n" " void f() {\n" " return;\n" " }\n" "} // namespace interface", ShortInlineFunctions); verifyFormat("namespace {\n" " class X {\n" " void f() { return; }\n" " };\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace {\n" " class X { /* comment */\n" " void f() { return; }\n" " };\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace {\n" " class X { // comment\n" " void f() { return; }\n" " };\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace {\n" " struct X {\n" " void f() { return; }\n" " };\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace {\n" " union X {\n" " void f() { return; }\n" " };\n" "} // namespace", ShortInlineFunctions); verifyFormat("extern \"C\" {\n" "void f() {\n" " return;\n" "}\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace {\n" " class X {\n" " void f() { return; }\n" " } x;\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace {\n" " [[nodiscard]] class X {\n" " void f() { return; }\n" " };\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace {\n" " static class X {\n" " void f() { return; }\n" " } x;\n" "} // namespace", ShortInlineFunctions); verifyFormat("namespace {\n" " constexpr class X {\n" " void f() { return; }\n" " } x;\n" "} // namespace", ShortInlineFunctions); ShortInlineFunctions.IndentExternBlock = FormatStyle::IEBS_Indent; verifyFormat("extern \"C\" {\n" " void f() {\n" " return;\n" " }\n" "} // namespace", ShortInlineFunctions); Style.NamespaceIndentation = FormatStyle::NI_Inner; verifyFormat("namespace out {\n" "int i;\n" "namespace in {\n" " int i;\n" "} // namespace in\n" "} // namespace out", "namespace out {\n" "int i;\n" "namespace in {\n" "int i;\n" "} // namespace in\n" "} // namespace out", Style); Style.NamespaceIndentation = FormatStyle::NI_None; verifyFormat("template \n" "concept a_concept = X<>;\n" "namespace B {\n" "struct b_struct {};\n" "} // namespace B", Style); verifyFormat("template \n" "constexpr void foo()\n" " requires(I == 42)\n" "{}\n" "namespace ns {\n" "void foo() {}\n" "} // namespace ns", Style); FormatStyle LLVMWithCompactInnerNamespace = getLLVMStyle(); LLVMWithCompactInnerNamespace.CompactNamespaces = true; LLVMWithCompactInnerNamespace.NamespaceIndentation = FormatStyle::NI_Inner; verifyFormat("namespace ns1 { namespace ns2 { namespace ns3 {\n" "// block for debug mode\n" "#ifndef NDEBUG\n" "#endif\n" "}}} // namespace ns1::ns2::ns3", LLVMWithCompactInnerNamespace); } TEST_F(FormatTest, NamespaceMacros) { FormatStyle Style = getLLVMStyle(); Style.NamespaceMacros.push_back("TESTSUITE"); verifyFormat("TESTSUITE(A) {\n" "int foo();\n" "} // TESTSUITE(A)", Style); verifyFormat("TESTSUITE(A, B) {\n" "int foo();\n" "} // TESTSUITE(A)", Style); // Properly indent according to NamespaceIndentation style Style.NamespaceIndentation = FormatStyle::NI_All; verifyFormat("TESTSUITE(A) {\n" " int foo();\n" "} // TESTSUITE(A)", Style); verifyFormat("TESTSUITE(A) {\n" " namespace B {\n" " int foo();\n" " } // namespace B\n" "} // TESTSUITE(A)", Style); verifyFormat("namespace A {\n" " TESTSUITE(B) {\n" " int foo();\n" " } // TESTSUITE(B)\n" "} // namespace A", Style); Style.NamespaceIndentation = FormatStyle::NI_Inner; verifyFormat("TESTSUITE(A) {\n" "TESTSUITE(B) {\n" " int foo();\n" "} // TESTSUITE(B)\n" "} // TESTSUITE(A)", Style); verifyFormat("TESTSUITE(A) {\n" "namespace B {\n" " int foo();\n" "} // namespace B\n" "} // TESTSUITE(A)", Style); verifyFormat("namespace A {\n" "TESTSUITE(B) {\n" " int foo();\n" "} // TESTSUITE(B)\n" "} // namespace A", Style); // Properly merge namespace-macros blocks in CompactNamespaces mode Style.NamespaceIndentation = FormatStyle::NI_None; Style.CompactNamespaces = true; verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n" "}} // TESTSUITE(A::B)", Style); verifyFormat("TESTSUITE(out) { TESTSUITE(in) {\n" "}} // TESTSUITE(out::in)", "TESTSUITE(out) {\n" "TESTSUITE(in) {\n" "} // TESTSUITE(in)\n" "} // TESTSUITE(out)", Style); verifyFormat("TESTSUITE(out) { TESTSUITE(in) {\n" "}} // TESTSUITE(out::in)", "TESTSUITE(out) {\n" "TESTSUITE(in) {\n" "} // TESTSUITE(in)\n" "} // TESTSUITE(out)", Style); // Do not merge different namespaces/macros verifyFormat("namespace out {\n" "TESTSUITE(in) {\n" "} // TESTSUITE(in)\n" "} // namespace out", Style); verifyFormat("TESTSUITE(out) {\n" "namespace in {\n" "} // namespace in\n" "} // TESTSUITE(out)", Style); Style.NamespaceMacros.push_back("FOOBAR"); verifyFormat("TESTSUITE(out) {\n" "FOOBAR(in) {\n" "} // FOOBAR(in)\n" "} // TESTSUITE(out)", Style); } TEST_F(FormatTest, FormatsCompactNamespaces) { FormatStyle Style = getLLVMStyle(); Style.CompactNamespaces = true; Style.NamespaceMacros.push_back("TESTSUITE"); verifyFormat("namespace A { namespace B {\n" "}} // namespace A::B", Style); verifyFormat("namespace out { namespace in {\n" "}} // namespace out::in", "namespace out {\n" "namespace in {\n" "} // namespace in\n" "} // namespace out", Style); // Only namespaces which have both consecutive opening and end get compacted verifyFormat("namespace out {\n" "namespace in1 {\n" "} // namespace in1\n" "namespace in2 {\n" "} // namespace in2\n" "} // namespace out", Style); verifyFormat("namespace out {\n" "int i;\n" "namespace in {\n" "int j;\n" "} // namespace in\n" "int k;\n" "} // namespace out", "namespace out { int i;\n" "namespace in { int j; } // namespace in\n" "int k; } // namespace out", Style); Style.ColumnLimit = 41; verifyFormat("namespace A { namespace B { namespace C {\n" "}}} // namespace A::B::C", "namespace A { namespace B {\n" "namespace C {\n" "}} // namespace B::C\n" "} // namespace A", Style); Style.ColumnLimit = 40; verifyFormat("namespace aaaaaaaaaa {\n" "namespace bbbbbbbbbb {\n" "}} // namespace aaaaaaaaaa::bbbbbbbbbb", "namespace aaaaaaaaaa {\n" "namespace bbbbbbbbbb {\n" "} // namespace bbbbbbbbbb\n" "} // namespace aaaaaaaaaa", Style); verifyFormat("namespace aaaaaa { namespace bbbbbb {\n" "namespace cccccc {\n" "}}} // namespace aaaaaa::bbbbbb::cccccc", "namespace aaaaaa {\n" "namespace bbbbbb {\n" "namespace cccccc {\n" "} // namespace cccccc\n" "} // namespace bbbbbb\n" "} // namespace aaaaaa", Style); verifyFormat("namespace a { namespace b {\n" "namespace c {\n" "}}} // namespace a::b::c", Style); Style.ColumnLimit = 80; // Extra semicolon after 'inner' closing brace prevents merging verifyFormat("namespace out { namespace in {\n" "}; } // namespace out::in", "namespace out {\n" "namespace in {\n" "}; // namespace in\n" "} // namespace out", Style); // Extra semicolon after 'outer' closing brace is conserved verifyFormat("namespace out { namespace in {\n" "}}; // namespace out::in", "namespace out {\n" "namespace in {\n" "} // namespace in\n" "}; // namespace out", Style); Style.NamespaceIndentation = FormatStyle::NI_All; verifyFormat("namespace out { namespace in {\n" " int i;\n" "}} // namespace out::in", "namespace out {\n" "namespace in {\n" "int i;\n" "} // namespace in\n" "} // namespace out", Style); verifyFormat("namespace out { namespace mid {\n" " namespace in {\n" " int j;\n" " } // namespace in\n" " int k;\n" "}} // namespace out::mid", "namespace out { namespace mid {\n" "namespace in { int j; } // namespace in\n" "int k; }} // namespace out::mid", Style); verifyFormat("namespace A { namespace B { namespace C {\n" " int i;\n" "}}} // namespace A::B::C\n" "int main() {\n" " if (true)\n" " return 0;\n" "}", "namespace A { namespace B {\n" "namespace C {\n" " int i;\n" "}} // namespace B::C\n" "} // namespace A\n" "int main() {\n" " if (true)\n" " return 0;\n" "}", Style); verifyFormat("namespace A { namespace B { namespace C {\n" "#ifdef FOO\n" " int i;\n" "#endif\n" "}}} // namespace A::B::C\n" "int main() {\n" " if (true)\n" " return 0;\n" "}", "namespace A { namespace B {\n" "namespace C {\n" "#ifdef FOO\n" " int i;\n" "#endif\n" "}} // namespace B::C\n" "} // namespace A\n" "int main() {\n" " if (true)\n" " return 0;\n" "}", Style); Style.NamespaceIndentation = FormatStyle::NI_Inner; verifyFormat("namespace out { namespace in {\n" " int i;\n" "}} // namespace out::in", "namespace out {\n" "namespace in {\n" "int i;\n" "} // namespace in\n" "} // namespace out", Style); verifyFormat("namespace out { namespace mid { namespace in {\n" " int i;\n" "}}} // namespace out::mid::in", "namespace out {\n" "namespace mid {\n" "namespace in {\n" "int i;\n" "} // namespace in\n" "} // namespace mid\n" "} // namespace out", Style); Style.CompactNamespaces = true; Style.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None; Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.BeforeLambdaBody = true; verifyFormat("namespace out { namespace in {\n" "}} // namespace out::in", Style); verifyFormat("namespace out { namespace in {\n" "}} // namespace out::in", "namespace out {\n" "namespace in {\n" "} // namespace in\n" "} // namespace out", Style); } TEST_F(FormatTest, FormatsExternC) { verifyFormat("extern \"C\" {\nint a;"); verifyFormat("extern \"C\" {}"); verifyFormat("extern \"C\" {\n" "int foo();\n" "}"); verifyFormat("extern \"C\" int foo() {}"); verifyFormat("extern \"C\" int foo();"); verifyFormat("extern \"C\" int foo() {\n" " int i = 42;\n" " return i;\n" "}"); FormatStyle Style = getLLVMStyle(); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterFunction = true; verifyFormat("extern \"C\" int foo() {}", Style); verifyFormat("extern \"C\" int foo();", Style); verifyFormat("extern \"C\" int foo()\n" "{\n" " int i = 42;\n" " return i;\n" "}", Style); Style.BraceWrapping.AfterExternBlock = true; Style.BraceWrapping.SplitEmptyRecord = false; verifyFormat("extern \"C\"\n" "{}", Style); verifyFormat("extern \"C\"\n" "{\n" " int foo();\n" "}", Style); } TEST_F(FormatTest, IndentExternBlockStyle) { FormatStyle Style = getLLVMStyle(); Style.IndentWidth = 2; Style.IndentExternBlock = FormatStyle::IEBS_Indent; verifyFormat("extern \"C\" { /*9*/\n" "}", Style); verifyFormat("extern \"C\" {\n" " int foo10();\n" "}", Style); Style.IndentExternBlock = FormatStyle::IEBS_NoIndent; verifyFormat("extern \"C\" { /*11*/\n" "}", Style); verifyFormat("extern \"C\" {\n" "int foo12();\n" "}", Style); Style.BreakBeforeBraces = FormatStyle::BS_Allman; verifyFormat("extern \"C\"\n" "{\n" "int i;\n" "}", Style); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterExternBlock = true; Style.IndentExternBlock = FormatStyle::IEBS_Indent; verifyFormat("extern \"C\"\n" "{ /*13*/\n" "}", Style); verifyFormat("extern \"C\"\n{\n" " int foo14();\n" "}", Style); Style.BraceWrapping.AfterExternBlock = false; Style.IndentExternBlock = FormatStyle::IEBS_NoIndent; verifyFormat("extern \"C\" { /*15*/\n" "}", Style); verifyFormat("extern \"C\" {\n" "int foo16();\n" "}", Style); Style.BraceWrapping.AfterExternBlock = true; verifyFormat("extern \"C\"\n" "{ /*13*/\n" "}", Style); verifyFormat("extern \"C\"\n" "{\n" "int foo14();\n" "}", Style); Style.IndentExternBlock = FormatStyle::IEBS_Indent; verifyFormat("extern \"C\"\n" "{ /*13*/\n" "}", Style); verifyFormat("extern \"C\"\n" "{\n" " int foo14();\n" "}", Style); } TEST_F(FormatTest, FormatsInlineASM) { verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"); verifyFormat("asm(\"nop\" ::: \"memory\");"); 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));"); verifyFormat( "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" " __asm {\n" " mov edx,[that] // vtable in edx\n" " mov eax,methodIndex\n" " call [edx][eax*4] // stdcall\n" " }\n" "}", "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n" " __asm {\n" " mov edx,[that] // vtable in edx\n" " mov eax,methodIndex\n" " call [edx][eax*4] // stdcall\n" " }\n" "}"); verifyNoChange("_asm {\n" " xor eax, eax;\n" " cpuid;\n" "}"); verifyFormat("void function() {\n" " // comment\n" " asm(\"\");\n" "}"); verifyFormat("__asm {\n" "}\n" "int i;", "__asm {\n" "}\n" "int i;"); auto Style = getLLVMStyleWithColumns(0); const StringRef Code1{"asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));"}; const StringRef Code2{"asm(\"xyz\"\n" " : \"=a\"(a), \"=d\"(b)\n" " : \"a\"(data));"}; const StringRef Code3{"asm(\"xyz\" : \"=a\"(a), \"=d\"(b)\n" " : \"a\"(data));"}; Style.BreakBeforeInlineASMColon = FormatStyle::BBIAS_OnlyMultiline; verifyFormat(Code1, Style); verifyNoChange(Code2, Style); verifyNoChange(Code3, Style); Style.BreakBeforeInlineASMColon = FormatStyle::BBIAS_Always; verifyFormat(Code2, Code1, Style); verifyNoChange(Code2, Style); verifyFormat(Code2, Code3, Style); } TEST_F(FormatTest, FormatTryCatch) { verifyFormat("try {\n" " throw a * b;\n" "} catch (int a) {\n" " // Do nothing.\n" "} catch (...) {\n" " exit(42);\n" "}"); // Function-level try statements. verifyFormat("int f() try { return 4; } catch (...) {\n" " return 5;\n" "}"); verifyFormat("class A {\n" " int a;\n" " A() try : a(0) {\n" " } catch (...) {\n" " throw;\n" " }\n" "};"); verifyFormat("class A {\n" " int a;\n" " A() try : a(0), b{1} {\n" " } catch (...) {\n" " throw;\n" " }\n" "};"); verifyFormat("class A {\n" " int a;\n" " A() try : a(0), b{1}, c{2} {\n" " } catch (...) {\n" " throw;\n" " }\n" "};"); verifyFormat("class A {\n" " int a;\n" " A() try : a(0), b{1}, c{2} {\n" " { // New scope.\n" " }\n" " } catch (...) {\n" " throw;\n" " }\n" "};"); // Incomplete try-catch blocks. verifyIncompleteFormat("try {} catch ("); } TEST_F(FormatTest, FormatTryAsAVariable) { verifyFormat("int try;"); verifyFormat("int try, size;"); verifyFormat("try = foo();"); verifyFormat("if (try < size) {\n return true;\n}"); verifyFormat("int catch;"); verifyFormat("int catch, size;"); verifyFormat("catch = foo();"); verifyFormat("if (catch < size) {\n return true;\n}"); FormatStyle Style = getLLVMStyle(); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterFunction = true; Style.BraceWrapping.BeforeCatch = true; verifyFormat("try {\n" " int bar = 1;\n" "}\n" "catch (...) {\n" " int bar = 1;\n" "}", Style); verifyFormat("#if NO_EX\n" "try\n" "#endif\n" "{\n" "}\n" "#if NO_EX\n" "catch (...) {\n" "}", Style); verifyFormat("try /* abc */ {\n" " int bar = 1;\n" "}\n" "catch (...) {\n" " int bar = 1;\n" "}", Style); verifyFormat("try\n" "// abc\n" "{\n" " int bar = 1;\n" "}\n" "catch (...) {\n" " int bar = 1;\n" "}", Style); } TEST_F(FormatTest, FormatSEHTryCatch) { verifyFormat("__try {\n" " int a = b * c;\n" "} __except (EXCEPTION_EXECUTE_HANDLER) {\n" " // Do nothing.\n" "}"); verifyFormat("__try {\n" " int a = b * c;\n" "} __finally {\n" " // Do nothing.\n" "}"); verifyFormat("DEBUG({\n" " __try {\n" " } __finally {\n" " }\n" "});"); } TEST_F(FormatTest, IncompleteTryCatchBlocks) { verifyFormat("try {\n" " f();\n" "} catch {\n" " g();\n" "}"); verifyFormat("try {\n" " f();\n" "} catch (A a) MACRO(x) {\n" " g();\n" "} catch (B b) MACRO(x) {\n" " g();\n" "}"); } TEST_F(FormatTest, FormatTryCatchBraceStyles) { FormatStyle Style = getLLVMStyle(); for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla, FormatStyle::BS_WebKit}) { Style.BreakBeforeBraces = BraceStyle; verifyFormat("try {\n" " // something\n" "} catch (...) {\n" " // something\n" "}", Style); } Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; verifyFormat("try {\n" " // something\n" "}\n" "catch (...) {\n" " // something\n" "}", Style); verifyFormat("__try {\n" " // something\n" "}\n" "__finally {\n" " // something\n" "}", Style); verifyFormat("@try {\n" " // something\n" "}\n" "@finally {\n" " // something\n" "}", Style); Style.BreakBeforeBraces = FormatStyle::BS_Allman; verifyFormat("try\n" "{\n" " // something\n" "}\n" "catch (...)\n" "{\n" " // something\n" "}", Style); Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; verifyFormat("try\n" " {\n" " // something white\n" " }\n" "catch (...)\n" " {\n" " // something white\n" " }", Style); Style.BreakBeforeBraces = FormatStyle::BS_GNU; verifyFormat("try\n" " {\n" " // something\n" " }\n" "catch (...)\n" " {\n" " // something\n" " }", Style); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.BeforeCatch = true; verifyFormat("try {\n" " // something\n" "}\n" "catch (...) {\n" " // something\n" "}", Style); } TEST_F(FormatTest, StaticInitializers) { verifyFormat("static SomeClass SC = {1, 'a'};"); verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n" " 100000000, " "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};"); // Here, everything other than the "}" would fit on a line. verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n" " 10000000000000000000000000};"); verifyFormat("S s = {a,\n" "\n" " b};", "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}};", 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};"); verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};"); verifyFormat("const struct A a = {[0] = 1, [1] = 2};"); verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n" " [2] = bbbbbbbbbb,\n" " [3] = cccccccccc,\n" " [4] = dddddddddd,\n" " [5] = eeeeeeeeee};"); verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n" " [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" " [3] = cccccccccccccccccccccccccccccccccccccc,\n" " [4] = dddddddddddddddddddddddddddddddddddddd,\n" " [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};"); verifyFormat("for (const TestCase &test_case : {\n" " TestCase{\n" " .a = 1,\n" " .b = 1,\n" " },\n" " TestCase{\n" " .a = 2,\n" " .b = 2,\n" " },\n" " }) {\n" "}"); } TEST_F(FormatTest, BracedInitializerIndentWidth) { auto Style = getLLVMStyleWithColumns(60); Style.BinPackArguments = true; Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; Style.BracedInitializerIndentWidth = 6; // Non-initializing braces are unaffected by BracedInitializerIndentWidth. verifyFormat("enum class {\n" " One,\n" " Two,\n" "};", Style); verifyFormat("class Foo {\n" " Foo() {}\n" " void bar();\n" "};", Style); verifyFormat("void foo() {\n" " auto bar = baz;\n" " return baz;\n" "};", Style); verifyFormat("auto foo = [&] {\n" " auto bar = baz;\n" " return baz;\n" "};", Style); verifyFormat("{\n" " auto bar = baz;\n" " return baz;\n" "};", Style); // Non-brace initialization is unaffected by BracedInitializerIndentWidth. verifyFormat("SomeClass clazz(\n" " \"xxxxxxxxxxxxxxxxxx\", \"yyyyyyyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzzzzzzz\");", Style); // The following types of initialization are all affected by // BracedInitializerIndentWidth. Aggregate initialization. verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n" " 10000000, 20000000};", Style); verifyFormat("SomeStruct s{\n" " \"xxxxxxxxxxxxxxxx\", \"yyyyyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzzzzz\"};", Style); // Designated initializers. verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n" " [0] = 10000000, [1] = 20000000};", Style); verifyFormat("SomeStruct s{\n" " .foo = \"xxxxxxxxxxxxx\",\n" " .bar = \"yyyyyyyyyyyyy\",\n" " .baz = \"zzzzzzzzzzzzz\"};", Style); // List initialization. verifyFormat("SomeStruct s{\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" "};", Style); verifyFormat("SomeStruct{\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" "};", Style); verifyFormat("new SomeStruct{\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" "};", Style); // Member initializer. verifyFormat("class SomeClass {\n" " SomeStruct s{\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" " };\n" "};", Style); // Constructor member initializer. verifyFormat("SomeClass::SomeClass : strct{\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" " } {}", Style); // Copy initialization. verifyFormat("SomeStruct s = SomeStruct{\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" "};", Style); // Copy list initialization. verifyFormat("SomeStruct s = {\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" "};", Style); // Assignment operand initialization. verifyFormat("s = {\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" "};", Style); // Returned object initialization. verifyFormat("return {\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" "};", Style); // Initializer list. verifyFormat("auto initializerList = {\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" "};", Style); // Function parameter initialization. verifyFormat("func({\n" " \"xxxxxxxxxxxxx\",\n" " \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\",\n" "});", Style); // Nested init lists. verifyFormat("SomeStruct s = {\n" " {{init1, init2, init3, init4, init5},\n" " {init1, init2, init3, init4, init5}}};", Style); verifyFormat("SomeStruct s = {\n" " {{\n" " .init1 = 1,\n" " .init2 = 2,\n" " .init3 = 3,\n" " .init4 = 4,\n" " .init5 = 5,\n" " },\n" " {init1, init2, init3, init4, init5}}};", Style); verifyFormat("SomeArrayT a[3] = {\n" " {\n" " foo,\n" " bar,\n" " },\n" " {\n" " foo,\n" " bar,\n" " },\n" " SomeArrayT{},\n" "};", Style); verifyFormat("SomeArrayT a[3] = {\n" " {foo},\n" " {\n" " {\n" " init1,\n" " init2,\n" " init3,\n" " },\n" " {\n" " init1,\n" " init2,\n" " init3,\n" " },\n" " },\n" " {baz},\n" "};", Style); // Aligning after open braces unaffected by BracedInitializerIndentWidth. Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; verifyFormat("SomeStruct s{\"xxxxxxxxxxxxx\", \"yyyyyyyyyyyyy\",\n" " \"zzzzzzzzzzzzz\"};", Style); } TEST_F(FormatTest, NestedStaticInitializers) { verifyFormat("static A x = {{{}}};"); verifyFormat("static A x = {{{init1, init2, init3, init4},\n" " {init1, init2, init3, init4}}};", getLLVMStyleWithColumns(50)); 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}};", getLLVMStyleWithColumns(60)); 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 = {\n" " {{1, 2, 3},\n" " {1, 2, 3},\n" " {111111111111111111111111111111, 222222222222222222222222222222,\n" " 333333333333333333333333333333},\n" " {1, 2, 3},\n" " {1, 2, 3}}};"); verifyFormat( "SomeArrayOfSomeType a = {\n" " {{1, 2, 3}},\n" " {{1, 2, 3}},\n" " {{111111111111111111111111111111, 222222222222222222222222222222,\n" " 333333333333333333333333333333}},\n" " {{1, 2, 3}},\n" " {{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\"}};"); verifyFormat("struct {\n" " unsigned bit;\n" " const char *const name;\n" "} kBitsToOs[] = {\n" " {kOsMac, \"Mac\"},\n" " {kOsWin, \"Windows\"},\n" " {kOsLinux, \"Linux\"},\n" " {kOsCrOS, \"Chrome OS\"},\n" "};"); } TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) { verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" " \\\n" " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)"); } TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) { verifyFormat("virtual void write(ELFWriter *writerrr,\n" " OwningPtr &buffer) = 0;"); // Do break defaulted and deleted functions. verifyFormat("virtual void ~Deeeeeeeestructor() =\n" " default;", getLLVMStyleWithColumns(40)); verifyFormat("virtual void ~Deeeeeeeestructor() =\n" " delete;", getLLVMStyleWithColumns(40)); } TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) { verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3", getLLVMStyleWithColumns(40)); verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", getLLVMStyleWithColumns(40)); verifyFormat("#define Q \\\n" " \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n" " \"aaaaaaaa.cpp\"", "#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"", getLLVMStyleWithColumns(40)); } TEST_F(FormatTest, UnderstandsLinePPDirective) { verifyFormat("# 123 \"A string literal\"", " # 123 \"A string literal\""); } TEST_F(FormatTest, LayoutUnknownPPDirective) { verifyFormat("#;"); verifyFormat("#\n;\n;\n;"); } TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) { verifyFormat("#line 42 \"test\"", "# \\\n line \\\n 42 \\\n \"test\""); verifyFormat("#define A B", "# \\\n define \\\n A \\\n B", getLLVMStyleWithColumns(12)); } TEST_F(FormatTest, EndOfFileEndsPPDirective) { verifyFormat("#line 42 \"test\"", "# \\\n line \\\n 42 \\\n \"test\""); verifyFormat("#define A B", "# \\\n define \\\n A \\\n B"); } TEST_F(FormatTest, DoesntRemoveUnknownTokens) { verifyFormat("#define A \\x20"); verifyFormat("#define A \\ x20"); verifyFormat("#define A \\ x20", "#define A \\ x20"); verifyFormat("#define A ''"); verifyFormat("#define A ''qqq"); verifyFormat("#define A `qqq"); verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");"); verifyFormat("const char *c = STRINGIFY(\n" "\\na : b);", "const char * c = STRINGIFY(\n" "\\na : b);"); verifyFormat("a\r\\"); verifyFormat("a\v\\"); verifyFormat("a\f\\"); } TEST_F(FormatTest, IndentsPPDirectiveWithPPIndentWidth) { FormatStyle style = getChromiumStyle(FormatStyle::LK_Cpp); style.IndentWidth = 4; style.PPIndentWidth = 1; style.IndentPPDirectives = FormatStyle::PPDIS_None; verifyFormat("#ifdef __linux__\n" "void foo() {\n" " int x = 0;\n" "}\n" "#define FOO\n" "#endif\n" "void bar() {\n" " int y = 0;\n" "}", style); style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; verifyFormat("#ifdef __linux__\n" "void foo() {\n" " int x = 0;\n" "}\n" "# define FOO foo\n" "#endif\n" "void bar() {\n" " int y = 0;\n" "}", style); style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; verifyFormat("#ifdef __linux__\n" "void foo() {\n" " int x = 0;\n" "}\n" " #define FOO foo\n" "#endif\n" "void bar() {\n" " int y = 0;\n" "}", style); verifyFormat("#if 1\n" " // some comments\n" " // another\n" " #define foo 1\n" "// not a define comment\n" "void bar() {\n" " // comment\n" " int y = 0;\n" "}", "#if 1\n" "// some comments\n" "// another\n" "#define foo 1\n" "// not a define comment\n" "void bar() {\n" " // comment\n" " int y = 0;\n" "}", style); style.IndentPPDirectives = FormatStyle::PPDIS_None; verifyFormat("#ifdef foo\n" "#define bar() \\\n" " if (A) { \\\n" " B(); \\\n" " } \\\n" " C();\n" "#endif", style); verifyFormat("if (emacs) {\n" "#ifdef is\n" "#define lit \\\n" " if (af) { \\\n" " return duh(); \\\n" " }\n" "#endif\n" "}", style); verifyFormat("#if abc\n" "#ifdef foo\n" "#define bar() \\\n" " if (A) { \\\n" " if (B) { \\\n" " C(); \\\n" " } \\\n" " } \\\n" " D();\n" "#endif\n" "#endif", style); verifyFormat("#ifndef foo\n" "#define foo\n" "if (emacs) {\n" "#ifdef is\n" "#define lit \\\n" " if (af) { \\\n" " return duh(); \\\n" " }\n" "#endif\n" "}\n" "#endif", style); verifyFormat("#if 1\n" "#define X \\\n" " { \\\n" " x; \\\n" " x; \\\n" " }\n" "#endif", style); verifyFormat("#define X \\\n" " { \\\n" " x; \\\n" " x; \\\n" " }", style); style.PPIndentWidth = 2; verifyFormat("#ifdef foo\n" "#define bar() \\\n" " if (A) { \\\n" " B(); \\\n" " } \\\n" " C();\n" "#endif", style); style.IndentWidth = 8; verifyFormat("#ifdef foo\n" "#define bar() \\\n" " if (A) { \\\n" " B(); \\\n" " } \\\n" " C();\n" "#endif", style); style.IndentWidth = 1; style.PPIndentWidth = 4; verifyFormat("#if 1\n" "#define X \\\n" " { \\\n" " x; \\\n" " x; \\\n" " }\n" "#endif", style); verifyFormat("#define X \\\n" " { \\\n" " x; \\\n" " x; \\\n" " }", style); style.IndentWidth = 4; style.PPIndentWidth = 1; style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; verifyFormat("#ifdef foo\n" "# define bar() \\\n" " if (A) { \\\n" " B(); \\\n" " } \\\n" " C();\n" "#endif", style); verifyFormat("#if abc\n" "# ifdef foo\n" "# define bar() \\\n" " if (A) { \\\n" " if (B) { \\\n" " C(); \\\n" " } \\\n" " } \\\n" " D();\n" "# endif\n" "#endif", style); verifyFormat("#ifndef foo\n" "#define foo\n" "if (emacs) {\n" "#ifdef is\n" "# define lit \\\n" " if (af) { \\\n" " return duh(); \\\n" " }\n" "#endif\n" "}\n" "#endif", style); verifyFormat("#define X \\\n" " { \\\n" " x; \\\n" " x; \\\n" " }", style); style.PPIndentWidth = 2; style.IndentWidth = 8; verifyFormat("#ifdef foo\n" "# define bar() \\\n" " if (A) { \\\n" " B(); \\\n" " } \\\n" " C();\n" "#endif", style); style.PPIndentWidth = 4; style.IndentWidth = 1; verifyFormat("#define X \\\n" " { \\\n" " x; \\\n" " x; \\\n" " }", style); style.IndentWidth = 4; style.PPIndentWidth = 1; style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; verifyFormat("if (emacs) {\n" "#ifdef is\n" " #define lit \\\n" " if (af) { \\\n" " return duh(); \\\n" " }\n" "#endif\n" "}", style); verifyFormat("#if abc\n" " #ifdef foo\n" " #define bar() \\\n" " if (A) { \\\n" " B(); \\\n" " } \\\n" " C();\n" " #endif\n" "#endif", style); verifyFormat("#if 1\n" " #define X \\\n" " { \\\n" " x; \\\n" " x; \\\n" " }\n" "#endif", style); style.PPIndentWidth = 2; verifyFormat("#ifdef foo\n" " #define bar() \\\n" " if (A) { \\\n" " B(); \\\n" " } \\\n" " C();\n" "#endif", style); style.PPIndentWidth = 4; style.IndentWidth = 1; verifyFormat("#if 1\n" " #define X \\\n" " { \\\n" " x; \\\n" " x; \\\n" " }\n" "#endif", style); } 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) { verifyFormat("// somecomment\n" "#include \"a.h\"\n" "#define A( \\\n" " A, B)\n" "#include \"b.h\"\n" "// somecomment", " // somecomment\n" " #include \"a.h\"\n" "#define A(A,\\\n" " B)\n" " #include \"b.h\"\n" " // somecomment", getLLVMStyleWithColumns(13)); } TEST_F(FormatTest, LayoutSingleHash) { verifyFormat("#\na;"); } TEST_F(FormatTest, LayoutCodeInMacroDefinitions) { verifyFormat("#define A \\\n" " c; \\\n" " e;\n" "f;", "#define A c; e;\n" "f;", getLLVMStyleWithColumns(14)); } TEST_F(FormatTest, LayoutRemainingTokens) { verifyFormat("{\n" "}"); } TEST_F(FormatTest, MacroDefinitionInsideStatement) { verifyFormat("int x,\n" "#define A\n" " y;", "int x,\n#define A\ny;"); } TEST_F(FormatTest, HashInMacroDefinition) { verifyFormat("#define A(c) L#c"); verifyFormat("#define A(c) u#c"); verifyFormat("#define A(c) U#c"); verifyFormat("#define A(c) u8#c"); verifyFormat("#define A(c) LR#c"); verifyFormat("#define A(c) uR#c"); verifyFormat("#define A(c) UR#c"); verifyFormat("#define A(c) u8R#c"); 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)); verifyFormat("{\n" " {\n" "#define GEN_ID(_x) char *_x{#_x}\n" " GEN_ID(one);\n" " }\n" "}"); } TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) { verifyFormat("#define A (x)"); verifyFormat("#define A(x)"); FormatStyle Style = getLLVMStyle(); Style.SpaceBeforeParens = FormatStyle::SBPO_Never; verifyFormat("#define true ((foo)1)", Style); Style.SpaceBeforeParens = FormatStyle::SBPO_Always; verifyFormat("#define false((foo)0)", Style); } TEST_F(FormatTest, EmptyLinesInMacroDefinitions) { verifyFormat("#define A b;", "#define A \\\n" " \\\n" " b;", getLLVMStyleWithColumns(25)); verifyNoChange("#define A \\\n" " \\\n" " a; \\\n" " b;", getLLVMStyleWithColumns(11)); verifyNoChange("#define A \\\n" " a; \\\n" " \\\n" " b;", getLLVMStyleWithColumns(11)); } TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) { verifyIncompleteFormat("#define A :"); verifyFormat("#define SOMECASES \\\n" " case 1: \\\n" " case 2", getLLVMStyleWithColumns(20)); verifyFormat("#define MACRO(a) \\\n" " if (a) \\\n" " f(); \\\n" " else \\\n" " g()", getLLVMStyleWithColumns(18)); verifyFormat("#define A template "); verifyIncompleteFormat("#define STR(x) #x\n" "f(STR(this_is_a_string_literal{));"); verifyFormat("#pragma omp threadprivate( \\\n" " y)), // expected-warning", getLLVMStyleWithColumns(28)); verifyFormat("#d, = };"); verifyFormat("#if \"a"); verifyIncompleteFormat("({\n" "#define b \\\n" " } \\\n" " a\n" "a", getLLVMStyleWithColumns(15)); verifyFormat("#define A \\\n" " { \\\n" " {\n" "#define B \\\n" " } \\\n" " }", getLLVMStyleWithColumns(15)); verifyNoCrash("#if a\na(\n#else\n#endif\n{a"); verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}"); verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};"); verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() { \n)}"); verifyNoCrash("#else\n" "#else\n" "#endif\n" "#endif"); verifyNoCrash("#else\n" "#if X\n" "#endif\n" "#endif"); verifyNoCrash("#else\n" "#endif\n" "#if X\n" "#endif"); verifyNoCrash("#if X\n" "#else\n" "#else\n" "#endif\n" "#endif"); verifyNoCrash("#if X\n" "#elif Y\n" "#elif Y\n" "#endif\n" "#endif"); verifyNoCrash("#endif\n" "#endif"); verifyNoCrash("#endif\n" "#else"); verifyNoCrash("#endif\n" "#elif Y"); } TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) { verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline. verifyFormat("class A : public QObject {\n" " Q_OBJECT\n" "\n" " A() {}\n" "};", "class A : public QObject {\n" " Q_OBJECT\n" "\n" " A() {\n}\n" "} ;"); verifyFormat("MACRO\n" "/*static*/ int i;", "MACRO\n" " /*static*/ int i;"); verifyFormat("SOME_MACRO\n" "namespace {\n" "void f();\n" "} // namespace", "SOME_MACRO\n" " namespace {\n" "void f( );\n" "} // namespace"); // Only if the identifier contains at least 5 characters. verifyFormat("HTTP f();", "HTTP\nf();"); verifyNoChange("MACRO\nf();"); // Only if everything is upper case. verifyFormat("class A : public QObject {\n" " Q_Object A() {}\n" "};", "class A : public QObject {\n" " Q_Object\n" " A() {\n}\n" "} ;"); // Only if the next line can actually start an unwrapped line. verifyFormat("SOME_WEIRD_LOG_MACRO << SomeThing;", "SOME_WEIRD_LOG_MACRO\n" "<< SomeThing;"); verifyFormat("GGGG(ffff(xxxxxxxxxxxxxxxxxxxx)->yyyyyyyyyyyyyyyyyyyy)(foo);", "GGGG(ffff(xxxxxxxxxxxxxxxxxxxx)->yyyyyyyyyyyyyyyyyyyy)\n" "(foo);", getLLVMStyleWithColumns(60)); verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), " "(n, buffers))", getChromiumStyle(FormatStyle::LK_Cpp)); // See PR41483 verifyNoChange("/**/ FOO(a)\n" "FOO(b)"); } TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) { verifyFormat("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; }", " 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. verifyFormat("int q() {\n" " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" " IPC_MESSAGE_HANDLER(xxx, qqq)\n" " IPC_END_MESSAGE_MAP()\n" "}", "int q() {\n" " IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n" " IPC_MESSAGE_HANDLER(xxx, qqq)\n" " IPC_END_MESSAGE_MAP()\n" "}"); // Same inside macros. verifyFormat("#define LIST(L) \\\n" " L(A) \\\n" " L(B) \\\n" " L(C)", "#define LIST(L) \\\n" " L(A) \\\n" " L(B) \\\n" " L(C)", getGoogleStyle()); // These must not be recognized as macros. verifyFormat("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" "}", "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" "}"); verifyFormat("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" " } catch (...) {\n" " }\n" "}", "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" "}"); verifyFormat("class A {\n" " A() : t(0) {}\n" " A(int i) noexcept() : {}\n" " A(X x)\n" // FIXME: function-level try blocks are broken. " try : t(0) {\n" " } catch (...) {\n" " }\n" "};", "class A {\n" " A()\n : t(0) {}\n" " A(int i)\n noexcept() : {}\n" " A(X x)\n" " try : t(0) {} catch (...) {}\n" "};"); FormatStyle Style = getLLVMStyle(); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; Style.BraceWrapping.AfterFunction = true; verifyFormat("void f()\n" "try\n" "{\n" "}", "void f() try {\n" "}", Style); verifyFormat("class SomeClass {\n" "public:\n" " SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n" "};", "class SomeClass {\n" "public:\n" " SomeClass()\n" " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" "};"); verifyFormat("class SomeClass {\n" "public:\n" " SomeClass()\n" " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" "};", "class SomeClass {\n" "public:\n" " SomeClass()\n" " EXCLUSIVE_LOCK_FUNCTION(mu_);\n" "};", getLLVMStyleWithColumns(40)); verifyFormat("MACRO(>)"); // Some macros contain an implicit semicolon. Style = getLLVMStyle(); Style.StatementMacros.push_back("FOO"); verifyFormat("FOO(a) int b = 0;"); verifyFormat("FOO(a)\n" "int b = 0;", Style); verifyFormat("FOO(a);\n" "int b = 0;", Style); verifyFormat("FOO(argc, argv, \"4.0.2\")\n" "int b = 0;", Style); verifyFormat("FOO()\n" "int b = 0;", Style); verifyFormat("FOO\n" "int b = 0;", Style); verifyFormat("void f() {\n" " FOO(a)\n" " return a;\n" "}", Style); verifyFormat("FOO(a)\n" "FOO(b)", Style); verifyFormat("int a = 0;\n" "FOO(b)\n" "int c = 0;", Style); verifyFormat("int a = 0;\n" "int x = FOO(a)\n" "int b = 0;", Style); verifyFormat("void foo(int a) { FOO(a) }\n" "uint32_t bar() {}", Style); } TEST_F(FormatTest, FormatsMacrosWithZeroColumnWidth) { FormatStyle ZeroColumn = getLLVMStyleWithColumns(0); verifyFormat("#define A LOOOOOOOOOOOOOOOOOOONG() LOOOOOOOOOOOOOOOOOOONG()", ZeroColumn); } TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) { verifyFormat("#define A \\\n" " f({ \\\n" " g(); \\\n" " });", getLLVMStyleWithColumns(11)); } TEST_F(FormatTest, IndentPreprocessorDirectives) { FormatStyle Style = getLLVMStyleWithColumns(40); Style.IndentPPDirectives = FormatStyle::PPDIS_None; verifyFormat("#ifdef _WIN32\n" "#define A 0\n" "#ifdef VAR2\n" "#define B 1\n" "#include \n" "#define MACRO \\\n" " some_very_long_func_aaaaaaaaaa();\n" "#endif\n" "#else\n" "#define A 1\n" "#endif", Style); Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash; verifyFormat("#if 1\n" "# define __STR(x) #x\n" "#endif", Style); verifyFormat("#ifdef _WIN32\n" "# define A 0\n" "# ifdef VAR2\n" "# define B 1\n" "# include \n" "# define MACRO \\\n" " some_very_long_func_aaaaaaaaaa();\n" "# endif\n" "#else\n" "# define A 1\n" "#endif", Style); verifyFormat("#if A\n" "# define MACRO \\\n" " void a(int x) { \\\n" " b(); \\\n" " c(); \\\n" " d(); \\\n" " e(); \\\n" " f(); \\\n" " }\n" "#endif", Style); // Comments before include guard. verifyFormat("// file comment\n" "// file comment\n" "#ifndef HEADER_H\n" "#define HEADER_H\n" "code();\n" "#endif", Style); // Test with include guards. verifyFormat("#ifndef HEADER_H\n" "#define HEADER_H\n" "code();\n" "#endif", Style); // Include guards must have a #define with the same variable immediately // after #ifndef. verifyFormat("#ifndef NOT_GUARD\n" "# define FOO\n" "code();\n" "#endif", Style); // Include guards must cover the entire file. verifyFormat("code();\n" "code();\n" "#ifndef NOT_GUARD\n" "# define NOT_GUARD\n" "code();\n" "#endif", Style); verifyFormat("#ifndef NOT_GUARD\n" "# define NOT_GUARD\n" "code();\n" "#endif\n" "code();", Style); // Test with trailing blank lines. verifyFormat("#ifndef HEADER_H\n" "#define HEADER_H\n" "code();\n" "#endif", Style); // Include guards don't have #else. verifyFormat("#ifndef NOT_GUARD\n" "# define NOT_GUARD\n" "code();\n" "#else\n" "#endif", Style); verifyFormat("#ifndef NOT_GUARD\n" "# define NOT_GUARD\n" "code();\n" "#elif FOO\n" "#endif", Style); // Non-identifier #define after potential include guard. verifyFormat("#ifndef FOO\n" "# define 1\n" "#endif", Style); // #if closes past last non-preprocessor line. verifyFormat("#ifndef FOO\n" "#define FOO\n" "#if 1\n" "int i;\n" "# define A 0\n" "#endif\n" "#endif", Style); // Don't crash if there is an #elif directive without a condition. verifyFormat("#if 1\n" "int x;\n" "#elif\n" "int y;\n" "#else\n" "int z;\n" "#endif", Style); // FIXME: This doesn't handle the case where there's code between the // #ifndef and #define but all other conditions hold. This is because when // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the // previous code line yet, so we can't detect it. verifyFormat("#ifndef NOT_GUARD\n" "code();\n" "#define NOT_GUARD\n" "code();\n" "#endif", "#ifndef NOT_GUARD\n" "code();\n" "# define NOT_GUARD\n" "code();\n" "#endif", Style); // FIXME: This doesn't handle cases where legitimate preprocessor lines may // be outside an include guard. Examples are #pragma once and // #pragma GCC diagnostic, or anything else that does not change the meaning // of the file if it's included multiple times. verifyFormat("#ifdef WIN32\n" "# pragma once\n" "#endif\n" "#ifndef HEADER_H\n" "# define HEADER_H\n" "code();\n" "#endif", "#ifdef WIN32\n" "# pragma once\n" "#endif\n" "#ifndef HEADER_H\n" "#define HEADER_H\n" "code();\n" "#endif", Style); // FIXME: This does not detect when there is a single non-preprocessor line // in front of an include-guard-like structure where other conditions hold // because ScopedLineState hides the line. verifyFormat("code();\n" "#ifndef HEADER_H\n" "#define HEADER_H\n" "code();\n" "#endif", "code();\n" "#ifndef HEADER_H\n" "# define HEADER_H\n" "code();\n" "#endif", Style); // Keep comments aligned with #, otherwise indent comments normally. These // tests cannot use verifyFormat because messUp manipulates leading // whitespace. { const char *Expected = "" "void f() {\n" "#if 1\n" "// Preprocessor aligned.\n" "# define A 0\n" " // Code. Separated by blank line.\n" "\n" "# define B 0\n" " // Code. Not aligned with #\n" "# define C 0\n" "#endif"; const char *ToFormat = "" "void f() {\n" "#if 1\n" "// Preprocessor aligned.\n" "# define A 0\n" "// Code. Separated by blank line.\n" "\n" "# define B 0\n" " // Code. Not aligned with #\n" "# define C 0\n" "#endif"; verifyFormat(Expected, ToFormat, Style); verifyNoChange(Expected, Style); } // Keep block quotes aligned. { const char *Expected = "" "void f() {\n" "#if 1\n" "/* Preprocessor aligned. */\n" "# define A 0\n" " /* Code. Separated by blank line. */\n" "\n" "# define B 0\n" " /* Code. Not aligned with # */\n" "# define C 0\n" "#endif"; const char *ToFormat = "" "void f() {\n" "#if 1\n" "/* Preprocessor aligned. */\n" "# define A 0\n" "/* Code. Separated by blank line. */\n" "\n" "# define B 0\n" " /* Code. Not aligned with # */\n" "# define C 0\n" "#endif"; verifyFormat(Expected, ToFormat, Style); verifyNoChange(Expected, Style); } // Keep comments aligned with un-indented directives. { const char *Expected = "" "void f() {\n" "// Preprocessor aligned.\n" "#define A 0\n" " // Code. Separated by blank line.\n" "\n" "#define B 0\n" " // Code. Not aligned with #\n" "#define C 0\n"; const char *ToFormat = "" "void f() {\n" "// Preprocessor aligned.\n" "#define A 0\n" "// Code. Separated by blank line.\n" "\n" "#define B 0\n" " // Code. Not aligned with #\n" "#define C 0\n"; verifyFormat(Expected, ToFormat, Style); verifyNoChange(Expected, Style); } // Test AfterHash with tabs. { FormatStyle Tabbed = Style; Tabbed.UseTab = FormatStyle::UT_Always; Tabbed.IndentWidth = 8; Tabbed.TabWidth = 8; verifyFormat("#ifdef _WIN32\n" "#\tdefine A 0\n" "#\tifdef VAR2\n" "#\t\tdefine B 1\n" "#\t\tinclude \n" "#\t\tdefine MACRO \\\n" "\t\t\tsome_very_long_func_aaaaaaaaaa();\n" "#\tendif\n" "#else\n" "#\tdefine A 1\n" "#endif", Tabbed); } // Regression test: Multiline-macro inside include guards. verifyFormat("#ifndef HEADER_H\n" "#define HEADER_H\n" "#define A() \\\n" " int i; \\\n" " int j;\n" "#endif // HEADER_H", getLLVMStyleWithColumns(20)); Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash; // Basic before hash indent tests verifyFormat("#ifdef _WIN32\n" " #define A 0\n" " #ifdef VAR2\n" " #define B 1\n" " #include \n" " #define MACRO \\\n" " some_very_long_func_aaaaaaaaaa();\n" " #endif\n" "#else\n" " #define A 1\n" "#endif", Style); verifyFormat("#if A\n" " #define MACRO \\\n" " void a(int x) { \\\n" " b(); \\\n" " c(); \\\n" " d(); \\\n" " e(); \\\n" " f(); \\\n" " }\n" "#endif", Style); // Keep comments aligned with indented directives. These // tests cannot use verifyFormat because messUp manipulates leading // whitespace. { const char *Expected = "void f() {\n" "// Aligned to preprocessor.\n" "#if 1\n" " // Aligned to code.\n" " int a;\n" " #if 1\n" " // Aligned to preprocessor.\n" " #define A 0\n" " // Aligned to code.\n" " int b;\n" " #endif\n" "#endif\n" "}"; const char *ToFormat = "void f() {\n" "// Aligned to preprocessor.\n" "#if 1\n" "// Aligned to code.\n" "int a;\n" "#if 1\n" "// Aligned to preprocessor.\n" "#define A 0\n" "// Aligned to code.\n" "int b;\n" "#endif\n" "#endif\n" "}"; verifyFormat(Expected, ToFormat, Style); verifyNoChange(Expected, Style); } { const char *Expected = "void f() {\n" "/* Aligned to preprocessor. */\n" "#if 1\n" " /* Aligned to code. */\n" " int a;\n" " #if 1\n" " /* Aligned to preprocessor. */\n" " #define A 0\n" " /* Aligned to code. */\n" " int b;\n" " #endif\n" "#endif\n" "}"; const char *ToFormat = "void f() {\n" "/* Aligned to preprocessor. */\n" "#if 1\n" "/* Aligned to code. */\n" "int a;\n" "#if 1\n" "/* Aligned to preprocessor. */\n" "#define A 0\n" "/* Aligned to code. */\n" "int b;\n" "#endif\n" "#endif\n" "}"; verifyFormat(Expected, ToFormat, Style); verifyNoChange(Expected, Style); } // Test single comment before preprocessor verifyFormat("// Comment\n" "\n" "#if 1\n" "#endif", Style); } TEST_F(FormatTest, FormatAlignInsidePreprocessorElseBlock) { FormatStyle Style = getLLVMStyle(); Style.AlignConsecutiveAssignments.Enabled = true; Style.AlignConsecutiveDeclarations.Enabled = true; // Test with just #if blocks. verifyFormat("void f1() {\n" "#if 1\n" " int foo = 1;\n" " int foobar = 2;\n" "#endif\n" "}\n" "#if 1\n" "int baz = 3;\n" "#endif\n" "void f2() {\n" "#if 1\n" " char *foobarbaz = \"foobarbaz\";\n" " int quux = 4;\n" "}", Style); // Test with just #else blocks. verifyFormat("void f1() {\n" "#if 1\n" "#else\n" " int foo = 1;\n" " int foobar = 2;\n" "#endif\n" "}\n" "#if 1\n" "#else\n" "int baz = 3;\n" "#endif\n" "void f2() {\n" "#if 1\n" "#else\n" " char *foobarbaz = \"foobarbaz\";\n" " int quux = 4;\n" "}", Style); verifyFormat("auto foo = [] { return; };\n" "#if FOO\n" "#else\n" "count = bar;\n" "mbid = bid;\n" "#endif", Style); // Test with a mix of #if and #else blocks. verifyFormat("void f1() {\n" "#if 1\n" "#else\n" " int foo = 1;\n" " int foobar = 2;\n" "#endif\n" "}\n" "#if 1\n" "int baz = 3;\n" "#endif\n" "void f2() {\n" "#if 1\n" "#else\n" " // prevent alignment with #else in f1\n" " char *foobarbaz = \"foobarbaz\";\n" " int quux = 4;\n" "}", Style); // Test with nested #if and #else blocks. verifyFormat("void f1() {\n" "#if 1\n" "#else\n" "#if 2\n" "#else\n" " int foo = 1;\n" " int foobar = 2;\n" "#endif\n" "#endif\n" "}\n" "#if 1\n" "#else\n" "#if 2\n" "int baz = 3;\n" "#endif\n" "#endif\n" "void f2() {\n" "#if 1\n" "#if 2\n" "#else\n" " // prevent alignment with #else in f1\n" " char *foobarbaz = \"foobarbaz\";\n" " int quux = 4;\n" "#endif\n" "#endif\n" "}", Style); verifyFormat("#if FOO\n" "int a = 1;\n" "#else\n" "int ab = 2;\n" "#endif\n" "#ifdef BAR\n" "int abc = 3;\n" "#elifdef BAZ\n" "int abcd = 4;\n" "#endif", Style); verifyFormat("void f() {\n" " if (foo) {\n" "#if FOO\n" " int a = 1;\n" "#else\n" " bool a = true;\n" "#endif\n" " int abc = 3;\n" "#ifndef BAR\n" " int abcd = 4;\n" "#elif BAZ\n" " bool abcd = true;\n" "#endif\n" " }\n" "}", Style); verifyFormat("void f() {\n" "#if FOO\n" " a = 1;\n" "#else\n" " ab = 2;\n" "#endif\n" "}\n" "void g() {\n" "#if BAR\n" " abc = 3;\n" "#elifndef BAZ\n" " abcd = 4;\n" "#endif\n" "}", Style); } TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) { verifyFormat("{\n" " {\n" " a #c;\n" " }\n" "}"); } TEST_F(FormatTest, FormatUnbalancedStructuralElements) { verifyFormat("#define A \\\n { \\\n {\nint i;", "#define A { {\nint i;", getLLVMStyleWithColumns(11)); verifyFormat("#define A \\\n } \\\n }\nint i;", "#define A } }\nint i;", getLLVMStyleWithColumns(11)); } TEST_F(FormatTest, EscapedNewlines) { FormatStyle Narrow = getLLVMStyleWithColumns(11); verifyFormat("#define A \\\n int i; \\\n int j;", "#define A \\\nint i;\\\n int j;", Narrow); verifyFormat("#define A\n\nint i;", "#define A \\\n\n int i;"); verifyFormat("template f();", "\\\ntemplate f();"); verifyFormat("/* \\ \\ \\\n */", "\\\n/* \\ \\ \\\n */"); verifyNoChange(""); FormatStyle AlignLeft = getLLVMStyle(); AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left; verifyFormat("#define MACRO(x) \\\n" "private: \\\n" " int x(int a);", AlignLeft); // CRLF line endings verifyFormat("#define A \\\r\n int i; \\\r\n int j;", "#define A \\\r\nint i;\\\r\n int j;", Narrow); verifyFormat("#define A\r\n\r\nint i;", "#define A \\\r\n\r\n int i;"); verifyFormat("template f();", "\\\ntemplate f();"); verifyFormat("/* \\ \\ \\\r\n */", "\\\r\n/* \\ \\ \\\r\n */"); verifyNoChange(""); verifyFormat("#define MACRO(x) \\\r\n" "private: \\\r\n" " int x(int a);", AlignLeft); constexpr StringRef Code{"#define A \\\n" " int a123; \\\n" " int a; \\\n" " int a1234;"}; verifyFormat(Code, AlignLeft); constexpr StringRef Code2{"#define A \\\n" " int a123; \\\n" " int a; \\\n" " int a1234;"}; auto LastLine = getLLVMStyle(); LastLine.AlignEscapedNewlines = FormatStyle::ENAS_LeftWithLastLine; verifyFormat(Code2, LastLine); LastLine.ColumnLimit = 13; verifyFormat(Code, LastLine); LastLine.ColumnLimit = 0; verifyFormat(Code2, LastLine); FormatStyle DontAlign = getLLVMStyle(); DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign; DontAlign.MaxEmptyLinesToKeep = 3; // FIXME: can't use verifyFormat here because the newline before // "public:" is not inserted the first time it's reformatted verifyNoChange("#define A \\\n" " class Foo { \\\n" " void bar(); \\\n" "\\\n" "\\\n" "\\\n" " public: \\\n" " void baz(); \\\n" " };", DontAlign); } TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) { verifyFormat("#define A \\\n" " int v( \\\n" " a); \\\n" " int i;", getLLVMStyleWithColumns(11)); } TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) { verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro(" " \\\n" " aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" "\n" "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);", " #define ALooooooooooooooooooooooooooooooooooooooongMacro(" "\\\n" "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n" " \n" " AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n" " aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);"); } TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) { verifyFormat("int\n" "#define A\n" " a;", "int\n#define A\na;"); 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"); verifyFormat("DEBUG({\n" " return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n" "});\n" "#if a\n" "#else\n" "#endif"); verifyIncompleteFormat("void f(\n" "#if A\n" ");\n" "#else\n" "#endif"); // Verify that indentation is correct when there is an `#if 0` with an // `#else`. verifyFormat("#if 0\n" "{\n" "#else\n" "{\n" "#endif\n" " x;\n" "}"); verifyFormat("#if 0\n" "#endif\n" "#if X\n" "int something_fairly_long; // Align here please\n" "#endif // Should be aligned"); verifyFormat("#if 0\n" "#endif\n" "#if X\n" "#else // Align\n" ";\n" "#endif // Align"); verifyFormat("void SomeFunction(int param1,\n" " template <\n" "#ifdef A\n" "#if 0\n" "#endif\n" " MyType>\n" "#else\n" " Type1, Type2>\n" "#endif\n" " param2,\n" " param3) {\n" " f();\n" "}"); } TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) { verifyFormat("#endif\n" "#if B"); } TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) { FormatStyle SingleLine = getLLVMStyle(); SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse; verifyFormat("#if 0\n" "#elif 1\n" "#endif\n" "void foo() {\n" " if (test) foo2();\n" "}", SingleLine); } TEST_F(FormatTest, LayoutBlockInsideParens) { verifyFormat("functionCall({ int i; });"); verifyFormat("functionCall({\n" " int i;\n" " int j;\n" "});"); verifyFormat("functionCall(\n" " {\n" " int i;\n" " int j;\n" " },\n" " aaaa, bbbb, cccc);"); verifyFormat("functionA(functionB({\n" " int i;\n" " int j;\n" " }),\n" " aaaa, bbbb, cccc);"); verifyFormat("functionCall(\n" " {\n" " int i;\n" " int j;\n" " },\n" " aaaa, bbbb, // comment\n" " cccc);"); verifyFormat("functionA(functionB({\n" " int i;\n" " int j;\n" " }),\n" " aaaa, bbbb, // comment\n" " cccc);"); verifyFormat("functionCall(aaaa, bbbb, { int i; });"); verifyFormat("functionCall(aaaa, bbbb, {\n" " int i;\n" " int j;\n" "});"); verifyFormat( "Aaa(\n" // FIXME: There shouldn't be a linebreak here. " {\n" " int i; // break\n" " },\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n" " ccccccccccccccccc));"); verifyFormat("DEBUG({\n" " if (a)\n" " f();\n" "});"); } TEST_F(FormatTest, LayoutBlockInsideStatement) { verifyFormat("SOME_MACRO { int i; }\n" "int i;", " 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)); verifyFormat("DEBUG( //\n" " { f(); }, a);"); verifyFormat("DEBUG( //\n" " {\n" " f(); //\n" " },\n" " a);"); verifyFormat("call(parameter, {\n" " something();\n" " // Comment too\n" " // looooooooooong.\n" " somethingElse();\n" "});", "call(parameter, {\n" " something();\n" " // Comment too looooooooooong.\n" " somethingElse();\n" "});", getLLVMStyleWithColumns(29)); verifyFormat("DEBUG({ int i; });", "DEBUG({ int i; });"); verifyFormat("DEBUG({ // comment\n" " int i;\n" "});", "DEBUG({ // comment\n" "int i;\n" "});"); verifyFormat("DEBUG({\n" " int i;\n" "\n" " // comment\n" " int j;\n" "});", "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(\n" " aaaaa,\n" " {\n" " if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n" " },\n" " a);", Style); verifyFormat("SomeFunction({MACRO({ return output; }), b});"); verifyNoCrash("^{v^{a}}"); } TEST_F(FormatTest, FormatNestedBlocksInMacros) { verifyFormat("#define MACRO() \\\n" " Debug(aaa, /* force line break */ \\\n" " { \\\n" " int i; \\\n" " int j; \\\n" " })", "#define MACRO() Debug(aaa, /* force line break */ \\\n" " { int i; int j; })", getGoogleStyle()); verifyFormat("#define A \\\n" " [] { \\\n" " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" " xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n" " }", "#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n" "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }", getGoogleStyle()); } TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) { verifyFormat("enum E {};"); verifyFormat("enum E {}"); FormatStyle Style = getLLVMStyle(); Style.SpaceInEmptyBlock = true; verifyFormat("void f() { }", "void f() {}", Style); Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; verifyFormat("{ }", Style); verifyFormat("while (true) { }", "while (true) {}", Style); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.BeforeElse = false; Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always; verifyFormat("if (a)\n" "{\n" "} else if (b)\n" "{\n" "} else\n" "{ }", Style); Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never; verifyFormat("if (a) {\n" "} else if (b) {\n" "} else {\n" "}", Style); Style.BraceWrapping.BeforeElse = true; verifyFormat("if (a) { }\n" "else if (b) { }\n" "else { }", Style); Style = getLLVMStyle(FormatStyle::LK_CSharp); Style.SpaceInEmptyBlock = true; verifyFormat("Event += () => { };", Style); } TEST_F(FormatTest, FormatBeginBlockEndMacros) { FormatStyle Style = getLLVMStyle(); Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$"; Style.MacroBlockEnd = "^[A-Z_]+_END$"; verifyFormat("FOO_BEGIN\n" " FOO_ENTRY\n" "FOO_END", Style); verifyFormat("FOO_BEGIN\n" " NESTED_FOO_BEGIN\n" " NESTED_FOO_ENTRY\n" " NESTED_FOO_END\n" "FOO_END", Style); verifyFormat("FOO_BEGIN(Foo, Bar)\n" " int x;\n" " x = 1;\n" "FOO_END(Baz)", Style); Style.RemoveBracesLLVM = true; verifyNoCrash("for (;;)\n" " FOO_BEGIN\n" " foo();\n" " FOO_END", Style); } //===----------------------------------------------------------------------===// // 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 &&\n" " 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 aaaaaaa =\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n" " bbbbbbbb();"); verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n" " ccccccccc == ddddddddddd;"); verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n" " ccccccccc == ddddddddddd;"); verifyFormat( "bool aaaaaaaaaaaaaaaaaaaaa =\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n" " ccccccccc == ddddddddddd;"); verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" " aaaaaa) &&\n" " bbbbbb && cccccc;"); verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n" " aaaaaa) >>\n" " bbbbbb;"); verifyFormat("aa = Whitespaces.addUntouchableComment(\n" " SourceMgr.getSpellingColumnNumber(\n" " TheLine.Last->FormatTok.Tok.getLocation()) -\n" " 1);"); verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n" " cccccc) {\n}"); verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" " cccccc) {\n}"); verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" " bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n" " cccccc) {\n}"); verifyFormat("b = a &&\n" " // Comment\n" " b.c && d;"); // 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" "}"); verifyFormat( "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\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" "}"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n" " 5) {\n" "}"); FormatStyle OnePerLine = getLLVMStyle(); OnePerLine.BinPackParameters = FormatStyle::BPPS_OnePerLine; verifyFormat( "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}", OnePerLine); verifyFormat("int i = someFunction(aaaaaaa, 0)\n" " .aaa(aaaaaaaaaaaaa) *\n" " aaaaaaa +\n" " aaaaaaa;", getLLVMStyleWithColumns(40)); } 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" "}"); verifyFormat("if () {\n" "} else if constexpr (aaaaa && bbbbb > // break\n" " ccccc) {\n" "}"); verifyFormat("if () {\n" "} else if CONSTEXPR (aaaaa && bbbbb > // break\n" " ccccc) {\n" "}"); verifyFormat("if () {\n" "} else if (aaaaa &&\n" " bbbbb > // break\n" " ccccc &&\n" " ddddd) {\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 = FormatStyle::BOS_All; 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\n" " && bbbbb // break\n" " > ccccc) {\n" "}", Style); verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", Style); verifyFormat("return (a)\n" " // comment\n" " + b;", Style); verifyFormat( "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" " + cc;", Style); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", 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)"); verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" " == boost::fusion::at_c<1>(iiii).second;", Style); Style.ColumnLimit = 60; verifyFormat("zzzzzzzzzz\n" " = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", Style); Style.ColumnLimit = 80; Style.IndentWidth = 4; Style.TabWidth = 4; Style.UseTab = FormatStyle::UT_Always; Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; Style.AlignOperands = FormatStyle::OAS_DontAlign; verifyFormat("return someVeryVeryLongConditionThatBarelyFitsOnALine\n" "\t&& (someOtherLongishConditionPart1\n" "\t\t|| someOtherEvenLongerNestedConditionPart2);", "return someVeryVeryLongConditionThatBarelyFitsOnALine && " "(someOtherLongishConditionPart1 || " "someOtherEvenLongerNestedConditionPart2);", Style); Style = getLLVMStyleWithColumns(20); Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; Style.ContinuationIndentWidth = 2; verifyFormat("struct Foo {\n" " Foo(\n" " int arg1,\n" " int arg2)\n" " : Base(\n" " arg1,\n" " arg2) {}\n" "};", Style); verifyFormat("return abc\n" " ? foo(\n" " a,\n" " b,\n" " bar(\n" " abc))\n" " : g(abc);", Style); } TEST_F(FormatTest, ExpressionIndentationStrictAlign) { FormatStyle Style = getLLVMStyle(); Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator; 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\n" " && bbbbb // break\n" " > ccccc) {\n" "}", Style); verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", Style); verifyFormat("return (a)\n" " // comment\n" " + b;", Style); verifyFormat( "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" " + cc;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" " : bbbbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : ccccccccccccccc ? dddddddddddddddddd\n" " : eeeeeeeeeeeeeeeeee)\n" " : bbbbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;", Style); verifyFormat("return boost::fusion::at_c<0>(iiii).second\n" " == boost::fusion::at_c<1>(iiii).second;", Style); Style.ColumnLimit = 60; verifyFormat("zzzzzzzzzzzzz\n" " = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" " >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);", Style); // Forced by comments. Style.ColumnLimit = 80; 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)", Style); Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; 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)", Style); Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; 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)", Style); } TEST_F(FormatTest, EnforcedOperatorWraps) { // Here we'd like to wrap after the || operators, but a comment is forcing an // earlier wrap. verifyFormat("bool x = aaaaa //\n" " || bbbbb\n" " //\n" " || cccc;"); } TEST_F(FormatTest, NoOperandAlignment) { FormatStyle Style = getLLVMStyle(); Style.AlignOperands = FormatStyle::OAS_DontAlign; verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", Style); Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" " && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " > ccccccccccccccccccccccccccccccccccccccccc;", Style); verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" " + cc;", Style); verifyFormat("int a = aa\n" " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" " * cccccccccccccccccccccccccccccccccccc;", Style); Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; verifyFormat("return (a > b\n" " // comment1\n" " // comment2\n" " || c);", Style); } TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) { FormatStyle Style = getLLVMStyle(); Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;", Style); } TEST_F(FormatTest, AllowBinPackingInsideArguments) { FormatStyle Style = getLLVMStyleWithColumns(40); Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; Style.BinPackArguments = false; verifyFormat("void test() {\n" " someFunction(\n" " this + argument + is + quite\n" " + long + so + it + gets + wrapped\n" " + but + remains + bin - packed);\n" "}", Style); verifyFormat("void test() {\n" " someFunction(arg1,\n" " this + argument + is\n" " + quite + long + so\n" " + it + gets + wrapped\n" " + but + remains + bin\n" " - packed,\n" " arg3);\n" "}", Style); verifyFormat("void test() {\n" " someFunction(\n" " arg1,\n" " this + argument + has\n" " + anotherFunc(nested,\n" " calls + whose\n" " + arguments\n" " + are + also\n" " + wrapped,\n" " in + addition)\n" " + to + being + bin - packed,\n" " arg3);\n" "}", Style); Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None; verifyFormat("void test() {\n" " someFunction(\n" " arg1,\n" " this + argument + has +\n" " anotherFunc(nested,\n" " calls + whose +\n" " arguments +\n" " are + also +\n" " wrapped,\n" " in + addition) +\n" " to + being + bin - packed,\n" " arg3);\n" "}", Style); } TEST_F(FormatTest, BreakBinaryOperatorsInPresenceOfTemplates) { auto Style = getLLVMStyleWithColumns(45); EXPECT_EQ(Style.BreakBeforeBinaryOperators, FormatStyle::BOS_None); verifyFormat("bool b =\n" " is_default_constructible_v> and\n" " is_copy_constructible_v> and\n" " is_move_constructible_v> and\n" " is_copy_assignable_v> and\n" " is_move_assignable_v> and\n" " is_destructible_v> and\n" " is_swappable_v> and\n" " is_callable_v(T)>;", Style); Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment; verifyFormat("bool b = is_default_constructible_v>\n" " and is_copy_constructible_v>\n" " and is_move_constructible_v>\n" " and is_copy_assignable_v>\n" " and is_move_assignable_v>\n" " and is_destructible_v>\n" " and is_swappable_v>\n" " and is_callable_v(T)>;", Style); Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All; verifyFormat("bool b = is_default_constructible_v>\n" " and is_copy_constructible_v>\n" " and is_move_constructible_v>\n" " and is_copy_assignable_v>\n" " and is_move_assignable_v>\n" " and is_destructible_v>\n" " and is_swappable_v>\n" " and is_callable_v(T)>;", Style); } 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("template \n" "Constructor() : Initializer(FitsOnTheLine) {}", getLLVMStyleWithColumns(45)); 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(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " : aaaaaaaaaa(aaaaaa) {}"); 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 desirable. verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaa(aaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}"); FormatStyle OnePerLine = getLLVMStyle(); OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_Never; verifyFormat("MyClass::MyClass()\n" " : a(a),\n" " b(b),\n" " c(c) {}", OnePerLine); verifyFormat("MyClass::MyClass()\n" " : a(a), // comment\n" " b(b),\n" " c(c) {}", OnePerLine); verifyFormat("MyClass::MyClass(int a)\n" " : b(a), // comment\n" " c(a + 1) { // lined up\n" "}", OnePerLine); verifyFormat("Constructor()\n" " : a(b, b, b) {}", OnePerLine); OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_NextLine; OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false; 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); OnePerLine.BinPackParameters = FormatStyle::BPPS_OnePerLine; verifyFormat( "Constructor()\n" " : aaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaa().aaa(),\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", OnePerLine); OnePerLine.ColumnLimit = 60; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", OnePerLine); verifyFormat("Constructor()\n" " : // Comment forcing unwanted break.\n" " aaaa(aaaa) {}", "Constructor() :\n" " // Comment forcing unwanted break.\n" " aaaa(aaaa) {}"); } TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) { FormatStyle Style = getLLVMStyleWithColumns(60); Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; for (int i = 0; i < 4; ++i) { // Test all combinations of parameters that should not have an effect. Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; Style.AllowAllArgumentsOnNextLine = i & 2; Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); verifyFormat("Constructor() : a(a), b(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a)\n" " , bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); verifyFormat("Constructor() : a(a), b(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLineOnly; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); verifyFormat("Constructor()\n" " : a(a), b(b) {}", Style); verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a)\n" " , bbbbbbbbbbbbbbbbbbbbb(b)\n" " , cccccccccccccccccccccc(c) {}", Style); Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLineOnly; verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); verifyFormat("Constructor()\n" " : a(a), b(b) {}", Style); verifyFormat("Constructor()\n" " : aaaaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbb(b),\n" " cccccccccccccccccccccc(c) {}", Style); Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLineOnly; verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); verifyFormat("Constructor() :\n" " a(a), b(b) {}", Style); verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbb(b),\n" " cccccccccccccccccccccc(c) {}", Style); } // Test interactions between AllowAllParametersOfDeclarationOnNextLine and // AllowAllConstructorInitializersOnNextLine in all // BreakConstructorInitializers modes Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma; Style.AllowAllParametersOfDeclarationOnNextLine = true; Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" " : aaaaaaaaaaaaaaaaaaaa(a)\n" " , bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb,\n" " int cccccccccccccccc)\n" " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLineOnly; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb,\n" " int cccccccccccccccc)\n" " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.AllowAllParametersOfDeclarationOnNextLine = false; Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb)\n" " : aaaaaaaaaaaaaaaaaaaa(a)\n" " , bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon; Style.AllowAllParametersOfDeclarationOnNextLine = true; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n" " : aaaaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb,\n" " int cccccccccccccccc)\n" " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLineOnly; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb,\n" " int cccccccccccccccc)\n" " : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.AllowAllParametersOfDeclarationOnNextLine = false; Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb)\n" " : aaaaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; Style.AllowAllParametersOfDeclarationOnNextLine = true; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n" " aaaaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb,\n" " int cccccccccccccccc) :\n" " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLineOnly; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb,\n" " int cccccccccccccccc) :\n" " aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style.AllowAllParametersOfDeclarationOnNextLine = false; Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("SomeClassWithALongName::Constructor(\n" " int aaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb) :\n" " aaaaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbb(b) {}", Style); Style = getLLVMStyleWithColumns(0); Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; verifyFormat("Foo(Bar bar, Baz baz) : bar(bar), baz(baz) {}", Style); verifyNoChange("Foo(Bar bar, Baz baz)\n" " : bar(bar), baz(baz) {}", Style); } TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { FormatStyle Style = getLLVMStyleWithColumns(60); Style.BinPackArguments = false; for (int i = 0; i < 4; ++i) { // Test all combinations of parameters that should not have an effect. Style.AllowAllParametersOfDeclarationOnNextLine = i & 1; Style.PackConstructorInitializers = i & 2 ? FormatStyle::PCIS_BinPack : FormatStyle::PCIS_Never; Style.AllowAllArgumentsOnNextLine = true; verifyFormat("void foo() {\n" " FunctionCallWithReallyLongName(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n" "}", Style); Style.AllowAllArgumentsOnNextLine = false; verifyFormat("void foo() {\n" " FunctionCallWithReallyLongName(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " bbbbbbbbbbbb);\n" "}", Style); Style.AllowAllArgumentsOnNextLine = true; verifyFormat("void foo() {\n" " auto VariableWithReallyLongName = {\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n" "}", Style); Style.AllowAllArgumentsOnNextLine = false; verifyFormat("void foo() {\n" " auto VariableWithReallyLongName = {\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " bbbbbbbbbbbb};\n" "}", Style); } // This parameter should not affect declarations. Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; Style.AllowAllArgumentsOnNextLine = false; Style.AllowAllParametersOfDeclarationOnNextLine = true; verifyFormat("void FunctionCallWithReallyLongName(\n" " int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);", Style); Style.AllowAllParametersOfDeclarationOnNextLine = false; verifyFormat("void FunctionCallWithReallyLongName(\n" " int aaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbb);", Style); } TEST_F(FormatTest, AllowAllArgumentsOnNextLineDontAlign) { // Check that AllowAllArgumentsOnNextLine is respected for both BAS_DontAlign // and BAS_Align. FormatStyle Style = getLLVMStyleWithColumns(35); StringRef Input = "functionCall(paramA, paramB, paramC);\n" "void functionDecl(int A, int B, int C);"; Style.AllowAllArgumentsOnNextLine = false; Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; verifyFormat(StringRef("functionCall(paramA, paramB,\n" " paramC);\n" "void functionDecl(int A, int B,\n" " int C);"), Input, Style); Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; verifyFormat(StringRef("functionCall(paramA, paramB,\n" " paramC);\n" "void functionDecl(int A, int B,\n" " int C);"), Input, Style); // However, BAS_AlwaysBreak and BAS_BlockIndent should take precedence over // AllowAllArgumentsOnNextLine. Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; verifyFormat(StringRef("functionCall(\n" " paramA, paramB, paramC);\n" "void functionDecl(\n" " int A, int B, int C);"), Input, Style); Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; verifyFormat("functionCall(\n" " paramA, paramB, paramC\n" ");\n" "void functionDecl(\n" " int A, int B, int C\n" ");", Input, Style); // When AllowAllArgumentsOnNextLine is set, we prefer breaking before the // first argument. Style.AllowAllArgumentsOnNextLine = true; Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; verifyFormat(StringRef("functionCall(\n" " paramA, paramB, paramC);\n" "void functionDecl(\n" " int A, int B, int C);"), Input, Style); // It wouldn't fit on one line with aligned parameters so this setting // doesn't change anything for BAS_Align. Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; verifyFormat(StringRef("functionCall(paramA, paramB,\n" " paramC);\n" "void functionDecl(int A, int B,\n" " int C);"), Input, Style); Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; verifyFormat(StringRef("functionCall(\n" " paramA, paramB, paramC);\n" "void functionDecl(\n" " int A, int B, int C);"), Input, Style); } TEST_F(FormatTest, BreakFunctionDefinitionParameters) { StringRef Input = "void functionDecl(paramA, paramB, paramC);\n" "void emptyFunctionDefinition() {}\n" "void functionDefinition(int A, int B, int C) {}\n" "Class::Class(int A, int B) : m_A(A), m_B(B) {}"; verifyFormat(Input); FormatStyle Style = getLLVMStyle(); EXPECT_FALSE(Style.BreakFunctionDefinitionParameters); Style.BreakFunctionDefinitionParameters = true; verifyFormat("void functionDecl(paramA, paramB, paramC);\n" "void emptyFunctionDefinition() {}\n" "void functionDefinition(\n" " int A, int B, int C) {}\n" "Class::Class(\n" " int A, int B)\n" " : m_A(A), m_B(B) {}", Input, Style); // Test the style where all parameters are on their own lines. Style.AllowAllParametersOfDeclarationOnNextLine = false; Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; verifyFormat("void functionDecl(paramA, paramB, paramC);\n" "void emptyFunctionDefinition() {}\n" "void functionDefinition(\n" " int A,\n" " int B,\n" " int C) {}\n" "Class::Class(\n" " int A,\n" " int B)\n" " : m_A(A), m_B(B) {}", Input, Style); } TEST_F(FormatTest, BreakBeforeInlineASMColon) { FormatStyle Style = getLLVMStyle(); Style.BreakBeforeInlineASMColon = FormatStyle::BBIAS_Never; /* Test the behaviour with long lines */ Style.ColumnLimit = 40; verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n" " : : val);", Style); verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n" " : val1 : val2);", Style); verifyFormat("asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" " \"cpuid\\n\\t\"\n" " \"xchgq\\t%%rbx %%rsi\\n\\t\",\n" " : \"=a\" : \"a\");", Style); Style.ColumnLimit = 80; verifyFormat("asm volatile(\"string\", : : val);", Style); verifyFormat("asm volatile(\"string\", : val1 : val2);", Style); Style.BreakBeforeInlineASMColon = FormatStyle::BBIAS_Always; verifyFormat("asm volatile(\"string\",\n" " :\n" " : val);", Style); verifyFormat("asm volatile(\"string\",\n" " : val1\n" " : val2);", Style); /* Test the behaviour with long lines */ Style.ColumnLimit = 40; verifyFormat("asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" " \"cpuid\\n\\t\"\n" " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" " : \"=a\"(*rEAX)\n" " : \"a\"(value));", Style); verifyFormat("asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n" " \"cpuid\\n\\t\"\n" " \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n" " :\n" " : \"a\"(value));", Style); verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n" " :\n" " : val);", Style); verifyFormat("asm volatile(\"loooooooooooooooooooong\",\n" " : val1\n" " : val2);", Style); } TEST_F(FormatTest, BreakConstructorInitializersAfterColon) { FormatStyle Style = getLLVMStyle(); Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon; verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}"); verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}", getStyleWithColumns(Style, 45)); verifyFormat("Constructor() :\n" " Initializer(FitsOnTheLine) {}", getStyleWithColumns(Style, 44)); verifyFormat("Constructor() :\n" " Initializer(FitsOnTheLine) {}", getStyleWithColumns(Style, 43)); verifyFormat("template \n" "Constructor() : Initializer(FitsOnTheLine) {}", getStyleWithColumns(Style, 50)); verifyFormat( "Class::Class(int some, int arguments, int loooooooooooooooooooong,\n" " int mooooooooooooore) noexcept :\n" " Super{some, arguments}, Member{5}, Member2{2} {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine; verifyFormat( "SomeClass::Constructor() :\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", Style); verifyFormat( "SomeClass::Constructor() : // NOLINT\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_NextLineOnly; verifyFormat( "SomeClass::Constructor() :\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", Style); verifyFormat( "SomeClass::Constructor() : // NOLINT\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", Style); Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack; verifyFormat( "SomeClass::Constructor() :\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", Style); verifyFormat( "SomeClass::Constructor() :\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}", Style); verifyFormat( "SomeClass::Constructor() :\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}", Style); verifyFormat( "Ctor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) : aaaaaaaaaa(aaaaaa) {}", Style); verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaaaa() {}", Style); verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", Style); verifyFormat("Constructor(int Parameter = 0) :\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}", Style); verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n" "}", getStyleWithColumns(Style, 60)); verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}", Style); // Here a line could be saved by splitting the second initializer onto two // lines, but that is not desirable. verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaaaaaaaaa(aaaaaaaaaaa),\n" " aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", Style); FormatStyle OnePerLine = Style; OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine; 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("Foo::Foo(int i, int j) : // NOLINT\n" " i(i), // comment\n" " j(j) {}", 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); OnePerLine.BinPackParameters = FormatStyle::BPPS_OnePerLine; verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaa().aaa(),\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", OnePerLine); OnePerLine.ColumnLimit = 60; verifyFormat("Constructor() :\n" " aaaaaaaaaaaaaaaaaaaa(a),\n" " bbbbbbbbbbbbbbbbbbbbbbbb(b) {}", OnePerLine); verifyFormat("Constructor() :\n" " // Comment forcing unwanted break.\n" " aaaa(aaaa) {}", Style); verifyFormat("Constructor() : // NOLINT\n" " aaaa(aaaa) {}", Style); verifyFormat("Constructor() : // A very long trailing comment that cannot fit" " on a single\n" " // line.\n" " aaaa(aaaa) {}", "Constructor() : // A very long trailing comment that cannot fit" " on a single line.\n" " aaaa(aaaa) {}", Style); Style.ColumnLimit = 0; verifyFormat("SomeClass::Constructor() :\n" " a(a) {}", Style); verifyFormat("SomeClass::Constructor() noexcept :\n" " a(a) {}", Style); verifyFormat("SomeClass::Constructor() :\n" " a(a), b(b), c(c) {}", Style); verifyFormat("SomeClass::Constructor() :\n" " a(a) {\n" " foo();\n" " bar();\n" "}", Style); Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; verifyFormat("SomeClass::Constructor() :\n" " a(a), b(b), c(c) {\n" "}", Style); verifyFormat("SomeClass::Constructor() :\n" " a(a) {\n" "}", Style); Style.ColumnLimit = 80; Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All; Style.ConstructorInitializerIndentWidth = 2; verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style); verifyFormat("SomeClass::Constructor() :\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}", Style); // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as // well Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon; verifyFormat( "class SomeClass\n" " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", Style); Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma; verifyFormat( "class SomeClass\n" " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", Style); Style.BreakInheritanceList = FormatStyle::BILS_AfterColon; verifyFormat( "class SomeClass :\n" " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", Style); Style.BreakInheritanceList = FormatStyle::BILS_AfterComma; verifyFormat( "class SomeClass\n" " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};", Style); } #ifndef EXPENSIVE_CHECKS // Expensive checks enables libstdc++ checking which includes validating the // state of ranges used in std::priority_queue - this blows out the // runtime/scalability of the function and makes this test unacceptably slow. 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.PackConstructorInitializers = FormatStyle::PCIS_NextLine; OnePerLine.BinPackParameters = FormatStyle::BPPS_OnePerLine; 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); OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_NextLineOnly; verifyFormat(input, OnePerLine); } #endif 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. verifyGoogleFormat( "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);"); // 3) break after (. verifyGoogleFormat( "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n" " Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);"); // 4) break before after nested name specifiers. verifyGoogleFormat( "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" "SomeClasssssssssssssssssssssssssssssssssssssss::\n" " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);"); // 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);"); verifyGoogleFormat( "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n" " Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);"); 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);"); verifyFormat("void SomeLoooooooooooongFunction(\n" " std::unique_ptr\n" " aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbb);"); // Treat overloaded operators like other functions. verifyFormat("SomeLoooooooooooooooooooooooooogType\n" "operator>(const SomeLoooooooooooooooooooooooooogType &other);"); verifyFormat("SomeLoooooooooooooooooooooooooogType\n" "operator>>(const SomeLooooooooooooooooooooooooogType &other);"); verifyFormat("SomeLoooooooooooooooooooooooooogType\n" "operator<<(const SomeLooooooooooooooooooooooooogType &other);"); verifyGoogleFormat( "SomeLoooooooooooooooooooooooooooooogType operator>>(\n" " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); verifyGoogleFormat( "SomeLoooooooooooooooooooooooooooooogType operator<<(\n" " const SomeLooooooooogType &a, const SomeLooooooooogType &b);"); verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);"); verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n" "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);"); verifyGoogleFormat( "typename aaaaaaaaaa::aaaaaaaaaaa\n" "aaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}"); verifyGoogleFormat("template \n" "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" "aaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);"); FormatStyle Style = getLLVMStyle(); Style.PointerAlignment = FormatStyle::PAS_Left; verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}", Style); verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", Style); } TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) { // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516: // Prefer keeping `::` followed by `operator` together. verifyFormat("const aaaa::bbbbbbb &\n" "ccccccccc::operator++() {\n" " stuff();\n" "}", "const aaaa::bbbbbbb\n" "&ccccccccc::operator++() { stuff(); }", getLLVMStyleWithColumns(40)); } TEST_F(FormatTest, TrailingReturnType) { verifyFormat("auto foo() -> int;"); // correct trailing return type spacing verifyFormat("auto operator->() -> int;"); verifyFormat("auto operator++(int) -> int;"); verifyFormat("struct S {\n" " auto bar() const -> int;\n" "};"); verifyFormat("template \n" "auto load_img(const std::string &filename)\n" " -> alias::tensor {}"); verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n" " -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}"); verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}"); verifyFormat("template \n" "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n" " -> decltype(eaaaaaaaaaaaaaaa(t.a).aaaaaaaa());"); FormatStyle Style = getLLVMStyleWithColumns(60); verifyFormat("#define MAKE_DEF(NAME) \\\n" " auto NAME() -> int { return 42; }", Style); // Not trailing return types. verifyFormat("void f() { auto a = b->c(); }"); verifyFormat("auto a = p->foo();"); verifyFormat("int a = p->foo();"); verifyFormat("auto lmbd = [] NOEXCEPT -> int { return 0; };"); } TEST_F(FormatTest, DeductionGuides) { verifyFormat("template A(const T &, const T &) -> A;"); verifyFormat("template explicit A(T &, T &&) -> A;"); verifyFormat("template S(Ts...) -> S;"); verifyFormat( "template \n" "array(T &&...t) -> array, sizeof...(T)>;"); verifyFormat("template A() -> Afoo<3>())>;"); verifyFormat("template A() -> A>)>;"); verifyFormat("template A() -> Afoo<1>)>;"); verifyFormat("template A() -> A<(3 < 2)>;"); verifyFormat("template A() -> A<((3) < (2))>;"); verifyFormat("template x() -> x<1>;"); verifyFormat("template explicit x(T &) -> x<1>;"); verifyFormat("A(const char *) -> A;"); verifyFormat("A() -> A;"); // Ensure not deduction guides. verifyFormat("c()->f();"); verifyFormat("x()->foo<1>;"); verifyFormat("x = p->foo<3>();"); verifyFormat("x()->x<1>();"); } TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) { // Avoid breaking before trailing 'const' or other trailing annotations, if // they are not function-like. FormatStyle Style = getGoogleStyleWithColumns(47); verifyFormat("void someLongFunction(\n" " int someLoooooooooooooongParameter) 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;"); verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n" " aaaaaaaaaaa aaaaa) const override;"); verifyGoogleFormat( "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" " const override;"); // Even if the first parameter has to be wrapped. verifyFormat("void someLongFunction(\n" " int someLongParameter) const {}", getLLVMStyleWithColumns(46)); verifyFormat("void someLongFunction(\n" " int someLongParameter) const {}", Style); verifyFormat("void someLongFunction(\n" " int someLongParameter) override {}", Style); verifyFormat("void someLongFunction(\n" " int someLongParameter) OVERRIDE {}", Style); verifyFormat("void someLongFunction(\n" " int someLongParameter) final {}", Style); verifyFormat("void someLongFunction(\n" " int someLongParameter) FINAL {}", Style); verifyFormat("void someLongFunction(\n" " int parameter) const override {}", Style); Style.BreakBeforeBraces = FormatStyle::BS_Allman; verifyFormat("void someLongFunction(\n" " int someLongParameter) const\n" "{\n" "}", Style); Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths; verifyFormat("void someLongFunction(\n" " int someLongParameter) const\n" " {\n" " }", Style); // Unless these are unknown annotations. 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) {}"); verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n" " AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);"); verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});"); verifyFormat( "void aaaaaaaaaaaaaaaaaa()\n" " __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaa));"); verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " __attribute__((unused));"); Style = getGoogleStyle(); verifyFormat( "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " GUARDED_BY(aaaaaaaaaaaa);", Style); verifyFormat( "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " GUARDED_BY(aaaaaaaaaaaa);", Style); verifyFormat( "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", Style); verifyFormat( "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n" " aaaaaaaaaaaaaaaaaaaaaaaaa;", Style); verifyFormat( "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ABSL_GUARDED_BY(aaaaaaaaaaaa);", Style); verifyFormat( "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ABSL_GUARDED_BY(aaaaaaaaaaaa);", Style); verifyFormat( "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ABSL_GUARDED_BY(aaaaaaaaaaaa) =\n" " aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;", Style); verifyFormat( "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ABSL_GUARDED_BY(aaaaaaaaaaaa) =\n" " aaaaaaaaaaaaaaaaaaaaaaaaa;", Style); } TEST_F(FormatTest, FunctionAnnotations) { verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" "int OldFunction(const string ¶meter) {}"); verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" "string OldFunction(const string ¶meter) {}"); verifyFormat("template \n" "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n" "string OldFunction(const string ¶meter) {}"); // Not function annotations. verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n" " ThisIsATestWithAReallyReallyReallyReallyLongName) {}"); verifyFormat("MACRO(abc).function() // wrap\n" " << abc;"); verifyFormat("MACRO(abc)->function() // wrap\n" " << abc;"); verifyFormat("MACRO(abc)::function() // wrap\n" " << abc;"); verifyFormat("FOO(bar)();", getLLVMStyleWithColumns(0)); } 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,\n" " 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( "aaaaaa(aaa,\n" " new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n" " aaaa);"); verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); // Indent consistently independent of call expression and unary operator. verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" " dddddddddddddddddddddddddddddd));"); verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n" " dddddddddddddddddddddddddddddd));"); verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\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. verifyFormat("f(g(h(a, // comment\n" " b, c),\n" " d, e),\n" " x, y);", "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, FormatsDeclarationsOnePerLine) { FormatStyle NoBinPacking = getGoogleStyle(); NoBinPacking.BinPackParameters = FormatStyle::BPPS_OnePerLine; NoBinPacking.BinPackArguments = true; verifyFormat("void f() {\n" " f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n" "}", NoBinPacking); verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n" " int aaaaaaaaaaaaaaaaaaaa,\n" " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", NoBinPacking); NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false; verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " vector bbbbbbbbbbbbbbb);", NoBinPacking); // FIXME: This behavior difference is probably not wanted. However, currently // we cannot distinguish BreakBeforeParameter being set because of the wrapped // template arguments from BreakBeforeParameter being set because of the // one-per-line formatting. verifyFormat( "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaa);", NoBinPacking); verifyFormat( "void fffffffffff(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " aaaaaaaaaa);"); } TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { FormatStyle NoBinPacking = getGoogleStyle(); NoBinPacking.BinPackParameters = FormatStyle::BPPS_OnePerLine; NoBinPacking.BinPackArguments = 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\n" " 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, FormatsDeclarationBreakAlways) { FormatStyle BreakAlways = getGoogleStyle(); BreakAlways.BinPackParameters = FormatStyle::BPPS_AlwaysOnePerLine; verifyFormat("void f(int a,\n" " int b);", BreakAlways); verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbbbbbbbbbbbbbb,\n" " int cccccccccccccccccccccccc);", BreakAlways); // Ensure AlignAfterOpenBracket interacts correctly with BinPackParameters set // to BPPS_AlwaysOnePerLine. BreakAlways.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; verifyFormat( "void someLongFunctionName(\n" " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " int b);", BreakAlways); BreakAlways.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; verifyFormat( "void someLongFunctionName(\n" " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " int b\n" ");", BreakAlways); } TEST_F(FormatTest, FormatsDefinitionBreakAlways) { FormatStyle BreakAlways = getGoogleStyle(); BreakAlways.BinPackParameters = FormatStyle::BPPS_AlwaysOnePerLine; verifyFormat("void f(int a,\n" " int b) {\n" " f(a, b);\n" "}", BreakAlways); // Ensure BinPackArguments interact correctly when BinPackParameters is set to // BPPS_AlwaysOnePerLine. verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbbbbbbbbbbbbbb,\n" " int cccccccccccccccccccccccc) {\n" " f(aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbb,\n" " cccccccccccccccccccccccc);\n" "}", BreakAlways); BreakAlways.BinPackArguments = false; verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " int bbbbbbbbbbbbbbbbbbbbbbbbb,\n" " int cccccccccccccccccccccccc) {\n" " f(aaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " bbbbbbbbbbbbbbbbbbbbbbbbb,\n" " cccccccccccccccccccccccc);\n" "}", BreakAlways); // Ensure BreakFunctionDefinitionParameters interacts correctly when // BinPackParameters is set to BPPS_AlwaysOnePerLine. BreakAlways.BreakFunctionDefinitionParameters = true; verifyFormat("void f(\n" " int a,\n" " int b) {\n" " f(a, b);\n" "}", BreakAlways); BreakAlways.BreakFunctionDefinitionParameters = false; // Ensure AlignAfterOpenBracket interacts correctly with BinPackParameters set // to BPPS_AlwaysOnePerLine. BreakAlways.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; verifyFormat( "void someLongFunctionName(\n" " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " int b) {\n" " someLongFunctionName(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, b);\n" "}", BreakAlways); BreakAlways.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; verifyFormat( "void someLongFunctionName(\n" " int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " int b\n" ") {\n" " someLongFunctionName(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, b\n" " );\n" "}", BreakAlways); } TEST_F(FormatTest, AdaptiveOnePerLineFormatting) { FormatStyle Style = getLLVMStyleWithColumns(15); Style.ExperimentalAutoDetectBinPacking = true; verifyFormat("aaa(aaaa,\n" " aaaa,\n" " aaaa);\n" "aaa(aaaa,\n" " aaaa,\n" " aaaa);", "aaa(aaaa,\n" // one-per-line " aaaa,\n" " aaaa );\n" "aaa(aaaa, aaaa, aaaa);", // inconclusive Style); verifyFormat("aaa(aaaa, aaaa,\n" " aaaa);\n" "aaa(aaaa, aaaa,\n" " aaaa);", "aaa(aaaa, aaaa,\n" // bin-packed " aaaa );\n" "aaa(aaaa, aaaa, aaaa);", // inconclusive Style); } TEST_F(FormatTest, IndentExportBlock) { FormatStyle Style = getLLVMStyleWithColumns(80); Style.IndentExportBlock = true; verifyFormat("export {\n" " int x;\n" " int y;\n" "}", "export {\n" "int x;\n" "int y;\n" "}", Style); Style.IndentExportBlock = false; verifyFormat("export {\n" "int x;\n" "int y;\n" "}", "export {\n" " int x;\n" " int y;\n" "}", Style); } TEST_F(FormatTest, ShortExportBlocks) { FormatStyle Style = getLLVMStyleWithColumns(80); Style.IndentExportBlock = false; Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never; verifyFormat("export {\n" "}", Style); verifyFormat("export {\n" "int x;\n" "}", Style); verifyFormat("export {\n" "int x;\n" "}", "export\n" "{\n" "int x;\n" "}", Style); verifyFormat("export {\n" "}", "export {}", Style); verifyFormat("export {\n" "int x;\n" "}", "export { int x; }", Style); Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always; verifyFormat("export {}", "export {\n" "}", Style); verifyFormat("export { int x; }", "export {\n" "int x;\n" "}", Style); verifyFormat("export { int x; }", "export\n" "{\n" "int x;\n" "}", Style); verifyFormat("export {}", "export {\n" "}", Style); verifyFormat("export { int x; }", "export {\n" "int x;\n" "}", Style); Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty; verifyFormat("export {}", "export {\n" "}", Style); verifyFormat("export {\n" "int x;\n" "}", Style); verifyFormat("export {\n" "int x;\n" "}", "export\n" "{\n" "int x;\n" "}", Style); verifyFormat("export {}", Style); verifyFormat("export {\n" "int x;\n" "}", "export { int x; }", 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);"); verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n" " aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();"); verifyFormat("aaaaaaa->aaaaaaa\n" " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " ->aaaaaaaa(aaaaaaaaaaaaaaa);"); verifyFormat( "aaaaaaa->aaaaaaa\n" " ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\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();"); // Don't linewrap after very short segments. verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); verifyFormat("aaa()\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); 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);"); // Prefer not to create "hanging" indents. verifyFormat( "return !soooooooooooooome_map\n" " .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " .second;"); verifyFormat( "return aaaaaaaaaaaaaaaa\n" " .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n" " .aaaa(aaaaaaaaaaaaaa);"); // No hanging indent here. verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", getLLVMStyleWithColumns(60)); verifyFormat("aaaaaaaaaaaaaaaaaa\n" " .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n" " .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", getLLVMStyleWithColumns(59)); verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); // Dont break if only closing statements before member call verifyFormat("test() {\n" " ([]() -> {\n" " int b = 32;\n" " return 3;\n" " }).foo();\n" "}"); verifyFormat("test() {\n" " (\n" " []() -> {\n" " int b = 32;\n" " return 3;\n" " },\n" " foo, bar)\n" " .foo();\n" "}"); verifyFormat("test() {\n" " ([]() -> {\n" " int b = 32;\n" " return 3;\n" " })\n" " .foo()\n" " .bar();\n" "}"); verifyFormat("test() {\n" " ([]() -> {\n" " int b = 32;\n" " return 3;\n" " })\n" " .foo(\"aaaaaaaaaaaaaaaaa\"\n" " \"bbbb\");\n" "}", getLLVMStyleWithColumns(30)); } TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) { verifyFormat( "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n" " bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}"); verifyFormat( "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n" " bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" " ccccccccccccccccccccccccc) {\n}"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n" " ccccccccccccccccccccccccc) {\n}"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n" " ccccccccccccccccccccccccc) {\n}"); verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n" " ccccccccccccccccccccccccc) {\n}"); verifyFormat( "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n" " ccccccccccccccccccccccccc) {\n}"); verifyFormat( "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n" " ccccccccccccccccccccccccc) {\n}"); verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n" " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n" " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n" " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n" " bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n" " cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n" " dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;"); verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n" " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n" " aaaaaaaaaaaaaaa != aa) {\n}"); verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n" " aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n" " aaaaaaaaaaaaaaa != aa) {\n}"); } TEST_F(FormatTest, BreaksAfterAssignments) { verifyFormat( "unsigned Cost =\n" " TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n" " SI->getPointerAddressSpaceee());"); 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, ConfigurableBreakAssignmentPenalty) { FormatStyle Style = getLLVMStyle(); verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n" " bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;", Style); Style.PenaltyBreakAssignment = 20; verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n" " cccccccccccccccccccccccccc;", Style); } 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, AlignsAfterOpenBracket) { verifyFormat( "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" " aaaaaaaaa aaaaaaa) {}"); verifyFormat( "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" " aaaaaaaaaaa aaaaaaaaa);"); verifyFormat( "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaa));"); FormatStyle Style = getLLVMStyle(); Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}", Style); verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);", Style); verifyFormat("SomeLongVariableName->someFunction(\n" " foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));", Style); verifyFormat( "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n" " aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", Style); verifyFormat( "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n" " aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", Style); verifyFormat( "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", Style); verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n" " ccccccc(aaaaaaaaaaaaaaaaa, //\n" " b));", Style); Style.ColumnLimit = 30; verifyFormat("for (int foo = 0; foo < FOO;\n" " ++foo) {\n" " bar(foo);\n" "}", Style); Style.ColumnLimit = 80; Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak; Style.BinPackArguments = false; Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaa aaaaaaaa,\n" " aaaaaaaaa aaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}", Style); verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" " aaaaaaaaaaa aaaaaaaaa,\n" " aaaaaaaaaaa aaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", Style); verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" " aaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));", Style); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", Style); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));", Style); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n" " aaaaaaaaaaaaaaaa);", Style); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n" " aaaaaaaaaaaaaaaa);", Style); verifyFormat( "fooooooooooo(new BARRRRRRRRR(\n" " XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZZZZZZZZZZZZZZZZZZZZZZZZZ()));", Style); verifyFormat( "fooooooooooo(::new BARRRRRRRRR(\n" " XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZZZZZZZZZZZZZZZZZZZZZZZZZ()));", Style); verifyFormat( "fooooooooooo(new FOO::BARRRR(\n" " XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXZZZZZZZZZZZZZZZZZZZZZZZZZ()));", Style); Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; Style.BinPackArguments = false; Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaa aaaaaaaa,\n" " aaaaaaaaa aaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" ") {}", Style); verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n" " aaaaaaaaaaa aaaaaaaaa,\n" " aaaaaaaaaaa aaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" ");", Style); verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n" " aaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" "));", Style); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)\n" "));", Style); verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)\n" "));", Style); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)\n" " ),\n" " aaaaaaaaaaaaaaaa\n" ");", Style); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)\n" " ) &&\n" " aaaaaaaaaaaaaaaa\n" ");", Style); verifyFormat("void foo(\n" " void (*foobarpntr)(\n" " aaaaaaaaaaaaaaaaaa *,\n" " bbbbbbbbbbbbbb *,\n" " cccccccccccccccccccc *,\n" " dddddddddddddddddd *\n" " )\n" ");", Style); verifyFormat("aaaaaaa const aaaaaaaaaa{\n" " aaaaaaaaaaaaa(aaaaaaaaaaa, aaaaaaaaaaaaaaaa)\n" "};", Style); verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " const bool &aaaaaaaaa, const void *aaaaaaaaaa\n" ") const {\n" " return true;\n" "}", Style); verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaa(\n" " const bool &aaaaaaaaaa, const void *aaaaaaaaaa\n" ") const;", Style); verifyFormat("void aaaaaaaaa(\n" " int aaaaaa, int bbbbbb, int cccccc, int dddddddddd\n" ") const noexcept -> std::vector;", Style); verifyFormat( "x = aaaaaaaaaaaaaaa(\n" " \"a aaaaaaa aaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa aaaaaaaaaaaaa\"\n" ");", Style); Style.ColumnLimit = 60; verifyFormat("auto lambda =\n" " [&b](\n" " auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ) {};", Style); } TEST_F(FormatTest, ParenthesesAndOperandAlignment) { FormatStyle Style = getLLVMStyleWithColumns(40); verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" " bbbbbbbbbbbbbbbbbbbbbb);", Style); Style.AlignAfterOpenBracket = FormatStyle::BAS_Align; Style.AlignOperands = FormatStyle::OAS_DontAlign; verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" " bbbbbbbbbbbbbbbbbbbbbb);", Style); Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; Style.AlignOperands = FormatStyle::OAS_Align; verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" " bbbbbbbbbbbbbbbbbbbbbb);", Style); Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign; Style.AlignOperands = FormatStyle::OAS_DontAlign; verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n" " bbbbbbbbbbbbbbbbbbbbbb);", Style); } TEST_F(FormatTest, BreaksConditionalExpressions) { verifyFormat( "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( "aaaa(aaaaaaaaaa, aaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n" " 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("return aaaa == bbbb\n" " // comment\n" " ? aaaa\n" " : bbbb;"); verifyFormat("unsigned Indent =\n" " format(TheLine.First,\n" " IndentForLevel[TheLine.Level] >= 0\n" " ? IndentForLevel[TheLine.Level]\n" " : TheLine * 2,\n" " TheLine.InPPDirective, PreviousEndOfLineColumn);", getLLVMStyleWithColumns(60)); verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" " ? aaaaaaaaaaaaaaa\n" " : bbbbbbbbbbbbbbb //\n" " ? ccccccccccccccc\n" " : ddddddddddddddd;"); verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n" " ? aaaaaaaaaaaaaaa\n" " : (bbbbbbbbbbbbbbb //\n" " ? ccccccccccccccc\n" " : ddddddddddddddd);"); verifyFormat( "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaa +\n" " aaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaa;"); verifyFormat( "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaa\n" " : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); FormatStyle NoBinPacking = getLLVMStyle(); NoBinPacking.BinPackArguments = 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); verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n" " // comment.\n" " ccccccccccccccccccccccccccccccccccccccc\n" " ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);"); // Assignments in conditional expressions. Apparently not uncommon :-(. verifyFormat("return a != b\n" " // comment\n" " ? a = b\n" " : a = b;"); verifyFormat("return a != b\n" " // comment\n" " ? a = a != b\n" " // comment\n" " ? a = b\n" " : a\n" " : a;"); verifyFormat("return a != b\n" " // comment\n" " ? a\n" " : a = a != b\n" " // comment\n" " ? a = b\n" " : a;"); // Chained conditionals FormatStyle Style = getLLVMStyleWithColumns(70); Style.AlignOperands = FormatStyle::OAS_Align; verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" " : bbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat("return aaaaaaaaaa ? 1111111111111111\n" " : bbbbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" " : bbbbbbbbbbbbbb ? 222222\n" " : 333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : cccccccccccccc ? 3333333333333333\n" " : 4444444444444444;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : (aaa ? bbb : ccc);", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : cccccccccccccccccc)\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat( "return aaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : cccccccccccccccccc)\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat( "return aaaaaaaaa ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : dddddddddddddddddd)\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat( "return aaaaaaaaa ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : dddddddddddddddddd)\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat( "return aaaaaaaaa ? 1111111111111111\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : dddddddddddddddddd)", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? 1111111111111111\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : cccccccccccccccccc);", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : ccccccccccccccc ? dddddddddddddddddd\n" " : eeeeeeeeeeeeeeeeee)\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : ccccccccccccccc ? dddddddddddddddddd\n" " : eeeeeeeeeeeeeeeeee)\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : cccccccccccc ? dddddddddddddddddd\n" " : eeeeeeeeeeeeeeeeee)\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : cccccccccccccccccc\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : cccccccccccccccc ? dddddddddddddddddd\n" " : eeeeeeeeeeeeeeeeee\n" " : bbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n" " ? (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : cccccccccccccccccc ? dddddddddddddddddd\n" " : eeeeeeeeeeeeeeeeee)\n" " : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n" " ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n" " : cccccccccccccccc ? dddddddddddddddddd\n" " : eeeeeeeeeeeeeeeeee\n" " : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n" " : 3333333333333333;", Style); Style.AlignOperands = FormatStyle::OAS_DontAlign; Style.BreakBeforeTernaryOperators = false; // FIXME: Aligning the question marks is weird given DontAlign. // Consider disabling this alignment in this case. Also check whether this // will render the adjustment from https://reviews.llvm.org/D82199 // unnecessary. verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n" " bbbb ? cccccccccccccccccc :\n" " ddddd;", Style); verifyFormat( "MMMMMMMMMMMMMMMMMMMMMMMMMMM = A ?\n" " /*\n" " */\n" " function() {\n" " try {\n" " return JJJJJJJJJJJJJJ(\n" " pppppppppppppppppppppppppppppppppppppppppppppppppp);\n" " }\n" " } :\n" " function() {};", "MMMMMMMMMMMMMMMMMMMMMMMMMMM = A ?\n" " /*\n" " */\n" " function() {\n" " try {\n" " return JJJJJJJJJJJJJJ(\n" " pppppppppppppppppppppppppppppppppppppppppppppppppp);\n" " }\n" " } :\n" " function() {};", getGoogleStyle(FormatStyle::LK_JavaScript)); } TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) { FormatStyle Style = getLLVMStyleWithColumns(70); Style.BreakBeforeTernaryOperators = false; verifyFormat( "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", Style); verifyFormat( "aaaa(aaaaaaaaaa, aaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", Style); verifyFormat( "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);", Style); verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n" " 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,\n" " 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); verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" " /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n" " ccccccccccccccccccccccccccc;", Style); verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n" " aaaaa :\n" " bbbbbbbbbbbbbbb + cccccccccccccccc;", Style); // Chained conditionals verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" " bbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat("return aaaaaaaaaa ? 1111111111111111 :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" " bbbbbbbbbbbbbbbb ? 222222 :\n" " 333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " cccccccccccccccc ? 3333333333333333 :\n" " 4444444444444444;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " (aaa ? bbb : ccc);", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " cccccccccccccccccc) :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat( "return aaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " cccccccccccccccccc) :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat( "return aaaaaaaaa ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " dddddddddddddddddd) :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat( "return aaaaaaaaa ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " dddddddddddddddddd) :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat( "return aaaaaaaaa ? 1111111111111111 :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " dddddddddddddddddd)", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " cccccccccccccccccc);", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " ccccccccccccccccc ? dddddddddddddddddd :\n" " eeeeeeeeeeeeeeeeee) :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " ccccccccccccc ? dddddddddddddddddd :\n" " eeeeeeeeeeeeeeeeee) :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " ccccccccccccccccc ? dddddddddddddddddd :\n" " eeeeeeeeeeeeeeeeee) :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " cccccccccccccccccc :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat( "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " cccccccccccccccccc ? dddddddddddddddddd :\n" " eeeeeeeeeeeeeeeeee :\n" " bbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n" " (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " cccccccccccccccccc ? dddddddddddddddddd :\n" " eeeeeeeeeeeeeeeeee) :\n" " bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", Style); verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n" " aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n" " cccccccccccccccccccc ? dddddddddddddddddd :\n" " eeeeeeeeeeeeeeeeee :\n" " bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n" " 3333333333333333;", 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;"); FormatStyle Style = getGoogleStyle(); Style.PointerAlignment = FormatStyle::PAS_Left; Style.DerivePointerAlignment = false; verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n" " *b = bbbbbbbbbbbbbbbbbbb;", Style); verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n" " *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;", Style); verifyFormat("vector a, b;", Style); verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style); verifyFormat("/*comment*/ for (int *p, *q; p != q; p = p->next) {\n}", Style); verifyFormat("if (int *p, *q; p != q) {\n p = p->next;\n}", Style); verifyFormat("/*comment*/ if (int *p, *q; p != q) {\n p = p->next;\n}", Style); verifyFormat("switch (int *p, *q; p != q) {\n default:\n break;\n}", Style); verifyFormat( "/*comment*/ switch (int *p, *q; p != q) {\n default:\n break;\n}", Style); verifyFormat("if ([](int* p, int* q) {}()) {\n}", Style); verifyFormat("for ([](int* p, int* q) {}();;) {\n}", Style); verifyFormat("for (; [](int* p, int* q) {}();) {\n}", Style); verifyFormat("for (;; [](int* p, int* q) {}()) {\n}", Style); verifyFormat("switch ([](int* p, int* q) {}()) {\n default:\n break;\n}", Style); } 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" " also, other, parameters);"); verifyFormat("fun + \"1243\" /* comment */\n" " \"5678\";", "fun + \"1243\" /* comment */\n" " \"5678\";", getLLVMStyleWithColumns(28)); verifyFormat( "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n" " \"aaaaaaaaaaaaaaaaaaaaa\"\n" " \"aaaaaaaaaaaaaaaa\";", "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\");"); verifyFormat("f(L\"a\"\n" " L\"b\");"); verifyFormat("#define A(X) \\\n" " L\"aaaaa\" #X L\"bbbbbb\" \\\n" " L\"ccccc\"", getLLVMStyleWithColumns(25)); verifyFormat("f(@\"a\"\n" " @\"b\");"); verifyFormat("NSString s = @\"a\"\n" " @\"b\"\n" " @\"c\";"); verifyFormat("NSString s = @\"a\"\n" " \"b\"\n" " \"c\";"); } TEST_F(FormatTest, ReturnTypeBreakingStyle) { FormatStyle Style = getLLVMStyle(); Style.ColumnLimit = 60; // No declarations or definitions should be moved to own line. Style.BreakAfterReturnType = FormatStyle::RTBS_None; verifyFormat("class A {\n" " int f() { return 1; }\n" " int g();\n" " long\n" " foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaar();\n" "};\n" "int f() { return 1; }\n" "int g();\n" "int foooooooooooooooooooooooooooo::\n" " baaaaaaaaaaaaaaaaaaaaar();", Style); // It is now allowed to break after a short return type if necessary. Style.BreakAfterReturnType = FormatStyle::RTBS_Automatic; verifyFormat("class A {\n" " int f() { return 1; }\n" " int g();\n" " long\n" " foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaar();\n" "};\n" "int f() { return 1; }\n" "int g();\n" "int\n" "foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaaar();", Style); // It now must never break after a short return type. Style.BreakAfterReturnType = FormatStyle::RTBS_ExceptShortType; verifyFormat("class A {\n" " int f() { return 1; }\n" " int g();\n" " long foooooooooooooooooooooooooooo::\n" " baaaaaaaaaaaaaaaaaaaar();\n" "};\n" "int f() { return 1; }\n" "int g();\n" "int foooooooooooooooooooooooooooo::\n" " baaaaaaaaaaaaaaaaaaaaar();", Style); // All declarations and definitions should have the return type moved to its // own line. Style.BreakAfterReturnType = FormatStyle::RTBS_All; Style.TypenameMacros = {"LIST"}; verifyFormat("SomeType\n" "funcdecl(LIST(uint64_t));", Style); verifyFormat("class E {\n" " int\n" " f() {\n" " return 1;\n" " }\n" " int\n" " g();\n" " long\n" " foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaar();\n" "};\n" "int\n" "f() {\n" " return 1;\n" "}\n" "int\n" "g();\n" "int\n" "foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaaar();", Style); // Top-level definitions, and no kinds of declarations should have the // return type moved to its own line. Style.BreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions; verifyFormat("class B {\n" " int f() { return 1; }\n" " int g();\n" "};\n" "int\n" "f() {\n" " return 1;\n" "}\n" "int g();", Style); // Top-level definitions and declarations should have the return type moved // to its own line. Style.BreakAfterReturnType = FormatStyle::RTBS_TopLevel; verifyFormat("class C {\n" " int f() { return 1; }\n" " int g();\n" "};\n" "int\n" "f() {\n" " return 1;\n" "}\n" "int\n" "g();\n" "int\n" "foooooooooooooooooooooooooooo::baaaaaaaaaaaaaaaaaaaaar();", Style); // All definitions should have the return type moved to its own line, but no // kinds of declarations. Style.BreakAfterReturnType = FormatStyle::RTBS_AllDefinitions; verifyFormat("class D {\n" " int\n" " f() {\n" " return 1;\n" " }\n" " int g();\n" "};\n" "int\n" "f() {\n" " return 1;\n" "}\n" "int g();", Style); verifyFormat("const char *\n" "f(void) {\n" // Break here. " return \"\";\n" "}\n" "const char *bar(void);", // No break here. Style); verifyFormat("template \n" "T *\n" "f(T &c) {\n" // Break here. " return NULL;\n" "}\n" "template T *f(T &c);", // No break here. Style); verifyFormat("class C {\n" " int\n" " operator+() {\n" " return 1;\n" " }\n" " int\n" " operator()() {\n" " return 1;\n" " }\n" "};", Style); verifyFormat("void\n" "A::operator()() {}\n" "void\n" "A::operator>>() {}\n" "void\n" "A::operator+() {}\n" "void\n" "A::operator*() {}\n" "void\n" "A::operator->() {}\n" "void\n" "A::operator void *() {}\n" "void\n" "A::operator void &() {}\n" "void\n" "A::operator void &&() {}\n" "void\n" "A::operator char *() {}\n" "void\n" "A::operator[]() {}\n" "void\n" "A::operator!() {}\n" "void\n" "A::operator**() {}\n" "void\n" "A::operator *() {}\n" "void\n" "A::operator **() {}\n" "void\n" "A::operator &() {}\n" "void\n" "A::operator void **() {}", Style); verifyFormat("constexpr auto\n" "operator()() const -> reference {}\n" "constexpr auto\n" "operator>>() const -> reference {}\n" "constexpr auto\n" "operator+() const -> reference {}\n" "constexpr auto\n" "operator*() const -> reference {}\n" "constexpr auto\n" "operator->() const -> reference {}\n" "constexpr auto\n" "operator++() const -> reference {}\n" "constexpr auto\n" "operator void *() const -> reference {}\n" "constexpr auto\n" "operator void **() const -> reference {}\n" "constexpr auto\n" "operator void *() const -> reference {}\n" "constexpr auto\n" "operator void &() const -> reference {}\n" "constexpr auto\n" "operator void &&() const -> reference {}\n" "constexpr auto\n" "operator char *() const -> reference {}\n" "constexpr auto\n" "operator!() const -> reference {}\n" "constexpr auto\n" "operator[]() const -> reference {}", Style); verifyFormat("void *operator new(std::size_t s);", // No break here. Style); verifyFormat("void *\n" "operator new(std::size_t s) {}", Style); verifyFormat("void *\n" "operator delete[](void *ptr) {}", Style); Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup; verifyFormat("const char *\n" "f(void)\n" // Break here. "{\n" " return \"\";\n" "}\n" "const char *bar(void);", // No break here. Style); verifyFormat("template \n" "T *\n" // Problem here: no line break "f(T &c)\n" // Break here. "{\n" " return NULL;\n" "}\n" "template T *f(T &c);", // No break here. Style); verifyFormat("int\n" "foo(A a)\n" "{\n" " return a;\n" "}", Style); verifyFormat("int\n" "foo(A<8> a)\n" "{\n" " return a;\n" "}", Style); verifyFormat("int\n" "foo(A, 8> a)\n" "{\n" " return a;\n" "}", Style); verifyFormat("int\n" "foo(A, bool> a)\n" "{\n" " return a;\n" "}", Style); verifyFormat("int\n" "foo(A, bool> a)\n" "{\n" " return a;\n" "}", Style); verifyFormat("int\n" "foo(A, 8> a)\n" "{\n" " return a;\n" "}", Style); Style.BreakBeforeBraces = FormatStyle::BS_Custom; Style.BraceWrapping.AfterFunction = true; verifyFormat("int f(i);\n" // No break here. "int\n" // Break here. "f(i)\n" "{\n" " return i + 1;\n" "}\n" "int\n" // Break here. "f(i)\n" "{\n" " return i + 1;\n" "};", Style); verifyFormat("int f(a, b, c);\n" // No break here. "int\n" // Break here. "f(a, b, c)\n" // Break here. "short a, b;\n" "float c;\n" "{\n" " return a + b < c;\n" "}\n" "int\n" // Break here. "f(a, b, c)\n" // Break here. "short a, b;\n" "float c;\n" "{\n" " return a + b < c;\n" "};", Style); verifyFormat("byte *\n" // Break here. "f(a)\n" // Break here. "byte a[];\n" "{\n" " return a;\n" "}", Style); verifyFormat("byte *\n" "f(a)\n" "byte /* K&R C */ a[];\n" "{\n" " return a;\n" "}\n" "byte *\n" "g(p)\n" "byte /* K&R C */ *p;\n" "{\n" " return p;\n" "}", Style); verifyFormat("bool f(int a, int) override;\n" "Bar g(int a, Bar) final;\n" "Bar h(a, Bar) final;", Style); verifyFormat("int\n" "f(a)", Style); verifyFormat("bool\n" "f(size_t = 0, bool b = false)\n" "{\n" " return !b;\n" "}", Style); // The return breaking style doesn't affect: // * function and object definitions with attribute-like macros verifyFormat("Tttttttttttttttttttttttt ppppppppppppppp\n" " ABSL_GUARDED_BY(mutex) = {};", getGoogleStyleWithColumns(40)); verifyFormat("Tttttttttttttttttttttttt ppppppppppppppp\n" " ABSL_GUARDED_BY(mutex); // comment", getGoogleStyleWithColumns(40)); verifyFormat("Tttttttttttttttttttttttt ppppppppppppppp\n" " ABSL_GUARDED_BY(mutex1)\n" " ABSL_GUARDED_BY(mutex2);", getGoogleStyleWithColumns(40)); verifyFormat("Tttttt f(int a, int b)\n" " ABSL_GUARDED_BY(mutex1)\n" " ABSL_GUARDED_BY(mutex2);", getGoogleStyleWithColumns(40)); // * typedefs verifyGoogleFormat("typedef ATTR(X) char x;"); Style = getGNUStyle(); // Test for comments at the end of function declarations. verifyFormat("void\n" "foo (int a, /*abc*/ int b) // def\n" "{\n" "}", Style); verifyFormat("void\n" "foo (int a, /* abc */ int b) /* def */\n" "{\n" "}", Style); // Definitions that should not break after return type verifyFormat("void foo (int a, int b); // def", Style); verifyFormat("void foo (int a, int b); /* def */", Style); verifyFormat("void foo (int a, int b);", Style); } 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); verifyFormat("aaaa(qqq,\n" " L\"bbbb\"\n" " L\"cccc\");", Break); verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n" " \"bbbb\"));", Break); verifyFormat("string s = someFunction(\n" " \"abc\"\n" " \"abc\");", Break); // As we break before unary operators, breaking right after them is bad. verifyFormat("string foo = abc ? \"x\"\n" " \"blah blah blah blah blah blah\"\n" " : \"y\";", 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. verifyNoChange("x = \"a\\\n" "b\\\n" "c\";", NoBreak); verifyFormat("xxxx =\n" " \"a\\\n" "b\\\n" "c\";", "xxxx = \"a\\\n" "b\\\n" "c\";", Break); verifyFormat("NSString *const kString =\n" " @\"aaaa\"\n" " @\"bbbb\";", "NSString *const kString = @\"aaaa\"\n" "@\"bbbb\";", Break); Break.ColumnLimit = 0; verifyFormat("const char *hello = \"hello llvm\";", Break); } TEST_F(FormatTest, AlignsPipes) { verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n" " << aaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n" " \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n" " << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";"); verifyFormat( "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;"); verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n" " << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);"); verifyFormat( "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat( "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n" " << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();"); verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaa)\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat("LOG_IF(aaa == //\n" " bbb)\n" " << a << b;"); // But sometimes, breaking before the first "<<" is desirable. verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" " << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);"); 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("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n" " << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " << aaa;"); verifyFormat( "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); // Incomplete string literal. verifyFormat("llvm::errs() << \"\n" " << a;", "llvm::errs() << \"\n<cccccc)\n" " << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n" "}"); // Handle 'endl'. verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n" " << bbbbbbbbbbbbbbbbbbbbbb << endl;"); verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;"); // Handle '\n'. verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n" " << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n" " << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';"); verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n" " << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";"); verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";"); } TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) { 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)); verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n" " \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;"); verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n" " \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);"); verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n" " (aaaa + aaaa);", getLLVMStyleWithColumns(40)); verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n" " (aaaaaaa + aaaaa));", getLLVMStyleWithColumns(40)); verifyFormat( "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n" " SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n" " bbbbbbbbbbbbbbbbbbbbbbb);"); } TEST_F(FormatTest, WrapBeforeInsertionOperatorbetweenStringLiterals) { verifyFormat("QStringList() << \"foo\" << \"bar\";"); verifyNoChange("QStringList() << \"foo\"\n" " << \"bar\";"); verifyFormat("log_error(log, \"foo\" << \"bar\");", "log_error(log, \"foo\"\n" " << \"bar\");"); } TEST_F(FormatTest, UnderstandsEquals) { verifyFormat( "aaaaaaaaaaaaaaaaa =\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;"); verifyFormat( "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}"); verifyFormat( "if (a) {\n" " f();\n" "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n" "}"); verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n" " 100000000 + 10000000) {\n}"); } TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) { verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n" " .looooooooooooooooooooooooooooooooooooooongFunction();"); verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\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("void f() {\n" " EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n" " .Times(2)\n" " .WillRepeatedly(Return(SomeValue));\n" "}"); verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n" " ccccccccccccccccccccccc);"); verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " .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));"); 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());"); verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " .a();"); FormatStyle NoBinPacking = getLLVMStyle(); NoBinPacking.BinPackParameters = FormatStyle::BPPS_OnePerLine; 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));"); verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();"); verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" " .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());"); } 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("template class cccccccccccccccccccccc,\n" " typename ddddddddddddd>\n" "class C {};"); 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)); verifyFormat("static_cast *>(\n" "\n" ");", "static_cast*>(\n" "\n" " );"); verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" " const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);"); FormatStyle AlwaysBreak = getLLVMStyle(); AlwaysBreak.BreakTemplateDeclarations = FormatStyle::BTDS_Yes; verifyFormat("template \nclass C {};", AlwaysBreak); verifyFormat("template \nvoid f();", AlwaysBreak); verifyFormat("template \nvoid f() {}", AlwaysBreak); verifyFormat("void aaaaaaaaaaaaaaaaaaa(\n" " ccccccccccccccccccccccccccccccccccccccccccccccc);"); verifyFormat("template