https://github.com/gedare created https://github.com/llvm/llvm-project/pull/154978
Add AlignBracketsTest.cpp to collect tests from FormatTest.cpp related to alignment and breaking after open brackets. >From 1516dfc7abb9fa2bbcf2431573daea08e78bd41d Mon Sep 17 00:00:00 2001 From: Gedare Bloom <ged...@rtems.org> Date: Fri, 22 Aug 2025 10:19:49 -0600 Subject: [PATCH] [clang-format][NFC] Move AlignAfterOpenBracket tests Add AlignBracketsTest.cpp to collect tests from FormatTest.cpp related to alignment and breaking after open brackets. --- clang/unittests/Format/AlignBracketsTest.cpp | 784 +++++++++++++++++++ clang/unittests/Format/CMakeLists.txt | 1 + clang/unittests/Format/FormatTest.cpp | 761 ------------------ 3 files changed, 785 insertions(+), 761 deletions(-) create mode 100644 clang/unittests/Format/AlignBracketsTest.cpp diff --git a/clang/unittests/Format/AlignBracketsTest.cpp b/clang/unittests/Format/AlignBracketsTest.cpp new file mode 100644 index 0000000000000..c4380ae415751 --- /dev/null +++ b/clang/unittests/Format/AlignBracketsTest.cpp @@ -0,0 +1,784 @@ +//===- unittest/Format/AlignBracketsTest.cpp ------------------------------===// +// +// 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 "align-brackets-test" + +namespace clang { +namespace format { +namespace test { +namespace { + +class AlignBracketsTest : public FormatTestBase {}; + +TEST_F(AlignBracketsTest, 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<bbbbbbbb> 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<of_very_long_type>;", + 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); + verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaa(\n" + " &bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" + ");", + Style); +} + +TEST_F(AlignBracketsTest, AlignAfterOpenBracketBlockIndent) { + auto Style = getLLVMStyle(); + + StringRef Short = "functionCall(paramA, paramB, paramC);\n" + "void functionDecl(int a, int b, int c);"; + + StringRef Medium = "functionCall(paramA, paramB, paramC, paramD, paramE, " + "paramF, paramG, paramH, paramI);\n" + "void functionDecl(int argumentA, int argumentB, int " + "argumentC, int argumentD, int argumentE);"; + + verifyFormat(Short, Style); + + StringRef NoBreak = "functionCall(paramA, paramB, paramC, paramD, paramE, " + "paramF, paramG, paramH,\n" + " paramI);\n" + "void functionDecl(int argumentA, int argumentB, int " + "argumentC, int argumentD,\n" + " int argumentE);"; + + verifyFormat(NoBreak, Medium, Style); + verifyFormat(NoBreak, + "functionCall(\n" + " paramA,\n" + " paramB,\n" + " paramC,\n" + " paramD,\n" + " paramE,\n" + " paramF,\n" + " paramG,\n" + " paramH,\n" + " paramI\n" + ");\n" + "void functionDecl(\n" + " int argumentA,\n" + " int argumentB,\n" + " int argumentC,\n" + " int argumentD,\n" + " int argumentE\n" + ");", + Style); + + verifyFormat("outerFunctionCall(nestedFunctionCall(argument1),\n" + " nestedLongFunctionCall(argument1, " + "argument2, argument3,\n" + " argument4, " + "argument5));", + Style); + + Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; + + verifyFormat(Short, Style); + verifyFormat( + "functionCall(\n" + " paramA, paramB, paramC, paramD, paramE, paramF, paramG, paramH, " + "paramI\n" + ");\n" + "void functionDecl(\n" + " int argumentA, int argumentB, int argumentC, int argumentD, int " + "argumentE\n" + ");", + Medium, Style); + + Style.AllowAllArgumentsOnNextLine = false; + Style.AllowAllParametersOfDeclarationOnNextLine = false; + + verifyFormat(Short, Style); + verifyFormat( + "functionCall(\n" + " paramA, paramB, paramC, paramD, paramE, paramF, paramG, paramH, " + "paramI\n" + ");\n" + "void functionDecl(\n" + " int argumentA, int argumentB, int argumentC, int argumentD, int " + "argumentE\n" + ");", + Medium, Style); + + Style.BinPackArguments = false; + Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; + + verifyFormat(Short, Style); + + verifyFormat("functionCall(\n" + " paramA,\n" + " paramB,\n" + " paramC,\n" + " paramD,\n" + " paramE,\n" + " paramF,\n" + " paramG,\n" + " paramH,\n" + " paramI\n" + ");\n" + "void functionDecl(\n" + " int argumentA,\n" + " int argumentB,\n" + " int argumentC,\n" + " int argumentD,\n" + " int argumentE\n" + ");", + Medium, Style); + + verifyFormat("outerFunctionCall(\n" + " nestedFunctionCall(argument1),\n" + " nestedLongFunctionCall(\n" + " argument1,\n" + " argument2,\n" + " argument3,\n" + " argument4,\n" + " argument5\n" + " )\n" + ");", + Style); + + verifyFormat("int a = (int)b;", Style); + verifyFormat("int a = (int)b;", + "int a = (\n" + " int\n" + ") b;", + Style); + + verifyFormat("return (true);", Style); + verifyFormat("return (true);", + "return (\n" + " true\n" + ");", + Style); + + verifyFormat("void foo();", Style); + verifyFormat("void foo();", + "void foo(\n" + ");", + Style); + + verifyFormat("void foo() {}", Style); + verifyFormat("void foo() {}", + "void foo(\n" + ") {\n" + "}", + Style); + + verifyFormat("auto string = std::string();", Style); + verifyFormat("auto string = std::string();", + "auto string = std::string(\n" + ");", + Style); + + verifyFormat("void (*functionPointer)() = nullptr;", Style); + verifyFormat("void (*functionPointer)() = nullptr;", + "void (\n" + " *functionPointer\n" + ")\n" + "(\n" + ") = nullptr;", + Style); +} + +TEST_F(AlignBracketsTest, AlignAfterOpenBracketBlockIndentIfStatement) { + auto Style = getLLVMStyle(); + + verifyFormat("if (foo()) {\n" + " return;\n" + "}", + Style); + + verifyFormat("if (quiteLongArg !=\n" + " (alsoLongArg - 1)) { // ABC is a very longgggggggggggg " + "comment\n" + " return;\n" + "}", + Style); + + Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; + + verifyFormat("if (foo()) {\n" + " return;\n" + "}", + Style); + + verifyFormat("if (quiteLongArg !=\n" + " (alsoLongArg - 1)) { // ABC is a very longgggggggggggg " + "comment\n" + " return;\n" + "}", + Style); + + verifyFormat("void foo() {\n" + " if (camelCaseName < alsoLongName ||\n" + " anotherEvenLongerName <=\n" + " thisReallyReallyReallyReallyReallyReallyLongerName ||" + "\n" + " otherName < thisLastName) {\n" + " return;\n" + " } else if (quiteLongName < alsoLongName ||\n" + " anotherEvenLongerName <=\n" + " thisReallyReallyReallyReallyReallyReallyLonger" + "Name ||\n" + " otherName < thisLastName) {\n" + " return;\n" + " }\n" + "}", + Style); + + Style.ContinuationIndentWidth = 2; + verifyFormat("void foo() {\n" + " if (ThisIsRatherALongIfClause && thatIExpectToBeBroken ||\n" + " ontoMultipleLines && whenFormattedCorrectly) {\n" + " if (false) {\n" + " return;\n" + " } else if (thisIsRatherALongIfClause && " + "thatIExpectToBeBroken ||\n" + " ontoMultipleLines && whenFormattedCorrectly) {\n" + " return;\n" + " }\n" + " }\n" + "}", + Style); +} + +TEST_F(AlignBracketsTest, AlignAfterOpenBracketBlockIndentForStatement) { + auto Style = getLLVMStyle(); + + verifyFormat("for (int i = 0; i < 5; ++i) {\n" + " doSomething();\n" + "}", + Style); + + verifyFormat("for (int myReallyLongCountVariable = 0; " + "myReallyLongCountVariable < count;\n" + " myReallyLongCountVariable++) {\n" + " doSomething();\n" + "}", + Style); + + Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; + + verifyFormat("for (int i = 0; i < 5; ++i) {\n" + " doSomething();\n" + "}", + Style); + + verifyFormat("for (int myReallyLongCountVariable = 0; " + "myReallyLongCountVariable < count;\n" + " myReallyLongCountVariable++) {\n" + " doSomething();\n" + "}", + Style); +} + +TEST_F(AlignBracketsTest, AlignAfterOpenBracketBlockIndentInitializers) { + auto Style = getLLVMStyleWithColumns(60); + Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; + // Aggregate initialization. + verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n" + " 10000000, 20000000\n" + "};", + Style); + verifyFormat("SomeStruct s{\n" + " \"xxxxxxxxxxxxxxxx\", \"yyyyyyyyyyyyyyyy\",\n" + " \"zzzzzzzzzzzzzzzz\"\n" + "};", + Style); + // Designated initializers. + verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n" + " [0] = 10000000, [1] = 20000000\n" + "};", + Style); + verifyFormat("SomeStruct s{\n" + " .foo = \"xxxxxxxxxxxxx\",\n" + " .bar = \"yyyyyyyyyyyyy\",\n" + " .baz = \"zzzzzzzzzzzzz\"\n" + "};", + 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}}\n" + "};", + 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}}\n" + "};", + 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); +} + +TEST_F(AlignBracketsTest, 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(AlignBracketsTest, 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(AlignBracketsTest, 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(AlignBracketsTest, 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); +} + +} // namespace +} // namespace test +} // namespace format +} // namespace clang diff --git a/clang/unittests/Format/CMakeLists.txt b/clang/unittests/Format/CMakeLists.txt index c4c7b483ba68e..5e5a7a0552993 100644 --- a/clang/unittests/Format/CMakeLists.txt +++ b/clang/unittests/Format/CMakeLists.txt @@ -1,6 +1,7 @@ # Format tests have few LLVM and Clang dependencies, so linking it as a # distinct target enables faster iteration times at low cost. add_distinct_clang_unittest(FormatTests + AlignBracketsTest.cpp BracesInserterTest.cpp BracesRemoverTest.cpp CleanupTest.cpp diff --git a/clang/unittests/Format/FormatTest.cpp b/clang/unittests/Format/FormatTest.cpp index 83c664c3b81f3..b0ae47dad2b50 100644 --- a/clang/unittests/Format/FormatTest.cpp +++ b/clang/unittests/Format/FormatTest.cpp @@ -8051,67 +8051,6 @@ TEST_F(FormatTest, AllowAllArgumentsOnNextLine) { 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" @@ -9030,97 +8969,6 @@ TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) { 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; @@ -9518,216 +9366,6 @@ TEST_F(FormatTest, AlignsAfterReturn) { " 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<bbbbbbbb> 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<of_very_long_type>;", - 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); - verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaa(\n" - " &bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\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" @@ -27572,405 +27210,6 @@ TEST_F(FormatTest, MultilineLambdaInConditional) { Style); } -TEST_F(FormatTest, AlignAfterOpenBracketBlockIndent) { - auto Style = getLLVMStyle(); - - StringRef Short = "functionCall(paramA, paramB, paramC);\n" - "void functionDecl(int a, int b, int c);"; - - StringRef Medium = "functionCall(paramA, paramB, paramC, paramD, paramE, " - "paramF, paramG, paramH, paramI);\n" - "void functionDecl(int argumentA, int argumentB, int " - "argumentC, int argumentD, int argumentE);"; - - verifyFormat(Short, Style); - - StringRef NoBreak = "functionCall(paramA, paramB, paramC, paramD, paramE, " - "paramF, paramG, paramH,\n" - " paramI);\n" - "void functionDecl(int argumentA, int argumentB, int " - "argumentC, int argumentD,\n" - " int argumentE);"; - - verifyFormat(NoBreak, Medium, Style); - verifyFormat(NoBreak, - "functionCall(\n" - " paramA,\n" - " paramB,\n" - " paramC,\n" - " paramD,\n" - " paramE,\n" - " paramF,\n" - " paramG,\n" - " paramH,\n" - " paramI\n" - ");\n" - "void functionDecl(\n" - " int argumentA,\n" - " int argumentB,\n" - " int argumentC,\n" - " int argumentD,\n" - " int argumentE\n" - ");", - Style); - - verifyFormat("outerFunctionCall(nestedFunctionCall(argument1),\n" - " nestedLongFunctionCall(argument1, " - "argument2, argument3,\n" - " argument4, " - "argument5));", - Style); - - Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; - - verifyFormat(Short, Style); - verifyFormat( - "functionCall(\n" - " paramA, paramB, paramC, paramD, paramE, paramF, paramG, paramH, " - "paramI\n" - ");\n" - "void functionDecl(\n" - " int argumentA, int argumentB, int argumentC, int argumentD, int " - "argumentE\n" - ");", - Medium, Style); - - Style.AllowAllArgumentsOnNextLine = false; - Style.AllowAllParametersOfDeclarationOnNextLine = false; - - verifyFormat(Short, Style); - verifyFormat( - "functionCall(\n" - " paramA, paramB, paramC, paramD, paramE, paramF, paramG, paramH, " - "paramI\n" - ");\n" - "void functionDecl(\n" - " int argumentA, int argumentB, int argumentC, int argumentD, int " - "argumentE\n" - ");", - Medium, Style); - - Style.BinPackArguments = false; - Style.BinPackParameters = FormatStyle::BPPS_OnePerLine; - - verifyFormat(Short, Style); - - verifyFormat("functionCall(\n" - " paramA,\n" - " paramB,\n" - " paramC,\n" - " paramD,\n" - " paramE,\n" - " paramF,\n" - " paramG,\n" - " paramH,\n" - " paramI\n" - ");\n" - "void functionDecl(\n" - " int argumentA,\n" - " int argumentB,\n" - " int argumentC,\n" - " int argumentD,\n" - " int argumentE\n" - ");", - Medium, Style); - - verifyFormat("outerFunctionCall(\n" - " nestedFunctionCall(argument1),\n" - " nestedLongFunctionCall(\n" - " argument1,\n" - " argument2,\n" - " argument3,\n" - " argument4,\n" - " argument5\n" - " )\n" - ");", - Style); - - verifyFormat("int a = (int)b;", Style); - verifyFormat("int a = (int)b;", - "int a = (\n" - " int\n" - ") b;", - Style); - - verifyFormat("return (true);", Style); - verifyFormat("return (true);", - "return (\n" - " true\n" - ");", - Style); - - verifyFormat("void foo();", Style); - verifyFormat("void foo();", - "void foo(\n" - ");", - Style); - - verifyFormat("void foo() {}", Style); - verifyFormat("void foo() {}", - "void foo(\n" - ") {\n" - "}", - Style); - - verifyFormat("auto string = std::string();", Style); - verifyFormat("auto string = std::string();", - "auto string = std::string(\n" - ");", - Style); - - verifyFormat("void (*functionPointer)() = nullptr;", Style); - verifyFormat("void (*functionPointer)() = nullptr;", - "void (\n" - " *functionPointer\n" - ")\n" - "(\n" - ") = nullptr;", - Style); -} - -TEST_F(FormatTest, AlignAfterOpenBracketBlockIndentIfStatement) { - auto Style = getLLVMStyle(); - - verifyFormat("if (foo()) {\n" - " return;\n" - "}", - Style); - - verifyFormat("if (quiteLongArg !=\n" - " (alsoLongArg - 1)) { // ABC is a very longgggggggggggg " - "comment\n" - " return;\n" - "}", - Style); - - Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; - - verifyFormat("if (foo()) {\n" - " return;\n" - "}", - Style); - - verifyFormat("if (quiteLongArg !=\n" - " (alsoLongArg - 1)) { // ABC is a very longgggggggggggg " - "comment\n" - " return;\n" - "}", - Style); - - verifyFormat("void foo() {\n" - " if (camelCaseName < alsoLongName ||\n" - " anotherEvenLongerName <=\n" - " thisReallyReallyReallyReallyReallyReallyLongerName ||" - "\n" - " otherName < thisLastName) {\n" - " return;\n" - " } else if (quiteLongName < alsoLongName ||\n" - " anotherEvenLongerName <=\n" - " thisReallyReallyReallyReallyReallyReallyLonger" - "Name ||\n" - " otherName < thisLastName) {\n" - " return;\n" - " }\n" - "}", - Style); - - Style.ContinuationIndentWidth = 2; - verifyFormat("void foo() {\n" - " if (ThisIsRatherALongIfClause && thatIExpectToBeBroken ||\n" - " ontoMultipleLines && whenFormattedCorrectly) {\n" - " if (false) {\n" - " return;\n" - " } else if (thisIsRatherALongIfClause && " - "thatIExpectToBeBroken ||\n" - " ontoMultipleLines && whenFormattedCorrectly) {\n" - " return;\n" - " }\n" - " }\n" - "}", - Style); -} - -TEST_F(FormatTest, AlignAfterOpenBracketBlockIndentForStatement) { - auto Style = getLLVMStyle(); - - verifyFormat("for (int i = 0; i < 5; ++i) {\n" - " doSomething();\n" - "}", - Style); - - verifyFormat("for (int myReallyLongCountVariable = 0; " - "myReallyLongCountVariable < count;\n" - " myReallyLongCountVariable++) {\n" - " doSomething();\n" - "}", - Style); - - Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; - - verifyFormat("for (int i = 0; i < 5; ++i) {\n" - " doSomething();\n" - "}", - Style); - - verifyFormat("for (int myReallyLongCountVariable = 0; " - "myReallyLongCountVariable < count;\n" - " myReallyLongCountVariable++) {\n" - " doSomething();\n" - "}", - Style); -} - -TEST_F(FormatTest, AlignAfterOpenBracketBlockIndentInitializers) { - auto Style = getLLVMStyleWithColumns(60); - Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent; - // Aggregate initialization. - verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n" - " 10000000, 20000000\n" - "};", - Style); - verifyFormat("SomeStruct s{\n" - " \"xxxxxxxxxxxxxxxx\", \"yyyyyyyyyyyyyyyy\",\n" - " \"zzzzzzzzzzzzzzzz\"\n" - "};", - Style); - // Designated initializers. - verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n" - " [0] = 10000000, [1] = 20000000\n" - "};", - Style); - verifyFormat("SomeStruct s{\n" - " .foo = \"xxxxxxxxxxxxx\",\n" - " .bar = \"yyyyyyyyyyyyy\",\n" - " .baz = \"zzzzzzzzzzzzz\"\n" - "};", - 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}}\n" - "};", - 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}}\n" - "};", - 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); -} - TEST_F(FormatTest, UnderstandsDigraphs) { verifyFormat("int arr<:5:> = {};"); verifyFormat("int arr[5] = <%%>;"); _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
