This is an archive of the discontinued LLVM Phabricator instance.

Paths

Table of Contentst

-
clang/unittests/Format/
-
unittests/
-
Format/
1/1
FormatTest.cpp

Differential D159051

[clang-format][NFC] Change EXPECT_EQ to verifyFormat or verifyNoChang
ClosedPublic

Authored by owenpan on Aug 28 2023, 7:42 PM.

Download Raw Diff

Details

Reviewers

rymiel
HazardyKnusperkeks
MyDeveloperDay

Commits

rG8b131d2e1480: [clang-format][NFC] Change EXPECT_EQ to verifyFormat or verifyNoChange

Summary

Replaces some 600 EXPECT_EQ() to verifyFormat() or verifyNoChange() in FormatTest.cpp because the former neither checks stability of formatting nor tests formatting C++ as Objective C.

Also marks dozens of unstable test cases with FIXME comments.

Diff Detail

Repository: rG LLVM Github Monorepo

Event Timeline

owenpan created this revision.Aug 28 2023, 7:42 PM

Herald added projects: Restricted Project, Restricted Project, Restricted Project. · View Herald TranscriptAug 28 2023, 7:42 PM

Herald added reviewers: rymiel, HazardyKnusperkeks, MyDeveloperDay. · View Herald Transcript

Herald added a subscriber: cfe-commits. · View Herald Transcript

owenpan requested review of this revision.Aug 28 2023, 7:42 PM

Herald added a subscriber: ormris. · View Herald TranscriptAug 28 2023, 7:42 PM

Harbormaster completed remote builds in B255377: Diff 554139.Aug 28 2023, 8:42 PM

owenpan added inline comments.Aug 29 2023, 11:48 AM

clang/unittests/Format/FormatTest.cpp
23940	To be consistent with the surrounding test cases. (Will fix it before landing.)

HazardyKnusperkeks accepted this revision.Aug 29 2023, 12:26 PM

This revision is now accepted and ready to land.Aug 29 2023, 12:26 PM

+1 to this before we goto github

Closed by commit rG8b131d2e1480: [clang-format][NFC] Change EXPECT_EQ to verifyFormat or verifyNoChange (authored by owenpan). · Explain WhyAug 30 2023, 1:07 PM

This revision was automatically updated to reflect the committed changes.

owenpan added a commit: rG8b131d2e1480: [clang-format][NFC] Change EXPECT_EQ to verifyFormat or verifyNoChange.

rG14feca5d14f1 concludes the cleanup of this gigantic file WRT EXPECT_EQ.

Revision Contents

Path

Size

clang/

unittests/

Format/

FormatTest.cpp

8263 lines

Diff 554815

clang/unittests/Format/FormatTest.cpp

This file is larger than 256 KB, so syntax highlighting is disabled by default.

Show All 35 Lines

//===----------------------------------------------------------------------===//

// Basic function tests.

//===----------------------------------------------------------------------===//

TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { verifyFormat(";"); }

TEST_F(FormatTest, FormatsGlobalStatementsAt0) {

EXPECT_EQ("int i;", format(" int i;"));

verifyFormat("int i;", " int i;");

EXPECT_EQ("\nint i;", format(" \n\t \v \f int i;"));

verifyFormat("\nint i;", " \n\t \v \f int i;");

EXPECT_EQ("int i;\nint j;", format(" int i; int j;"));

verifyFormat("int i;\nint j;", " int i; int j;");

EXPECT_EQ("int i;\nint j;", format(" int i;\n int j;"));

verifyFormat("int i;\nint j;", " int i;\n int j;");

}

TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {

EXPECT_EQ("int i;", format("int\ni;"));

verifyFormat("int i;", "int\ni;");

}

TEST_F(FormatTest, FormatsNestedBlockStatements) {

EXPECT_EQ("{\n {\n {}\n }\n}", format("{{{}}}"));

verifyFormat("{\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) {

EXPECT_EQ("if (a) {\n"

verifyFormat("if (a) {\n"

" f();\n"

"}",

format("if(a){f();}"));

"if(a){f();}");

EXPECT_EQ(4, ReplacementCount);

EXPECT_EQ("if (a) {\n"

verifyNoChange("if (a) {\n"

" f();\n"

"}",

format("if (a) {\n"

" f();\n"

"}"));

"}");

EXPECT_EQ(0, ReplacementCount);

EXPECT_EQ("/*\r\n"

verifyNoChange("/*\r\n"

"\r\n"

"*/",

format("/*\r\n"

"\r\n"

"*/"));

"*/");

EXPECT_EQ(0, ReplacementCount);

}

TEST_F(FormatTest, RemovesEmptyLines) {

EXPECT_EQ("class C {\n"

verifyFormat("class C {\n"

" int i;\n"

"};",

format("class C {\n"

"class C {\n"

" int i;\n"

"\n"

"};"));

"};");

// Don't remove empty lines at the start of namespaces or extern "C" blocks.

EXPECT_EQ("namespace N {\n"

verifyFormat("namespace N {\n"

"\n"

"int i;\n"

"}",

format("namespace N {\n"

"namespace N {\n"

"\n"

"int i;\n"

"}",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("/* something */ namespace N {\n"

verifyFormat("/* something */ namespace N {\n"

"\n"

"int i;\n"

"}",

format("/* something */ namespace N {\n"

"/* something */ namespace N {\n"

"\n"

"int i;\n"

"}",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("inline namespace N {\n"

verifyFormat("inline namespace N {\n"

"\n"

"int i;\n"

"}",

format("inline namespace N {\n"

"inline namespace N {\n"

"\n"

"int i;\n"

"}",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("/* something */ inline namespace N {\n"

verifyFormat("/* something */ inline namespace N {\n"

"\n"

"int i;\n"

"}",

format("/* something */ inline namespace N {\n"

"/* something */ inline namespace N {\n"

"\n"

"int i;\n"

"}",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("export namespace N {\n"

verifyFormat("export namespace N {\n"

"\n"

"int i;\n"

"}",

format("export namespace N {\n"

"export namespace N {\n"

"\n"

"int i;\n"

"}",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("extern /**/ \"C\" /**/ {\n"

verifyFormat("extern /**/ \"C\" /**/ {\n"

"\n"

"int i;\n"

"}",

format("extern /**/ \"C\" /**/ {\n"

"extern /**/ \"C\" /**/ {\n"

"\n"

"int i;\n"

"}",

getGoogleStyle()));

getGoogleStyle());

auto CustomStyle = getLLVMStyle();

CustomStyle.BreakBeforeBraces = FormatStyle::BS_Custom;

CustomStyle.BraceWrapping.AfterNamespace = true;

CustomStyle.KeepEmptyLinesAtTheStartOfBlocks = false;

EXPECT_EQ("namespace N\n"

verifyFormat("namespace N\n"

"{\n"

"\n"

"int i;\n"

"}",

format("namespace N\n"

"namespace N\n"

"{\n"

"\n"

"int i;\n"

"}",

CustomStyle));

CustomStyle);

EXPECT_EQ("/* something */ namespace N\n"

verifyFormat("/* something */ namespace N\n"

"{\n"

"\n"

"int i;\n"

"}",

format("/* something */ namespace N {\n"

"/* something */ namespace N {\n"

"\n"

"int i;\n"

"}",

CustomStyle));

CustomStyle);

EXPECT_EQ("inline namespace N\n"

verifyFormat("inline namespace N\n"

"{\n"

"\n"

"int i;\n"

"}",

format("inline namespace N\n"

"inline namespace N\n"

"{\n"

"\n"

"int i;\n"

"}",

CustomStyle));

CustomStyle);

EXPECT_EQ("/* something */ inline namespace N\n"

verifyFormat("/* something */ inline namespace N\n"

"{\n"

"\n"

"int i;\n"

"}",

format("/* something */ inline namespace N\n"

"/* something */ inline namespace N\n"

"{\n"

"\n"

"int i;\n"

"}",

CustomStyle));

CustomStyle);

EXPECT_EQ("export namespace N\n"

verifyFormat("export namespace N\n"

"{\n"

"\n"

"int i;\n"

"}",

format("export namespace N\n"

"export namespace N\n"

"{\n"

"\n"

"int i;\n"

"}",

CustomStyle));

CustomStyle);

EXPECT_EQ("namespace a\n"

verifyFormat("namespace a\n"

"{\n"

"namespace b\n"

"{\n"

"\n"

"class AA {};\n"

"\n"

"} // namespace b\n"

"} // namespace a",

format("namespace a\n"

"namespace a\n"

"{\n"

"namespace b\n"

"{\n"

"\n"

"class AA {};\n"

"\n"

"}\n"

"}",

CustomStyle));

CustomStyle);

EXPECT_EQ("namespace A /* comment */\n"

verifyFormat("namespace A /* comment */\n"

"{\n"

"class B {}\n"

"} // namespace A",

format("namespace A /* comment */ { class B {} }", CustomStyle));

"namespace A /* comment */ { class B {} }", CustomStyle);

EXPECT_EQ("namespace A\n"

verifyFormat("namespace A\n"

"{ /* comment */\n"

"class B {}\n"

"} // namespace A",

format("namespace A {/* comment */ class B {} }", CustomStyle));

"namespace A {/* comment */ class B {} }", CustomStyle);

EXPECT_EQ("namespace A\n"

verifyFormat("namespace A\n"

"{ /* comment */\n"

"\n"

"class B {}\n"

"\n"

"} // namespace A",

format("namespace A { /* comment */\n"

"namespace A { /* comment */\n"

"\n"

"class B {}\n"

"\n"

"}",

CustomStyle));

CustomStyle);

EXPECT_EQ("namespace A /* comment */\n"

verifyFormat("namespace A /* comment */\n"

"{\n"

"\n"

"class B {}\n"

"\n"

"} // namespace A",

format("namespace A/* comment */ {\n"

"namespace A/* comment */ {\n"

"\n"

"class B {}\n"

"\n"

"}",

CustomStyle));

CustomStyle);

// ...but do keep inlining and removing empty lines for non-block extern "C"

// functions.

verifyGoogleFormat("extern \"C\" int f() { return 42; }");

EXPECT_EQ("extern \"C\" int f() {\n"

verifyFormat("extern \"C\" int f() {\n"

" int i = 42;\n"

" return i;\n"

"}",

format("extern \"C\" int f() {\n"

"extern \"C\" int f() {\n"

"\n"

" int i = 42;\n"

" return i;\n"

"}",

getGoogleStyle()));

getGoogleStyle());

// Remove empty lines at the beginning and end of blocks.

EXPECT_EQ("void f() {\n"

verifyFormat("void f() {\n"

"\n"

" if (a) {\n"

"\n"

" f();\n"

" }\n"

"}",

format("void f() {\n"

"void f() {\n"

"\n"

" if (a) {\n"

"\n"

" f();\n"

"\n"

" }\n"

"\n"

"}"));

"}");

EXPECT_EQ("void f() {\n"

verifyFormat("void f() {\n"

" if (a) {\n"

" f();\n"

" }\n"

"}",

format("void f() {\n"

"void f() {\n"

"\n"

" if (a) {\n"

"\n"

" f();\n"

"\n"

" }\n"

"\n"

"}",

getGoogleStyle()));

getGoogleStyle());

// Don't remove empty lines in more complex control statements.

EXPECT_EQ("void f() {\n"

verifyFormat("void f() {\n"

" if (a) {\n"

" f();\n"

"\n"

" } else if (b) {\n"

" f();\n"

" }\n"

"}",

format("void f() {\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;

EXPECT_EQ("namespace {\n"

verifyNoChange("namespace {\n"

"int i;\n"

"\n"

"}",

format("namespace {\n"

LLVMWithNoNamespaceFix);

"int i;\n"

verifyFormat("namespace {\n"

"\n"

"}",

LLVMWithNoNamespaceFix));

EXPECT_EQ("namespace {\n"

"int i;\n"

"}",

format("namespace {\n"

"int i;\n"

"}",

LLVMWithNoNamespaceFix));

LLVMWithNoNamespaceFix);

EXPECT_EQ("namespace {\n"

verifyNoChange("namespace {\n"

"int i;\n"

"\n"

"};",

format("namespace {\n"

"int i;\n"

"\n"

"};",

LLVMWithNoNamespaceFix));

LLVMWithNoNamespaceFix);

EXPECT_EQ("namespace {\n"

verifyFormat("namespace {\n"

"int i;\n"

"};",

format("namespace {\n"

"int i;\n"

"};",

LLVMWithNoNamespaceFix));

LLVMWithNoNamespaceFix);

EXPECT_EQ("namespace {\n"

verifyNoChange("namespace {\n"

"int i;\n"

"\n"

"}",

format("namespace {\n"

"int i;\n"

"\n"

"}"));

"}");

EXPECT_EQ("namespace {\n"

verifyFormat("namespace {\n"

"int i;\n"

"\n"

"} // namespace",

format("namespace {\n"

"namespace {\n"

"int i;\n"

"\n"

"} // namespace"));

"} // 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.KeepEmptyLinesAtTheStartOfBlocks = false;

EXPECT_EQ("class Foo\n"

verifyFormat("class Foo\n"

"{\n"

" Foo() {}\n"

"\n"

" void funk() {}\n"

"};",

format("class Foo\n"

"class Foo\n"

"{\n"

" Foo()\n"

" {\n"

" }\n"

"\n"

" void funk() {}\n"

"};",

Style));

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);");

▲ Show 20 Lines • Show All 1,387 Lines • ▼ Show 20 Lines

verifyFormat("if (a)\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.

EXPECT_EQ("/* comment */ #define A (parentheses)\n"

verifyNoChange("/* comment */ #define A (parentheses)\n"

"#",

"#");

format("/* 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)");

Show All 35 Lines

TEST_F(FormatTest, UnderstandsMacros) {

verifyFormat("MACRO(co_return##something)");

}

TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {

FormatStyle Style = getLLVMStyleWithColumns(60);

Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;

Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;

Style.BreakBeforeBraces = FormatStyle::BS_Allman;

EXPECT_EQ("#define A \\\n"

verifyFormat("#define A \\\n"

" if (HANDLEwernufrnuLwrmviferuvnierv) \\\n"

" { \\\n"

" RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"

" }\n"

"X;",

format("#define A \\\n"

"#define A \\\n"

" if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"

" RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"

" }\n"

"X;",

Style));

Style);

}

TEST_F(FormatTest, ParseIfElse) {

verifyFormat("if (true)\n"

" if (true)\n"

" f();\n"

" else\n"

▲ Show 20 Lines • Show All 652 Lines • ▼ Show 20 Lines

verifyFormat("DEBUG({\n"

" f();\n"

" break;\n"

" // fallthrough\n"

" case B:\n"

" g();\n"

" break;\n"

" }\n"

"});");

EXPECT_EQ("DEBUG({\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"

"});",

"});");

format("DEBUG({\n"

verifyFormat("switch (n) {\n"

" switch (x) {\n"

" case A:\n"

" f();\n"

" break;\n"

" // On B:\n"

" case B:\n"

" g();\n"

" break;\n"

" }\n"

"});"));

EXPECT_EQ("switch (n) {\n"

"case 0: {\n"

" return false;\n"

"}\n"

"default: {\n"

" return true;\n"

"}\n"

"}",

format("switch (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"

▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines

verifyFormat("switch (a) {\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;

EXPECT_EQ("switch (n)\n"

verifyFormat("switch (n)\n"

"{\n"

" case 0:\n"

" {\n"

" return false;\n"

" }\n"

" default:\n"

" {\n"

" return true;\n"

" }\n"

"}",

format("switch (n) {\n"

"switch (n) {\n"

" case 0: {\n"

" return false;\n"

" }\n"

" default: {\n"

" return true;\n"

" }\n"

"}",

Style));

Style);

Style.BraceWrapping.AfterCaseLabel = false;

EXPECT_EQ("switch (n)\n"

verifyFormat("switch (n)\n"

"{\n"

" case 0: {\n"

" return false;\n"

" }\n"

" default: {\n"

" return true;\n"

" }\n"

"}",

format("switch (n) {\n"

"switch (n) {\n"

" case 0:\n"

" {\n"

" return false;\n"

" }\n"

" default:\n"

" {\n"

" return true;\n"

" }\n"

"}",

Style));

Style);

Style.IndentCaseLabels = false;

Style.IndentCaseBlocks = true;

EXPECT_EQ("switch (n)\n"

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"

"}",

format("switch (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);

Style.IndentCaseLabels = true;

Style.IndentCaseBlocks = true;

EXPECT_EQ("switch (n)\n"

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"

"}",

format("switch (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);

}

TEST_F(FormatTest, CaseRanges) {

verifyFormat("switch (x) {\n"

"case 'A' ... 'Z':\n"

"case 1 ... 5:\n"

"case a ... b:\n"

" break;\n"

▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Lines

verifyFormat("switch (a) {\n"

"case 8:\n"

" x = 1; /* comment */\n"

" break;\n"

"case 9:\n"

" break; // comment line 1\n"

" // comment line 2\n"

"}",

Style);

EXPECT_EQ("switch (a) {\n"

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"

"}",

format("switch (a) {\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));

Style);

EXPECT_EQ("switch (a) {\n"

verifyFormat("switch (a) {\n"

"case 0:\n"

" return; // long long long long long long long long long long "

"long long comment\n"

" // line\n"

"}",

format("switch (a) {\n"

"switch (a) {\n"

"case 0: return; // long long long long long long long long "

"long long long long comment line\n"

"}",

Style));

Style);

EXPECT_EQ("switch (a) {\n"

verifyFormat("switch (a) {\n"

"case 0:\n"

" return; /* long long long long long long long long long long "

"long long comment\n"

" line */\n"

"}",

format("switch (a) {\n"

"switch (a) {\n"

"case 0: return; /* long long long long long long long long "

"long long long long comment line */\n"

"}",

Style));

Style);

verifyFormat("switch (a) {\n"

"#if FOO\n"

"case 0: return 0;\n"

"#endif\n"

"}",

Style);

verifyFormat("switch (a) {\n"

"case 1: {\n"

Show All 24 Lines

verifyFormat("switch (a) {\n"

"default:\n"

" y = 1;\n"

" break;\n"

"}",

Style);

Style.ColumnLimit = 80;

Style.AllowShortCaseLabelsOnASingleLine = false;

Style.IndentCaseLabels = true;

EXPECT_EQ("switch (n) {\n"

verifyFormat("switch (n) {\n"

" default /*comments*/:\n"

" return true;\n"

" case 0:\n"

" return false;\n"

"}",

format("switch (n) {\n"

"switch (n) {\n"

"default/*comments*/:\n"

" return true;\n"

"case 0:\n"

" return false;\n"

"}",

Style));

Style);

Style.AllowShortCaseLabelsOnASingleLine = true;

Style.BreakBeforeBraces = FormatStyle::BS_Custom;

Style.BraceWrapping.AfterCaseLabel = true;

Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;

EXPECT_EQ("switch (n)\n"

verifyFormat("switch (n)\n"

"{\n"

" case 0:\n"

" {\n"

" return false;\n"

" }\n"

" default:\n"

" {\n"

" return true;\n"

" }\n"

"}",

format("switch (n) {\n"

"switch (n) {\n"

" case 0: {\n"

" return false;\n"

" }\n"

" default:\n"

" {\n"

" return true;\n"

" }\n"

"}",

Style));

Style);

}

TEST_F(FormatTest, FormatsLabels) {

verifyFormat("void f() {\n"

" some_code();\n"

"test_label:\n"

" some_other_code();\n"

" {\n"

▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Lines

verifyFormat("{\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.

EXPECT_EQ("if (foo) {\n"

verifyFormat("if (foo) {\n"

" bar();\n"

"}",

format("if(foo){bar();}", Style));

"if(foo){bar();}", Style);

EXPECT_EQ("if (foo) {\n"

verifyFormat("if (foo) {\n"

" bar();\n"

"} else {\n"

" baz();\n"

"}",

format("if(foo){bar();}else{baz();}", Style));

"if(foo){bar();}else{baz();}", Style);

EXPECT_EQ("if (foo && bar) {\n"

verifyFormat("if (foo && bar) {\n"

" baz();\n"

"}",

format("if(foo&&bar){baz();}", Style));

"if(foo&&bar){baz();}", Style);

EXPECT_EQ("if (foo) {\n"

verifyFormat("if (foo) {\n"

" bar();\n"

"} else if (baz) {\n"

" quux();\n"

"}",

format("if(foo){bar();}else if(baz){quux();}", Style));

"if(foo){bar();}else if(baz){quux();}", Style);

EXPECT_EQ(

verifyFormat("if (foo) {\n"

"if (foo) {\n"

" bar();\n"

"} else if (baz) {\n"

" quux();\n"

"} else {\n"

" foobar();\n"

"}",

format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));

"if(foo){bar();}else if(baz){quux();}else{foobar();}", Style);

EXPECT_EQ("for (;;) {\n"

verifyFormat("for (;;) {\n"

" foo();\n"

"}",

format("for(;;){foo();}"));

"for(;;){foo();}");

EXPECT_EQ("while (1) {\n"

verifyFormat("while (1) {\n"

" foo();\n"

"}",

format("while(1){foo();}", Style));

"while(1){foo();}", Style);

EXPECT_EQ("switch (foo) {\n"

verifyFormat("switch (foo) {\n"

"case bar:\n"

" return;\n"

"}",

format("switch(foo){case bar:return;}", Style));

"switch(foo){case bar:return;}", Style);

EXPECT_EQ("try {\n"

verifyFormat("try {\n"

" foo();\n"

"} catch (...) {\n"

" bar();\n"

"}",

format("try{foo();}catch(...){bar();}", Style));

"try{foo();}catch(...){bar();}", Style);

EXPECT_EQ("do {\n"

verifyFormat("do {\n"

" foo();\n"

"} while (bar &&\n"

" baz);",

format("do{foo();}while(bar&&baz);", Style));

"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);

EXPECT_EQ("if (foo && bar &&\n"

verifyFormat("if (foo && bar &&\n"

" baz)\n"

"{\n"

" quux();\n"

"}",

format("if(foo&&bar&&baz){quux();}", Style));

"if(foo&&bar&&baz){quux();}", Style);

EXPECT_EQ("if (foo && bar &&\n"

verifyFormat("if (foo && bar &&\n"

" baz)\n"

"{\n"

" quux();\n"

"}",

format("if (foo && bar &&\n"

"if (foo && bar &&\n"

" baz) {\n"

" quux();\n"

"}",

Style));

Style);

EXPECT_EQ("if (foo) {\n"

verifyFormat("if (foo) {\n"

" bar();\n"

"} else if (baz ||\n"

" quux)\n"

"{\n"

" foobar();\n"

"}",

format("if(foo){bar();}else if(baz||quux){foobar();}", Style));

"if(foo){bar();}else if(baz||quux){foobar();}", Style);

EXPECT_EQ(

verifyFormat("if (foo) {\n"

"if (foo) {\n"

" bar();\n"

"} else if (baz ||\n"

" quux)\n"

"{\n"

" foobar();\n"

"} else {\n"

" barbaz();\n"

"}",

format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",

"if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",

Style));

Style);

EXPECT_EQ("for (int i = 0;\n"

verifyFormat("for (int i = 0;\n"

" i < 10; ++i)\n"

"{\n"

" foo();\n"

"}",

format("for(int i=0;i<10;++i){foo();}", Style));

"for(int i=0;i<10;++i){foo();}", Style);

EXPECT_EQ("foreach (int i,\n"

verifyFormat("foreach (int i,\n"

" list)\n"

"{\n"

" foo();\n"

"}",

format("foreach(int i, list){foo();}", Style));

"foreach(int i, list){foo();}", Style);

Style.ColumnLimit =

40; // to concentrate at brace wrapping, not line wrap due to column limit

EXPECT_EQ("foreach (int i, list) {\n"

verifyFormat("foreach (int i, list) {\n"

" foo();\n"

"}",

format("foreach(int i, list){foo();}", Style));

"foreach(int i, list){foo();}", Style);

Style.ColumnLimit =

20; // to concentrate at brace wrapping, not line wrap due to column limit

EXPECT_EQ("while (foo || bar ||\n"

verifyFormat("while (foo || bar ||\n"

" baz)\n"

"{\n"

" quux();\n"

"}",

format("while(foo||bar||baz){quux();}", Style));

"while(foo||bar||baz){quux();}", Style);

EXPECT_EQ("switch (\n"

verifyFormat("switch (\n"

" foo = barbaz)\n"

"{\n"

"case quux:\n"

" return;\n"

"}",

format("switch(foo=barbaz){case quux:return;}", Style));

"switch(foo=barbaz){case quux:return;}", Style);

EXPECT_EQ("try {\n"

verifyFormat("try {\n"

" foo();\n"

"} catch (\n"

" Exception &bar)\n"

"{\n"

" baz();\n"

"}",

format("try{foo();}catch(Exception&bar){baz();}", Style));

"try{foo();}catch(Exception&bar){baz();}", Style);

Style.ColumnLimit =

40; // to concentrate at brace wrapping, not line wrap due to column limit

EXPECT_EQ("try {\n"

verifyFormat("try {\n"

" foo();\n"

"} catch (Exception &bar) {\n"

" baz();\n"

"}",

format("try{foo();}catch(Exception&bar){baz();}", Style));

"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;

EXPECT_EQ(

verifyFormat("if (foo) {\n"

"if (foo) {\n"

" bar();\n"

"}\n"

"else if (baz ||\n"

" quux)\n"

"{\n"

" foobar();\n"

"}\n"

"else {\n"

" barbaz();\n"

"}",

format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",

"if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",

Style));

Style);

Style.BraceWrapping.BeforeCatch = true;

EXPECT_EQ("try {\n"

verifyFormat("try {\n"

" foo();\n"

"}\n"

"catch (...) {\n"

" baz();\n"

"}",

format("try{foo();}catch(...){baz();}", Style));

"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);

▲ Show 20 Lines • Show All 170 Lines • ▼ Show 20 Lines

verifyFormat("class A {\n"

" std::unique_ptr<int *[] /* okay */> b() { return nullptr; }\n"

"\n"

"private:\n"

" int c;\n"

"};");

}

TEST_F(FormatTest, SeparatesLogicalBlocks) {

EXPECT_EQ("class A {\n"

verifyFormat("class A {\n"

"public:\n"

" void f();\n"

"\n"

"private:\n"

" void g() {}\n"

" // test\n"

"protected:\n"

" int h;\n"

"};",

format("class A {\n"

"class A {\n"

"public:\n"

"void f();\n"

"private:\n"

"void g() {}\n"

"// test\n"

"protected:\n"

"int h;\n"

"};"));

"};");

EXPECT_EQ("class A {\n"

verifyFormat("class A {\n"

"protected:\n"

"public:\n"

" void f();\n"

"};",

format("class A {\n"

"class A {\n"

"protected:\n"

"\n"

"public:\n"

"\n"

" void f();\n"

"};"));

"};");

// Even ensure proper spacing inside macros.

EXPECT_EQ("#define B \\\n"

verifyFormat("#define B \\\n"

" class A { \\\n"

" protected: \\\n"

" public: \\\n"

" void f(); \\\n"

" };",

format("#define B \\\n"

"#define B \\\n"

" class A { \\\n"

" protected: \\\n"

" \\\n"

" public: \\\n"

" \\\n"

" void f(); \\\n"

" };",

getGoogleStyle()));

getGoogleStyle());

// But don't remove empty lines after macros ending in access specifiers.

EXPECT_EQ("#define A private:\n"

verifyFormat("#define A private:\n"

"\n"

"int i;",

format("#define A private:\n"

"#define A private:\n"

"\n"

"int i;"));

"int i;");

}

TEST_F(FormatTest, FormatsClasses) {

verifyFormat("class A : public B {};");

verifyFormat("class A : public ::B {};");

verifyFormat(

"class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"

▲ Show 20 Lines • Show All 149 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, FormatsEnum) {

verifyFormat("enum {\n"

" Bar = Foo<int, int>::value\n"

"};",

getLLVMStyleWithColumns(30));

verifyFormat("enum ShortEnum { A, B, C };");

verifyGoogleFormat("enum ShortEnum { A, B, C };");

EXPECT_EQ("enum KeepEmptyLines {\n"

verifyFormat("enum KeepEmptyLines {\n"

" ONE,\n"

"\n"

" TWO,\n"

"\n"

" THREE\n"

"}",

format("enum KeepEmptyLines {\n"

"enum KeepEmptyLines {\n"

" ONE,\n"

"\n"

" TWO,\n"

"\n"

" THREE\n"

"}"));

"}");

verifyFormat("enum E { // comment\n"

" ONE,\n"

" TWO\n"

"};\n"

"int i;");

FormatStyle EightIndent = getLLVMStyle();

EightIndent.IndentWidth = 8;

▲ Show 20 Lines • Show All 331 Lines • ▼ Show 20 Lines

verifyFormat("namespace {\n"

"class A {};\n"

"};",

LLVMWithNoNamespaceFix);

verifyFormat("namespace {\n"

"int SomeVariable = 0; // comment\n"

"} // namespace",

LLVMWithNoNamespaceFix);

EXPECT_EQ("#ifndef HEADER_GUARD\n"

verifyFormat("#ifndef HEADER_GUARD\n"

"#define HEADER_GUARD\n"

"namespace my_namespace {\n"

"int i;\n"

"} // my_namespace\n"

"#endif // HEADER_GUARD",

format("#ifndef HEADER_GUARD\n"

"#ifndef HEADER_GUARD\n"

" #define HEADER_GUARD\n"

" namespace my_namespace {\n"

"int i;\n"

"} // my_namespace\n"

"#endif // HEADER_GUARD",

LLVMWithNoNamespaceFix));

LLVMWithNoNamespaceFix);

EXPECT_EQ("namespace A::B {\n"

verifyFormat("namespace A::B {\n"

"class C {};\n"

"}",

format("namespace A::B {\n"

"class C {};\n"

"}",

LLVMWithNoNamespaceFix));

LLVMWithNoNamespaceFix);

FormatStyle Style = getLLVMStyle();

Style.NamespaceIndentation = FormatStyle::NI_All;

EXPECT_EQ("namespace out {\n"

verifyFormat("namespace out {\n"

" int i;\n"

" namespace in {\n"

" int i;\n"

" } // namespace in\n"

"} // namespace out",

format("namespace out {\n"

"namespace out {\n"

"int i;\n"

"namespace in {\n"

"int i;\n"

"} // namespace in\n"

"} // namespace out",

Style));

Style);

FormatStyle ShortInlineFunctions = getLLVMStyle();

ShortInlineFunctions.NamespaceIndentation = FormatStyle::NI_All;

ShortInlineFunctions.AllowShortFunctionsOnASingleLine =

FormatStyle::SFS_Inline;

verifyFormat("namespace {\n"

" void f() {\n"

" return;\n"

▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, FormatsNamespaces) {

verifyFormat("extern \"C\" {\n"

" void f() {\n"

" return;\n"

" }\n"

"} // namespace",

ShortInlineFunctions);

Style.NamespaceIndentation = FormatStyle::NI_Inner;

EXPECT_EQ("namespace out {\n"

verifyFormat("namespace out {\n"

"int i;\n"

"namespace in {\n"

" int i;\n"

"} // namespace in\n"

"} // namespace out",

format("namespace out {\n"

"namespace out {\n"

"int i;\n"

"namespace in {\n"

"int i;\n"

"} // namespace in\n"

"} // namespace out",

Style));

Style);

Style.NamespaceIndentation = FormatStyle::NI_None;

verifyFormat("template <class T>\n"

"concept a_concept = X<>;\n"

"namespace B {\n"

"struct b_struct {};\n"

"} // namespace B",

Style);

▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, NamespaceMacros) {

// 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);

EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"

verifyFormat("TESTSUITE(out) { TESTSUITE(in) {\n"

"}} // TESTSUITE(out::in)",

format("TESTSUITE(out) {\n"

"TESTSUITE(out) {\n"

"TESTSUITE(in) {\n"

"} // TESTSUITE(in)\n"

"} // TESTSUITE(out)",

Style));

Style);

EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"

verifyFormat("TESTSUITE(out) { TESTSUITE(in) {\n"

"}} // TESTSUITE(out::in)",

format("TESTSUITE(out) {\n"

"TESTSUITE(out) {\n"

"TESTSUITE(in) {\n"

"} // TESTSUITE(in)\n"

"} // TESTSUITE(out)",

Style));

Style);

// Do not merge different namespaces/macros

EXPECT_EQ("namespace out {\n"

verifyFormat("namespace out {\n"

"TESTSUITE(in) {\n"

"} // TESTSUITE(in)\n"

"} // namespace out",

format("namespace out {\n"

"TESTSUITE(in) {\n"

"} // TESTSUITE(in)\n"

"} // namespace out",

Style));

Style);

EXPECT_EQ("TESTSUITE(out) {\n"

verifyFormat("TESTSUITE(out) {\n"

"namespace in {\n"

"} // namespace in\n"

"} // TESTSUITE(out)",

format("TESTSUITE(out) {\n"

"namespace in {\n"

"} // namespace in\n"

"} // TESTSUITE(out)",

Style));

Style);

Style.NamespaceMacros.push_back("FOOBAR");

EXPECT_EQ("TESTSUITE(out) {\n"

verifyFormat("TESTSUITE(out) {\n"

"FOOBAR(in) {\n"

"} // FOOBAR(in)\n"

"} // TESTSUITE(out)",

format("TESTSUITE(out) {\n"

Style);

"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);

EXPECT_EQ("namespace out { namespace in {\n"

verifyFormat("namespace out { namespace in {\n"

"}} // namespace out::in",

format("namespace out {\n"

"namespace out {\n"

"namespace in {\n"

"} // namespace in\n"

"} // namespace out",

Style));

Style);

// Only namespaces which have both consecutive opening and end get compacted

EXPECT_EQ("namespace out {\n"

verifyFormat("namespace out {\n"

"namespace in1 {\n"

"} // namespace in1\n"

"namespace in2 {\n"

"} // namespace in2\n"

"} // namespace out",

format("namespace out {\n"

Style);

"namespace in1 {\n"

"} // namespace in1\n"

"namespace in2 {\n"

"} // namespace in2\n"

"} // namespace out",

Style));

EXPECT_EQ("namespace out {\n"

verifyFormat("namespace out {\n"

"int i;\n"

"namespace in {\n"

"int j;\n"

"} // namespace in\n"

"int k;\n"

"} // namespace out",

format("namespace out { int i;\n"

"namespace out { int i;\n"

"namespace in { int j; } // namespace in\n"

"int k; } // namespace out",

Style));

Style);

EXPECT_EQ("namespace A { namespace B { namespace C {\n"

verifyFormat("namespace A { namespace B { namespace C {\n"

"}}} // namespace A::B::C",

format("namespace A { namespace B {\n"

"namespace A { namespace B {\n"

"namespace C {\n"

"}} // namespace B::C\n"

"} // namespace A",

Style));

Style);

Style.ColumnLimit = 40;

EXPECT_EQ("namespace aaaaaaaaaa {\n"

verifyFormat("namespace aaaaaaaaaa {\n"

"namespace bbbbbbbbbb {\n"

"}} // namespace aaaaaaaaaa::bbbbbbbbbb",

format("namespace aaaaaaaaaa {\n"

"namespace aaaaaaaaaa {\n"

"namespace bbbbbbbbbb {\n"

"} // namespace bbbbbbbbbb\n"

"} // namespace aaaaaaaaaa",

Style));

Style);

EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"

verifyFormat("namespace aaaaaa { namespace bbbbbb {\n"

"namespace cccccc {\n"

"}}} // namespace aaaaaa::bbbbbb::cccccc",

format("namespace aaaaaa {\n"

"namespace aaaaaa {\n"

"namespace bbbbbb {\n"

"namespace cccccc {\n"

"} // namespace cccccc\n"

"} // namespace bbbbbb\n"

"} // namespace aaaaaa",

Style));

Style);

Style.ColumnLimit = 80;

// Extra semicolon after 'inner' closing brace prevents merging

EXPECT_EQ("namespace out { namespace in {\n"

verifyFormat("namespace out { namespace in {\n"

"}; } // namespace out::in",

format("namespace out {\n"

"namespace out {\n"

"namespace in {\n"

"}; // namespace in\n"

"} // namespace out",

Style));

Style);

// Extra semicolon after 'outer' closing brace is conserved

EXPECT_EQ("namespace out { namespace in {\n"

verifyFormat("namespace out { namespace in {\n"

"}}; // namespace out::in",

format("namespace out {\n"

"namespace out {\n"

"namespace in {\n"

"} // namespace in\n"

"}; // namespace out",

Style));

Style);

Style.NamespaceIndentation = FormatStyle::NI_All;

EXPECT_EQ("namespace out { namespace in {\n"

verifyFormat("namespace out { namespace in {\n"

" int i;\n"

"}} // namespace out::in",

format("namespace out {\n"

"namespace out {\n"

"namespace in {\n"

"int i;\n"

"} // namespace in\n"

"} // namespace out",

Style));

Style);

EXPECT_EQ("namespace out { namespace mid {\n"

verifyFormat("namespace out { namespace mid {\n"

" namespace in {\n"

" int j;\n"

" } // namespace in\n"

" int k;\n"

"}} // namespace out::mid",

format("namespace out { namespace mid {\n"

"namespace out { namespace mid {\n"

"namespace in { int j; } // namespace in\n"

"int k; }} // namespace out::mid",

Style));

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"

"}",

Show All 26 Lines

verifyFormat("namespace A { namespace B { namespace C {\n"

"} // namespace A\n"

"int main() {\n"

" if (true)\n"

" return 0;\n"

"}",

Style);

Style.NamespaceIndentation = FormatStyle::NI_Inner;

EXPECT_EQ("namespace out { namespace in {\n"

verifyFormat("namespace out { namespace in {\n"

" int i;\n"

"}} // namespace out::in",

format("namespace out {\n"

"namespace out {\n"

"namespace in {\n"

"int i;\n"

"} // namespace in\n"

"} // namespace out",

Style));

Style);

EXPECT_EQ("namespace out { namespace mid { namespace in {\n"

verifyFormat("namespace out { namespace mid { namespace in {\n"

" int i;\n"

"}}} // namespace out::mid::in",

format("namespace out {\n"

"namespace out {\n"

"namespace mid {\n"

"namespace in {\n"

"int i;\n"

"} // namespace in\n"

"} // namespace mid\n"

"} // namespace out",

Style));

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);

EXPECT_EQ("namespace out { namespace in {\n"

verifyFormat("namespace out { namespace in {\n"

"}} // namespace out::in",

format("namespace out {\n"

"namespace out {\n"

"namespace in {\n"

"} // namespace in\n"

"} // namespace out",

Style));

Style);

}

TEST_F(FormatTest, FormatsExternC) {

verifyFormat("extern \"C\" {\nint a;");

verifyFormat("extern \"C\" {}");

verifyFormat("extern \"C\" {\n"

"int foo();\n"

"}");

▲ Show 20 Lines • Show All 99 Lines • ▼ Show 20 Lines

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));");

EXPECT_EQ(

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"

"}",

format("void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\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"

"}"));

"}");

EXPECT_EQ("_asm {\n"

verifyNoChange("_asm {\n"

" xor eax, eax;\n"

" cpuid;\n"

"}",

format("_asm {\n"

" xor eax, eax;\n"

" cpuid;\n"

"}"));

"}");

verifyFormat("void function() {\n"

" // comment\n"

" asm(\"\");\n"

"}");

EXPECT_EQ("__asm {\n"

verifyFormat("__asm {\n"

"}\n"

"int i;",

format("__asm {\n"

"__asm {\n"

"}\n"

"int i;"));

"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));"};

▲ Show 20 Lines • Show All 221 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, StaticInitializers) {

verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"

" 100000000, "

"\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");

// Here, everything other than the "}" would fit on a line.

verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"

" 10000000000000000000000000};");

EXPECT_EQ("S s = {a,\n"

verifyFormat("S s = {a,\n"

"\n"

" b};",

format("S s = {\n"

"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));

}

▲ Show 20 Lines • Show All 286 Lines • ▼ Show 20 Lines

verifyFormat("virtual void ~Deeeeeeeestructor() =\n"

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));

EXPECT_EQ("#define Q \\\n"

verifyFormat("#define Q \\\n"

" \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\" \\\n"

" \"aaaaaaaa.cpp\"",

format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",

"#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",

getLLVMStyleWithColumns(40)));

getLLVMStyleWithColumns(40));

}

TEST_F(FormatTest, UnderstandsLinePPDirective) {

EXPECT_EQ("# 123 \"A string literal\"",

verifyFormat("# 123 \"A string literal\"",

format(" # 123 \"A string literal\""));

" # 123 \"A string literal\"");

}

TEST_F(FormatTest, LayoutUnknownPPDirective) {

verifyFormat("#;");

verifyFormat("#\n;\n;\n;");

}

TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {

EXPECT_EQ("#line 42 \"test\"",

verifyFormat("#line 42 \"test\"", "# \\\n line \\\n 42 \\\n \"test\"");

format("# \\\n line \\\n 42 \\\n \"test\""));

verifyFormat("#define A B", "# \\\n define \\\n A \\\n B",

EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B",

getLLVMStyleWithColumns(12));

getLLVMStyleWithColumns(12)));

}

TEST_F(FormatTest, EndOfFileEndsPPDirective) {

EXPECT_EQ("#line 42 \"test\"",

verifyFormat("#line 42 \"test\"", "# \\\n line \\\n 42 \\\n \"test\"");

format("# \\\n line \\\n 42 \\\n \"test\""));

verifyFormat("#define A B", "# \\\n define \\\n A \\\n B");

EXPECT_EQ("#define A B", format("# \\\n define \\\n A \\\n B"));

}

TEST_F(FormatTest, DoesntRemoveUnknownTokens) {

verifyFormat("#define A \\x20");

verifyFormat("#define A \\ x20");

EXPECT_EQ("#define A \\ x20", format("#define A \\ x20"));

verifyFormat("#define A \\ x20", "#define A \\ x20");

verifyFormat("#define A ''");

verifyFormat("#define A ''qqq");

verifyFormat("#define A `qqq");

verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");

EXPECT_EQ("const char *c = STRINGIFY(\n"

verifyFormat("const char *c = STRINGIFY(\n"

"\\na : b);",

format("const char * c = STRINGIFY(\n"

"const char * c = STRINGIFY(\n"

"\\na : b);"));

"\\na : b);");

verifyFormat("a\r\\");

verifyFormat("a\v\\");

verifyFormat("a\f\\");

}

TEST_F(FormatTest, IndentsPPDirectiveWithPPIndentWidth) {

FormatStyle style = getChromiumStyle(FormatStyle::LK_Cpp);

▲ Show 20 Lines • Show All 273 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {

verifyFormat("#define A A\n#define A A");

verifyFormat("#define A(X) A\n#define A A");

verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));

verifyFormat("#define Something \\\n Other", getLLVMStyleWithColumns(22));

}

TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {

EXPECT_EQ("// somecomment\n"

verifyFormat("// somecomment\n"

"#include \"a.h\"\n"

"#define A( \\\n"

" A, B)\n"

"#include \"b.h\"\n"

"// somecomment",

format(" // somecomment\n"

" // somecomment\n"

" #include \"a.h\"\n"

"#define A(A,\\\n"

" B)\n"

" #include \"b.h\"\n"

" // somecomment",

getLLVMStyleWithColumns(13)));

getLLVMStyleWithColumns(13));

}

TEST_F(FormatTest, LayoutSingleHash) { verifyFormat("#\na;"); }

TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {

EXPECT_EQ("#define A \\\n"

verifyFormat("#define A \\\n"

" c; \\\n"

" e;\n"

"f;",

format("#define A c; e;\n"

"#define A c; e;\n"

"f;",

getLLVMStyleWithColumns(14)));

getLLVMStyleWithColumns(14));

}

TEST_F(FormatTest, LayoutRemainingTokens) { verifyFormat("{}"); }

TEST_F(FormatTest, MacroDefinitionInsideStatement) {

EXPECT_EQ("int x,\n"

verifyFormat("int x,\n"

"#define A\n"

" y;",

format("int x,\n#define A\ny;"));

"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");

Show All 25 Lines

TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {

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) {

EXPECT_EQ("#define A b;", format("#define A \\\n"

verifyFormat("#define A b;",

"#define A \\\n"

" \\\n"

" b;",

getLLVMStyleWithColumns(25)));

getLLVMStyleWithColumns(25));

EXPECT_EQ("#define A \\\n"

verifyNoChange("#define A \\\n"

" \\\n"

" a; \\\n"

" b;",

format("#define A \\\n"

" \\\n"

" a; \\\n"

" b;",

getLLVMStyleWithColumns(11)));

getLLVMStyleWithColumns(11));

EXPECT_EQ("#define A \\\n"

verifyNoChange("#define A \\\n"

" a; \\\n"

" \\\n"

" b;",

format("#define A \\\n"

" a; \\\n"

" \\\n"

" b;",

getLLVMStyleWithColumns(11)));

getLLVMStyleWithColumns(11));

}

TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {

verifyIncompleteFormat("#define A :");

verifyFormat("#define SOMECASES \\\n"

" case 1: \\\n"

" case 2",

getLLVMStyleWithColumns(20));

▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {

verifyNoCrash("#endif\n"

"#else");

verifyNoCrash("#endif\n"

"#elif Y");

}

TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {

verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.

EXPECT_EQ("class A : public QObject {\n"

verifyFormat("class A : public QObject {\n"

" Q_OBJECT\n"

"\n"

" A() {}\n"

"};",

format("class A : public QObject {\n"

"class A : public QObject {\n"

" Q_OBJECT\n"

"\n"

" A() {\n}\n"

"} ;"));

"} ;");

EXPECT_EQ("MACRO\n"

verifyFormat("MACRO\n"

"/*static*/ int i;",

format("MACRO\n"

"MACRO\n"

" /*static*/ int i;"));

" /*static*/ int i;");

EXPECT_EQ("SOME_MACRO\n"

verifyFormat("SOME_MACRO\n"

"namespace {\n"

"void f();\n"

"} // namespace",

format("SOME_MACRO\n"

"SOME_MACRO\n"

" namespace {\n"

"void f( );\n"

"} // namespace"));

"} // namespace");

// Only if the identifier contains at least 5 characters.

EXPECT_EQ("HTTP f();", format("HTTP\nf();"));

verifyFormat("HTTP f();", "HTTP\nf();");

verifyNoChange("MACRO\nf();");

// Only if everything is upper case.

EXPECT_EQ("class A : public QObject {\n"

verifyFormat("class A : public QObject {\n"

" Q_Object A() {}\n"

"};",

format("class A : public QObject {\n"

"class A : public QObject {\n"

" Q_Object\n"

" A() {\n}\n"

"} ;"));

"} ;");

// Only if the next line can actually start an unwrapped line.

EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",

verifyFormat("SOME_WEIRD_LOG_MACRO << SomeThing;", "SOME_WEIRD_LOG_MACRO\n"

format("SOME_WEIRD_LOG_MACRO\n"

"<< SomeThing;");

"<< SomeThing;"));

verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "

"(n, buffers))",

getChromiumStyle(FormatStyle::LK_Cpp));

// See PR41483

EXPECT_EQ("/**/ FOO(a)\n"

verifyNoChange("/**/ FOO(a)\n"

"FOO(b)",

"FOO(b)");

format("/**/ FOO(a)\n"

"FOO(b)"));

}

TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {

EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"

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; }",

format(" INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"

" 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; }"));

" int *createScopDetectionPass() { return 0; }");

// FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as

// braces, so that inner block is indented one level more.

EXPECT_EQ("int q() {\n"

verifyFormat("int q() {\n"

" IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"

" IPC_MESSAGE_HANDLER(xxx, qqq)\n"

" IPC_END_MESSAGE_MAP()\n"

"}",

format("int q() {\n"

"int q() {\n"

" IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"

" IPC_MESSAGE_HANDLER(xxx, qqq)\n"

" IPC_END_MESSAGE_MAP()\n"

"}"));

"}");

// Same inside macros.

EXPECT_EQ("#define LIST(L) \\\n"

verifyFormat("#define LIST(L) \\\n"

" L(A) \\\n"

" L(B) \\\n"

" L(C)",

format("#define LIST(L) \\\n"

"#define LIST(L) \\\n"

" L(A) \\\n"

" L(B) \\\n"

" L(C)",

getGoogleStyle()));

getGoogleStyle());

// These must not be recognized as macros.

EXPECT_EQ("int q() {\n"

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"

"}",

format("int q() {\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"

"}"));

"}");

EXPECT_EQ("int q() {\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"

"}",

format("int q() {\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"

"}"));

"}");

EXPECT_EQ("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"

"};",

format("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;

EXPECT_EQ("void f()\n"

verifyFormat("void f()\n"

"try\n"

"{\n"

"}",

format("void f() try {\n"

"void f() try {\n"

"}",

Style));

Style);

EXPECT_EQ("class SomeClass {\n"

verifyFormat("class SomeClass {\n"

"public:\n"

" SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"

"};",

format("class SomeClass {\n"

"class SomeClass {\n"

"public:\n"

" SomeClass()\n"

" EXCLUSIVE_LOCK_FUNCTION(mu_);\n"

"};"));

"};");

EXPECT_EQ("class SomeClass {\n"

verifyFormat("class SomeClass {\n"

"public:\n"

" SomeClass()\n"

" EXCLUSIVE_LOCK_FUNCTION(mu_);\n"

"};",

format("class SomeClass {\n"

"class SomeClass {\n"

"public:\n"

" SomeClass()\n"

" EXCLUSIVE_LOCK_FUNCTION(mu_);\n"

"};",

getLLVMStyleWithColumns(40)));

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"

▲ Show 20 Lines • Show All 167 Lines • ▼ Show 20 Lines

verifyFormat("#if 1\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.

EXPECT_EQ("#ifndef NOT_GUARD\n"

verifyFormat("#ifndef NOT_GUARD\n"

"code();\n"

"#define NOT_GUARD\n"

"code();\n"

"#endif",

format("#ifndef NOT_GUARD\n"

"#ifndef NOT_GUARD\n"

"code();\n"

"# define NOT_GUARD\n"

"code();\n"

"#endif",

Style));

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.

EXPECT_EQ("#ifdef WIN32\n"

verifyFormat("#ifdef WIN32\n"

"# pragma once\n"

"#endif\n"

"#ifndef HEADER_H\n"

"# define HEADER_H\n"

"code();\n"

"#endif",

format("#ifdef WIN32\n"

"#ifdef WIN32\n"

"# pragma once\n"

"#endif\n"

"#ifndef HEADER_H\n"

"#define HEADER_H\n"

"code();\n"

"#endif",

Style));

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.

EXPECT_EQ("code();\n"

verifyFormat("code();\n"

"#ifndef HEADER_H\n"

"#define HEADER_H\n"

"code();\n"

"#endif",

format("code();\n"

"code();\n"

"#ifndef HEADER_H\n"

"# define HEADER_H\n"

"code();\n"

"#endif",

Style));

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"

Show All 10 Lines

const char *ToFormat = ""

"// 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";

EXPECT_EQ(Expected, format(ToFormat, Style));

verifyFormat(Expected, ToFormat, Style);

verifyNoChange(Expected, Style);

}

// Keep block quotes aligned.

{

const char *Expected = ""

"void f() {\n"

"#if 1\n"

"/* Preprocessor aligned. */\n"

Show All 10 Lines

const char *ToFormat = ""

"/* 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";

EXPECT_EQ(Expected, format(ToFormat, Style));

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";

EXPECT_EQ(Expected, format(ToFormat, Style));

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;

▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines

const char *ToFormat = "void f() {\n"

"#if 1\n"

"// Aligned to preprocessor.\n"

"#define A 0\n"

"// Aligned to code.\n"

"int b;\n"

"#endif\n"

"}";

EXPECT_EQ(Expected, format(ToFormat, Style));

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"

Show All 13 Lines

const char *ToFormat = "void f() {\n"

"#if 1\n"

"/* Aligned to preprocessor. */\n"

"#define A 0\n"

"/* Aligned to code. */\n"

"int b;\n"

"#endif\n"

"}";

EXPECT_EQ(Expected, format(ToFormat, Style));

verifyFormat(Expected, ToFormat, Style);

verifyNoChange(Expected, Style);

}

// Test single comment before preprocessor

verifyFormat("// Comment\n"

"\n"

"#if 1\n"

"#endif",

▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines

verifyFormat("void f() {\n"

Style);

}

TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {

verifyFormat("{\n { a #c; }\n}");

}

TEST_F(FormatTest, FormatUnbalancedStructuralElements) {

EXPECT_EQ("#define A \\\n { \\\n {\nint i;",

verifyFormat("#define A \\\n { \\\n {\nint i;",

format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));

"#define A { {\nint i;", getLLVMStyleWithColumns(11));

EXPECT_EQ("#define A \\\n } \\\n }\nint i;",

verifyFormat("#define A \\\n } \\\n }\nint i;",

format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));

"#define A } }\nint i;", getLLVMStyleWithColumns(11));

}

TEST_F(FormatTest, EscapedNewlines) {

FormatStyle Narrow = getLLVMStyleWithColumns(11);

EXPECT_EQ("#define A \\\n int i; \\\n int j;",

verifyFormat("#define A \\\n int i; \\\n int j;",

format("#define A \\\nint i;\\\n int j;", Narrow));

"#define A \\\nint i;\\\n int j;", Narrow);

EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));

verifyFormat("#define A\n\nint i;", "#define A \\\n\n int i;");

EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));

verifyFormat("template <class T> f();", "\\\ntemplate <class T> f();");

EXPECT_EQ("/* \\ \\ \\\n */", format("\\\n/* \\ \\ \\\n */"));

verifyFormat("/* \\ \\ \\\n */", "\\\n/* \\ \\ \\\n */");

verifyNoChange("<a\n\\\\\n>");

FormatStyle AlignLeft = getLLVMStyle();

AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;

EXPECT_EQ("#define MACRO(x) \\\n"

verifyFormat("#define MACRO(x) \\\n"

"private: \\\n"

" int x(int a);",

format("#define MACRO(x) \\\n"

AlignLeft);

"private: \\\n"

" int x(int a);",

AlignLeft));

// CRLF line endings

EXPECT_EQ("#define A \\\r\n int i; \\\r\n int j;",

verifyFormat("#define A \\\r\n int i; \\\r\n int j;",

format("#define A \\\r\nint i;\\\r\n int j;", Narrow));

"#define A \\\r\nint i;\\\r\n int j;", Narrow);

EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));

verifyFormat("#define A\r\n\r\nint i;", "#define A \\\r\n\r\n int i;");

EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));

verifyFormat("template <class T> f();", "\\\ntemplate <class T> f();");

EXPECT_EQ("/* \\ \\ \\\r\n */", format("\\\r\n/* \\ \\ \\\r\n */"));

verifyFormat("/* \\ \\ \\\r\n */", "\\\r\n/* \\ \\ \\\r\n */");

verifyNoChange("<a\r\n\\\\\r\n>");

EXPECT_EQ("#define MACRO(x) \\\r\n"

verifyFormat("#define MACRO(x) \\\r\n"

"private: \\\r\n"

" int x(int a);",

format("#define MACRO(x) \\\r\n"

AlignLeft);

"private: \\\r\n"

" int x(int a);",

AlignLeft));

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

EXPECT_EQ("#define A \\\n"

verifyNoChange("#define A \\\n"

" class Foo { \\\n"

" void bar(); \\\n"

"\\\n"

" public: \\\n"

" void baz(); \\\n"

" };",

format("#define A \\\n"

DontAlign);

" class Foo { \\\n"

" void bar(); \\\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) {

EXPECT_EQ(

verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("

"#define ALooooooooooooooooooooooooooooooooooooooongMacro("

" \\\n"

" aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"

"\n"

"AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"

" aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);",

format(" #define ALooooooooooooooooooooooooooooooooooooooongMacro("

" #define ALooooooooooooooooooooooooooooooooooooooongMacro("

"\\\n"

"aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"

" \n"

" AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"

" aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);"));

" aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);");

}

TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {

EXPECT_EQ("int\n"

verifyFormat("int\n"

"#define A\n"

" a;",

format("int\n#define A\na;"));

"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"

▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines

verifyFormat(

" ccccccccccccccccc));");

verifyFormat("DEBUG({\n"

" if (a)\n"

" f();\n"

"});");

}

TEST_F(FormatTest, LayoutBlockInsideStatement) {

EXPECT_EQ("SOME_MACRO { int i; }\n"

verifyFormat("SOME_MACRO { int i; }\n"

"int i;",

format(" SOME_MACRO {int i;} 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"

Show All 9 Lines

TEST_F(FormatTest, LayoutNestedBlocks) {

verifyFormat("DEBUG( //\n"

" { f(); }, a);");

verifyFormat("DEBUG( //\n"

" {\n"

" f(); //\n"

" },\n"

" a);");

EXPECT_EQ("call(parameter, {\n"

verifyFormat("call(parameter, {\n"

" something();\n"

" // Comment too\n"

" // looooooooooong.\n"

" somethingElse();\n"

"});",

format("call(parameter, {\n"

"call(parameter, {\n"

" something();\n"

" // Comment too looooooooooong.\n"

" somethingElse();\n"

"});",

getLLVMStyleWithColumns(29)));

getLLVMStyleWithColumns(29));

EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int i; });"));

verifyFormat("DEBUG({ int i; });", "DEBUG({ int i; });");

EXPECT_EQ("DEBUG({ // comment\n"

verifyFormat("DEBUG({ // comment\n"

" int i;\n"

"});",

format("DEBUG({ // comment\n"

"DEBUG({ // comment\n"

"int i;\n"

"});"));

"});");

EXPECT_EQ("DEBUG({\n"

verifyFormat("DEBUG({\n"

" int i;\n"

"\n"

" // comment\n"

" int j;\n"

"});",

format("DEBUG({\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) {

EXPECT_EQ("#define MACRO() \\\n"

verifyFormat("#define MACRO() \\\n"

" Debug(aaa, /* force line break */ \\\n"

" { \\\n"

" int i; \\\n"

" int j; \\\n"

" })",

format("#define MACRO() Debug(aaa, /* force line break */ \\\n"

"#define MACRO() Debug(aaa, /* force line break */ \\\n"

" { int i; int j; })",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("#define A \\\n"

verifyFormat("#define A \\\n"

" [] { \\\n"

" xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"

" xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"

" }",

format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"

"#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"

"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",

getGoogleStyle()));

getGoogleStyle());

}

TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {

verifyFormat("{}");

verifyFormat("enum E {};");

verifyFormat("enum E {}");

FormatStyle Style = getLLVMStyle();

Style.SpaceInEmptyBlock = true;

EXPECT_EQ("void f() { }", format("void f() {}", Style));

verifyFormat("void f() { }", "void f() {}", Style);

Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;

EXPECT_EQ("while (true) { }", format("while (true) {}", 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"

▲ Show 20 Lines • Show All 299 Lines • ▼ Show 20 Lines

verifyFormat("zzzzzzzzzz\n"

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;

EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"

verifyFormat("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"

"\t&& (someOtherLongishConditionPart1\n"

"\t\t|| someOtherEvenLongerNestedConditionPart2);",

format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "

"return someVeryVeryLongConditionThatBarelyFitsOnALine && "

"(someOtherLongishConditionPart1 || "

"someOtherEvenLongerNestedConditionPart2);",

Style));

Style);

}

TEST_F(FormatTest, ExpressionIndentationStrictAlign) {

FormatStyle Style = getLLVMStyle();

Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;

Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;

verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"

▲ Show 20 Lines • Show All 352 Lines • ▼ Show 20 Lines

verifyFormat(

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",

OnePerLine);

OnePerLine.ColumnLimit = 60;

verifyFormat("Constructor()\n"

" : aaaaaaaaaaaaaaaaaaaa(a),\n"

" bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",

OnePerLine);

EXPECT_EQ("Constructor()\n"

verifyFormat("Constructor()\n"

" : // Comment forcing unwanted break.\n"

" aaaa(aaaa) {}",

format("Constructor() :\n"

"Constructor() :\n"

" // Comment forcing unwanted break.\n"

" aaaa(aaaa) {}"));

" aaaa(aaaa) {}");

}

TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {

FormatStyle Style = getLLVMStyleWithColumns(60);

Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;

Style.BinPackParameters = false;

for (int i = 0; i < 4; ++i) {

▲ Show 20 Lines • Show All 770 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, BreaksFunctionDeclarations) {

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.

EXPECT_EQ("const aaaa::bbbbbbb &\n"

verifyFormat("const aaaa::bbbbbbb &\n"

"ccccccccc::operator++() {\n"

" stuff();\n"

"}",

format("const aaaa::bbbbbbb\n"

"const aaaa::bbbbbbb\n"

"&ccccccccc::operator++() { stuff(); }",

getLLVMStyleWithColumns(40)));

getLLVMStyleWithColumns(40));

}

TEST_F(FormatTest, TrailingReturnType) {

verifyFormat("auto foo() -> int;");

// correct trailing return type spacing

verifyFormat("auto operator->() -> int;");

verifyFormat("auto operator++(int) -> int;");

▲ Show 20 Lines • Show All 232 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, BreaksDesireably) {

verifyFormat("{\n {\n {\n"

" Annotation.SpaceRequiredBefore =\n"

" Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"

" Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"

" }\n }\n}");

// Break on an outer level if there was a break on an inner level.

EXPECT_EQ("f(g(h(a, // comment\n"

verifyFormat("f(g(h(a, // comment\n"

" b, c),\n"

" d, e),\n"

" x, y);",

format("f(g(h(a, // comment\n"

"f(g(h(a, // comment\n"

" b, c), d, e), x, y);"));

" b, c), d, e), x, y);");

// Prefer breaking similar line breaks.

verifyFormat(

"const int kTrackingOptions = NSTrackingMouseMoved |\n"

" NSTrackingMouseEnteredAndExited |\n"

" NSTrackingActiveAlways;");

}

▲ Show 20 Lines • Show All 783 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, BreaksConditionalExpressions) {

// 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);

EXPECT_EQ(

verifyFormat(

"MMMMMMMMMMMMMMMMMMMMMMMMMMM = A ?\n"

" /*\n"

" */\n"

" function() {\n"

" try {\n"

" return JJJJJJJJJJJJJJ(\n"

" pppppppppppppppppppppppppppppppppppppppppppppppppp);\n"

" }\n"

" } :\n"

" function() {};",

format(

"MMMMMMMMMMMMMMMMMMMMMMMMMMM = A ?\n"

" /*\n"

" */\n"

" function() {\n"

" try {\n"

" return JJJJJJJJJJJJJJ(\n"

" pppppppppppppppppppppppppppppppppppppppppppppppppp);\n"

" }\n"

" } :\n"

" function() {};",

getGoogleStyle(FormatStyle::LK_JavaScript)));

getGoogleStyle(FormatStyle::LK_JavaScript));

}

TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {

FormatStyle Style = getLLVMStyleWithColumns(70);

Style.BreakBeforeTernaryOperators = false;

verifyFormat(

"aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"

▲ Show 20 Lines • Show All 272 Lines • ▼ Show 20 Lines

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);");

EXPECT_EQ("fun + \"1243\" /* comment */\n"

verifyFormat("fun + \"1243\" /* comment */\n"

" \"5678\";",

format("fun + \"1243\" /* comment */\n"

"fun + \"1243\" /* comment */\n"

" \"5678\";",

getLLVMStyleWithColumns(28)));

getLLVMStyleWithColumns(28));

EXPECT_EQ(

verifyFormat(

"aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"

" \"aaaaaaaaaaaaaaaaaaaaa\"\n"

" \"aaaaaaaaaaaaaaaa\";",

format("aaaaaa ="

"aaaaaa ="

"\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "

"aaaaaaaaaaaaaaaaaaaaa\" "

"\"aaaaaaaaaaaaaaaa\";"));

"\"aaaaaaaaaaaaaaaa\";");

verifyFormat("a = a + \"a\"\n"

" \"a\"\n"

" \"a\";");

verifyFormat("f(\"a\", \"b\"\n"

" \"c\");");

verifyFormat(

"#define LL_FORMAT \"ll\"\n"

▲ Show 20 Lines • Show All 401 Lines • ▼ Show 20 Lines

verifyFormat("string foo = abc ? \"x\"\n"

Break);

// Don't break if there is no column gain.

verifyFormat("f(\"aaaa\"\n"

" \"bbbb\");",

Break);

// Treat literals with escaped newlines like multi-line string literals.

EXPECT_EQ("x = \"a\\\n"

verifyNoChange("x = \"a\\\n"

"b\\\n"

"c\";",

format("x = \"a\\\n"

"b\\\n"

"c\";",

NoBreak));

NoBreak);

EXPECT_EQ("xxxx =\n"

verifyFormat("xxxx =\n"

" \"a\\\n"

"b\\\n"

"c\";",

format("xxxx = \"a\\\n"

"xxxx = \"a\\\n"

"b\\\n"

"c\";",

Break));

Break);

EXPECT_EQ("NSString *const kString =\n"

verifyFormat("NSString *const kString =\n"

" @\"aaaa\"\n"

" @\"bbbb\";",

format("NSString *const kString = @\"aaaa\"\n"

"NSString *const kString = @\"aaaa\"\n"

"@\"bbbb\";",

Break));

Break);

Break.ColumnLimit = 0;

verifyFormat("const char *hello = \"hello llvm\";", Break);

}

TEST_F(FormatTest, AlignsPipes) {

verifyFormat(

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"

▲ Show 20 Lines • Show All 55 Lines • ▼ Show 20 Lines

verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"

" << aaa;");

verifyFormat(

"llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"

" .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");

// Incomplete string literal.

EXPECT_EQ("llvm::errs() << \"\n"

verifyFormat("llvm::errs() << \"\n"

" << a;",

format("llvm::errs() << \"\n<<a;"));

"llvm::errs() << \"\n<<a;");

verifyFormat("void f() {\n"

" CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"

" << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"

"}");

// Handle 'endl'.

verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"

▲ Show 20 Lines • Show All 231 Lines • ▼ Show 20 Lines

verifyFormat(

"aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"

" new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"

" bbbbbbbbbbbbbbbbbbbbbbbb);",

getLLVMStyleWithColumns(72));

EXPECT_EQ("static_cast<A< //\n"

verifyFormat("static_cast<A< //\n"

" B> *>(\n"

"\n"

");",

format("static_cast<A<//\n"

"static_cast<A<//\n"

" B>*>(\n"

"\n"

" );"));

" );");

verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"

" const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");

FormatStyle AlwaysBreak = getLLVMStyle();

AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;

verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);

verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);

verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);

▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, WrapsTemplateDeclarations) {

verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "

"bbbbbbbbbbbbbbbbbbbb) {}",

NeverBreak);

}

TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {

FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);

Style.ColumnLimit = 60;

EXPECT_EQ("// Baseline - no comments.\n"

verifyFormat("// Baseline - no comments.\n"

"template <\n"

" typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"

"void f() {}",

format("// Baseline - no comments.\n"

Style);

"template <\n"

" typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"

"void f() {}",

Style));

EXPECT_EQ("template <\n"

verifyFormat("template <\n"

" typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"

"void f() {}",

format("template <\n"

"template <\n"

" typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"

"void f() {}",

Style));

Style);

EXPECT_EQ(

verifyFormat(

"template <\n"

" typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"

"void f() {}",

format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"

"template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"

"void f() {}",

Style));

Style);

EXPECT_EQ(

verifyFormat("template <\n"

"template <\n"

" typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"

" // multiline\n"

"void f() {}",

format("template <\n"

"template <\n"

" typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"

" // multiline\n"

"void f() {}",

Style));

Style);

EXPECT_EQ(

verifyFormat(

"template <typename aaaaaaaaaa<\n"

" bbbbbbbbbbbb>::value> // trailing loooong\n"

"void f() {}",

format(

"template <\n"

" typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"

"void f() {}",

Style));

Style);

}

TEST_F(FormatTest, WrapsTemplateParameters) {

FormatStyle Style = getLLVMStyle();

Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;

Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;

verifyFormat(

"template <typename... a> struct q {};\n"

▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, UnderstandsTemplateParameters) {

verifyGoogleFormat("A<A<A<A<int>>>> a;");

verifyGoogleFormat("A<A<int> > a;");

verifyGoogleFormat("A<A<A<int> > > a;");

verifyGoogleFormat("A<A<A<A<int> > > > a;");

verifyGoogleFormat("A<::A<int>> a;");

verifyGoogleFormat("A<::A> a;");

verifyGoogleFormat("A< ::A> a;");

verifyGoogleFormat("A< ::A<int> > a;");

EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));

verifyFormat("A<A<A<A>>> a;", "A<A<A<A> >> a;", getGoogleStyle());

EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));

verifyFormat("A<A<A<A>>> a;", "A<A<A<A>> > a;", getGoogleStyle());

EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));

verifyFormat("A<::A<int>> a;", "A< ::A<int>> a;", getGoogleStyle());

EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));

verifyFormat("A<::A<int>> a;", "A<::A<int> > a;", getGoogleStyle());

EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",

verifyFormat("auto x = [] { A<A<A<A>>> a; };", "auto x=[]{A<A<A<A> >> a;};",

format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));

getGoogleStyle());

verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));

// template closer followed by a token that starts with > or =

verifyFormat("bool b = a<1> > 1;");

verifyFormat("bool b = a<1> >= 1;");

verifyFormat("int i = a<1> >> 1;");

FormatStyle Style = getLLVMStyle();

▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, UnderstandsShiftOperators) {

verifyFormat("Foo.call<Bar<Function>>()");

verifyFormat("if (Foo.call<Bar<Function>>() == 0)");

verifyFormat("for (std::vector<std::pair<int>>::iterator i = 0; i < x >> 1; "

"++i, v = v >> 1)");

verifyFormat("if (w<u<v<x>>, 1>::t)");

}

TEST_F(FormatTest, BitshiftOperatorWidth) {

EXPECT_EQ("int a = 1 << 2; /* foo\n"

verifyFormat("int a = 1 << 2; /* foo\n"

" bar */",

format("int a=1<<2; /* foo\n"

"int a=1<<2; /* foo\n"

" bar */"));

" bar */");

EXPECT_EQ("int b = 256 >> 1; /* foo\n"

verifyFormat("int b = 256 >> 1; /* foo\n"

" bar */",

format("int b =256>>1 ; /* foo\n"

"int b =256>>1 ; /* foo\n"

" bar */"));

" bar */");

}

TEST_F(FormatTest, UnderstandsBinaryOperators) {

verifyFormat("COMPARE(a, ==, b);");

verifyFormat("auto s = sizeof...(Ts) - 1;");

}

TEST_F(FormatTest, UnderstandsPointersToMembers) {

▲ Show 20 Lines • Show All 432 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, UnderstandsNewAndDelete) {

verifyFormat("delete[] h->p;");

verifyFormat("delete[] (void *)p;");

verifyFormat("void operator delete(void *foo) ATTRIB;");

verifyFormat("void operator new(void *foo) ATTRIB;");

verifyFormat("void operator delete[](void *foo) ATTRIB;");

verifyFormat("void operator delete(void *ptr) noexcept;");

EXPECT_EQ("void new(link p);\n"

verifyFormat("void new(link p);\n"

"void delete(link p);",

format("void new (link p);\n"

"void new (link p);\n"

"void delete (link p);"));

"void delete (link p);");

}

TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {

verifyFormat("int *f(int *a) {}");

verifyFormat("int main(int argc, char **argv) {}");

verifyFormat("Test::Test(int b) : a(b * b) {}");

verifyIndependentOfContext("f(a, *a);");

verifyFormat("void g() { f(*a); }");

▲ Show 20 Lines • Show All 371 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {

verifyFormat("auto x = [](const decltype(x) &ptr) {};");

verifyFormat("auto x = [](const decltype(x) *ptr) {};");

verifyFormat("#define lambda [](const decltype(x) &ptr) {}");

verifyFormat("#define lambda [](const decltype(x) *ptr) {}");

verifyFormat("DatumHandle const *operator->() const { return input_; }");

verifyFormat("return options != nullptr && operator==(*options);");

EXPECT_EQ("#define OP(x) \\\n"

verifyFormat("#define OP(x) \\\n"

" ostream &operator<<(ostream &s, const A &a) { \\\n"

" return s << a.DebugString(); \\\n"

" }",

format("#define OP(x) \\\n"

"#define OP(x) \\\n"

" ostream &operator<<(ostream &s, const A &a) { \\\n"

" return s << a.DebugString(); \\\n"

" }",

getLLVMStyleWithColumns(50)));

getLLVMStyleWithColumns(50));

verifyFormat("#define FOO \\\n"

" void foo() { \\\n"

" operator+(a * b); \\\n"

" }",

getLLVMStyleWithColumns(25));

// FIXME: We cannot handle this case yet; we might be able to figure out that

▲ Show 20 Lines • Show All 210 Lines • ▼ Show 20 Lines

verifyFormat("MACRO;\n"

" //...\n"

"}");

verifyFormat("MACRO;\n"

"[[nodiscard]] int foo() {\n"

" //...\n"

"}");

EXPECT_EQ("MACRO\n\n"

verifyNoChange("MACRO\n\n"

"__attribute__((maybe_unused)) int foo() {\n"

" //...\n"

"}",

format("MACRO\n\n"

"__attribute__((maybe_unused)) int foo() {\n"

" //...\n"

"}"));

"}");

EXPECT_EQ("MACRO\n\n"

verifyNoChange("MACRO\n\n"

"[[nodiscard]] int foo() {\n"

" //...\n"

"}",

format("MACRO\n\n"

"[[nodiscard]] int foo() {\n"

" //...\n"

"}"));

"}");

}

TEST_F(FormatTest, AttributePenaltyBreaking) {

FormatStyle Style = getLLVMStyle();

verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"

" [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",

Style);

verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"

Show All 17 Lines

TEST_F(FormatTest, UnderstandsEllipsis) {

verifyFormat("template <int*... PP> a;", Style);

Style.PointerAlignment = FormatStyle::PAS_Middle;

verifyFormat("template <int *... PP> a;", Style);

}

TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {

EXPECT_EQ("int *a;\n"

verifyFormat("int *a;\n"

"int *a;\n"

"int *a;",

format("int *a;\n"

"int *a;\n"

"int* a;\n"

"int *a;",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("int* a;\n"

verifyFormat("int* a;\n"

"int* a;\n"

"int* a;",

format("int* a;\n"

"int* a;\n"

"int *a;",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("int *a;\n"

verifyFormat("int *a;\n"

"int *a;\n"

"int *a;",

format("int *a;\n"

"int *a;\n"

"int * a;\n"

"int * a;",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("auto x = [] {\n"

verifyFormat("auto x = [] {\n"

" int *a;\n"

"};",

format("auto x=[]{int *a;\n"

"auto x=[]{int *a;\n"

"int * a;\n"

"int * a;};",

getGoogleStyle()));

getGoogleStyle());

}

TEST_F(FormatTest, UnderstandsRvalueReferences) {

verifyFormat("int f(int &&a) {}");

verifyFormat("int f(int a, char &&b) {}");

verifyFormat("void f() { int &&a = b; }");

verifyGoogleFormat("int f(int a, char&& b) {}");

verifyGoogleFormat("void f() { int&& a = b; }");

▲ Show 20 Lines • Show All 502 Lines • ▼ Show 20 Lines

verifyFormat("struct foo {\n"

" int i;\n"

"#ifdef FOO\n"

"private:\n"

"#endif\n"

" int j;\n"

"};",

Style);

Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"\n"

"private:\n"

" void f() {}\n"

"\n"

"private:\n"

" int i;\n"

"\n"

"protected:\n"

" int j;\n"

"};",

format("struct foo {\n"

"\n"

"private:\n"

" void f() {}\n"

"\n"

"private:\n"

" int i;\n"

"\n"

"protected:\n"

" int j;\n"

"};",

Style));

Style);

verifyFormat("struct foo {\n"

"private:\n"

" void f() {}\n"

"private:\n"

" int i;\n"

"protected:\n"

" int j;\n"

"};",

Style);

EXPECT_EQ("struct foo { /* comment */\n"

verifyNoChange("struct foo { /* comment */\n"

"\n"

"private:\n"

" int i;\n"

" // comment\n"

"\n"

"private:\n"

" int j;\n"

"};",

format("struct foo { /* comment */\n"

Style);

"\n"

"private:\n"

" int i;\n"

" // comment\n"

"\n"

"private:\n"

" int j;\n"

"};",

Style));

verifyFormat("struct foo { /* comment */\n"

"private:\n"

" int i;\n"

" // comment\n"

"private:\n"

" int j;\n"

"};",

Style);

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"#ifdef FOO\n"

"#endif\n"

"\n"

"private:\n"

" int i;\n"

"#ifdef FOO\n"

"\n"

"private:\n"

"#endif\n"

" int j;\n"

"};",

format("struct foo {\n"

"#ifdef FOO\n"

"#endif\n"

"\n"

"private:\n"

" int i;\n"

"#ifdef FOO\n"

"\n"

"private:\n"

"#endif\n"

" int j;\n"

"};",

Style));

Style);

verifyFormat("struct foo {\n"

"#ifdef FOO\n"

"#endif\n"

"private:\n"

" int i;\n"

"#ifdef FOO\n"

"private:\n"

"#endif\n"

▲ Show 20 Lines • Show All 139 Lines • ▼ Show 20 Lines

verifyFormat("struct foo {\n"

" int i;\n"

"\n"

"protected:\n"

" int j;\n"

"};",

Style);

// Check if MaxEmptyLinesToKeep is respected.

EXPECT_EQ("struct foo {\n"

verifyFormat("struct foo {\n"

"private:\n"

" void f() {}\n"

"\n"

"private:\n"

" int i;\n"

"\n"

"protected:\n"

" int j;\n"

"};",

format("struct foo {\n"

"struct foo {\n"

"private:\n"

"\n\n\n"

" void f() {}\n"

"\n"

"private:\n"

"\n\n\n"

" int i;\n"

"\n"

"protected:\n"

"\n\n\n"

" int j;\n"

"};",

Style));

Style);

Style.MaxEmptyLinesToKeep = 1u;

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"private:\n"

"\n"

" void f() {}\n"

"\n"

"private:\n"

"\n"

" int i;\n"

"\n"

"protected:\n"

"\n"

" int j;\n"

"};",

format("struct foo {\n"

"private:\n"

"\n"

" void f() {}\n"

"\n"

"private:\n"

"\n"

" int i;\n"

"\n"

"protected:\n"

"\n"

" int j;\n"

"};",

Style));

Style);

// Check if no lines are kept.

EXPECT_EQ("struct foo {\n"

verifyFormat("struct foo {\n"

"private:\n"

" void f() {}\n"

"\n"

"private:\n"

" int i;\n"

"\n"

"protected:\n"

" int j;\n"

"};",

format("struct foo {\n"

"private:\n"

" void f() {}\n"

"\n"

"private:\n"

" int i;\n"

"\n"

"protected:\n"

" int j;\n"

"};",

Style));

Style);

// Check if MaxEmptyLinesToKeep is respected.

EXPECT_EQ("struct foo {\n"

verifyFormat("struct foo {\n"

"private:\n"

"\n"

" void f() {}\n"

"\n"

"private:\n"

"\n"

" int i;\n"

"\n"

"protected:\n"

"\n"

" int j;\n"

"};",

format("struct foo {\n"

"struct foo {\n"

"private:\n"

"\n\n\n"

" void f() {}\n"

"\n"

"private:\n"

"\n\n\n"

" int i;\n"

"\n"

"protected:\n"

"\n\n\n"

" int j;\n"

"};",

Style));

Style);

Style.MaxEmptyLinesToKeep = 10u;

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"private:\n"

"\n\n\n"

" void f() {}\n"

"\n"

"private:\n"

"\n\n\n"

" int i;\n"

"\n"

"protected:\n"

"\n\n\n"

" int j;\n"

"};",

format("struct foo {\n"

"private:\n"

"\n\n\n"

" void f() {}\n"

"\n"

"private:\n"

"\n\n\n"

" int i;\n"

"\n"

"protected:\n"

"\n\n\n"

" int j;\n"

"};",

Style));

Style);

// Test with comments.

Style = getLLVMStyle();

verifyFormat("struct foo {\n"

"private:\n"

" // comment\n"

" void f() {}\n"

"\n"

▲ Show 20 Lines • Show All 187 Lines • ▼ Show 20 Lines

verifyFormat("struct foo {\n"

"protected:\n"

"};",

Style);

// Leave tests rely on the code layout, test::messUp can not be used.

Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;

Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;

Style.MaxEmptyLinesToKeep = 10u;

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

format("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

Style));

Style);

Style.MaxEmptyLinesToKeep = 3u;

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

format("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

Style));

Style);

Style.MaxEmptyLinesToKeep = 1u;

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

format("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

Style)); // Based on new lines in original document and not

Style); // Based on new lines in original document and not

// on the setting.

Style.MaxEmptyLinesToKeep = 10u;

Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;

Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;

// Newlines are kept if they are greater than zero,

// test::messUp removes all new lines which changes the logic

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

format("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

Style));

Style);

Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;

Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;

// test::messUp removes all new lines which changes the logic

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

format("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

Style));

Style);

Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;

Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

format("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

Style)); // test::messUp removes all new lines which changes

Style); // test::messUp removes all new lines which changes

// the logic.

Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;

Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;

verifyFormat("struct foo {\n"

"private:\n"

"protected:\n"

"};",

"struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

Style);

Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;

Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;

EXPECT_EQ("struct foo {\n"

verifyNoChange("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

format("struct foo {\n"

"private:\n"

"\n\n\n"

"protected:\n"

"};",

Style)); // test::messUp removes all new lines which changes

Style); // test::messUp removes all new lines which changes

// the logic.

Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;

Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;

verifyFormat("struct foo {\n"

"private:\n"

"protected:\n"

"};",

"struct foo {\n"

▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines

verifyFormat("#include <string>\n"

"#include <a-a>\n"

"#include < path with space >\n"

"#include_next <test.h>"

"#include \"abc.h\" // this is included for ABC\n"

"#include \"some long include\" // with a comment\n"

"#include \"some very long include path\"\n"

"#include <some/very/long/include/path>",

getLLVMStyleWithColumns(35));

EXPECT_EQ("#include \"a.h\"", format("#include \"a.h\""));

verifyFormat("#include \"a.h\"", "#include \"a.h\"");

EXPECT_EQ("#include <a>", format("#include<a>"));

verifyFormat("#include <a>", "#include<a>");

verifyFormat("#import <string>");

verifyFormat("#import <a/b/c.h>");

verifyFormat("#import \"a/b/string\"");

verifyFormat("#import \"string.h\"");

verifyFormat("#if __has_include(<strstream>)\n"

"#include <strstream>\n"

▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, IncorrectCodeTrailingStuff) {

verifyFormat("void f() {\n"

" if (0)\n"

" return\n"

"}\n"

"42");

}

TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {

EXPECT_EQ("void f() { return }", format("void f ( ) { return }"));

verifyFormat("void f() { return }", "void f ( ) { return }");

EXPECT_EQ("void f() {\n"

verifyFormat("void f() {\n"

" if (a)\n"

" return\n"

"}",

format("void f ( ) { if ( a ) return }"));

"void f ( ) { if ( a ) return }");

EXPECT_EQ("namespace N {\n"

verifyFormat("namespace N {\n"

"void f()\n"

"}",

format("namespace N { void f() }"));

"namespace N { void f() }");

EXPECT_EQ("namespace N {\n"

verifyFormat("namespace N {\n"

"void f() {}\n"

"void g()\n"

"} // namespace N",

format("namespace N { void f( ) { } void g( ) }"));

"namespace N { void f( ) { } void g( ) }");

}

TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {

verifyFormat("int aaaaaaaa =\n"

" // Overlylongcomment\n"

" b;",

getLLVMStyleWithColumns(20));

verifyFormat("function(\n"

▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {

verifyIncompleteFormat("namespace {\n"

"class Foo { Foo (\n"

"};\n"

"} // namespace");

}

TEST_F(FormatTest, IncorrectCodeErrorDetection) {

EXPECT_EQ("{\n {}", format("{\n{\n}"));

verifyFormat("{\n {}", "{\n{\n}");

EXPECT_EQ("{\n {}", format("{\n {\n}"));

verifyFormat("{\n {}", "{\n {\n}");

EXPECT_EQ("{\n {}", format("{\n {\n }"));

verifyFormat("{\n {}", "{\n {\n }");

EXPECT_EQ("{\n {}\n}\n}", format("{\n {\n }\n }\n}"));

verifyFormat("{\n {}\n}\n}", "{\n {\n }\n }\n}");

EXPECT_EQ("{\n"

verifyFormat("{\n"

" {\n"

" breakme(\n"

" qwe);\n"

" }",

format("{\n"

"{\n"

" {\n"

" breakme(qwe);\n"

"}",

getLLVMStyleWithColumns(10)));

getLLVMStyleWithColumns(10));

}

TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {

verifyFormat("int x = {\n"

" avariable,\n"

" b(alongervariable)};",

getLLVMStyleWithColumns(25));

}

▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines

verifyFormat(

"const Aaaaaa aaaaa = {\n"

" aaaaa, bbbbb, ccccc, ddddd, eeeee, ffffff, ggggg, hhhhhh,\n"

" iiiiii, jjjjjj, kkkkkk, aaaaa, bbbbb, ccccc, ddddd, eeeee,\n"

" ffffff, ggggg, hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"

"};",

NoBinPacking);

NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;

EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"

verifyFormat("static uint8 CddDp83848Reg[] = {\n"

" CDDDP83848_BMCR_REGISTER,\n"

" CDDDP83848_BMSR_REGISTER,\n"

" CDDDP83848_RBR_REGISTER};",

format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"

"static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"

" CDDDP83848_BMSR_REGISTER,\n"

" CDDDP83848_RBR_REGISTER};",

NoBinPacking));

NoBinPacking);

// FIXME: The alignment of these trailing comments might be bad. Then again,

// this might be utterly useless in real code.

verifyFormat("Constructor::Constructor()\n"

" : some_value{ //\n"

" aaaaaaa, //\n"

" bbbbbbb} {}");

// In braced lists, the first comment is always assumed to belong to the

// first element. Thus, it can be moved to the next or previous line as

// appropriate.

EXPECT_EQ("function({// First element:\n"

verifyFormat("function({// First element:\n"

" 1,\n"

" // Second element:\n"

" 2});",

format("function({\n"

"function({\n"

" // First element:\n"

" 1,\n"

" // Second element:\n"

" 2});"));

" 2});");

EXPECT_EQ("std::vector<int> MyNumbers{\n"

verifyFormat("std::vector<int> MyNumbers{\n"

" // First element:\n"

" 1,\n"

" // Second element:\n"

" 2};",

format("std::vector<int> MyNumbers{// First element:\n"

"std::vector<int> MyNumbers{// First element:\n"

" 1,\n"

" // Second element:\n"

" 2};",

getLLVMStyleWithColumns(30)));

getLLVMStyleWithColumns(30));

// A trailing comma should still lead to an enforced line break and no

// binpacking.

EXPECT_EQ("vector<int> SomeVector = {\n"

verifyFormat("vector<int> SomeVector = {\n"

" // aaa\n"

" 1,\n"

" 2,\n"

"};",

format("vector<int> SomeVector = { // aaa\n"

"vector<int> SomeVector = { // aaa\n"

" 1, 2, };"));

" 1, 2, };");

// C++11 brace initializer list l-braces should not be treated any differently

// when breaking before lambda bodies is enabled

FormatStyle BreakBeforeLambdaBody = getLLVMStyle();

BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;

BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;

BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;

verifyFormat(

▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, LayoutCxx11BraceInitializers) {

SpaceBetweenBraces.SpacesInParensOptions.Other = true;

SpaceBetweenBraces.SpacesInSquareBrackets = true;

verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);

verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);

verifyFormat("vector< int > x{ // comment 1\n"

" 1, 2, 3, 4 };",

SpaceBetweenBraces);

SpaceBetweenBraces.ColumnLimit = 20;

EXPECT_EQ("vector< int > x{\n"

verifyFormat("vector< int > x{\n"

" 1, 2, 3, 4 };",

format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));

"vector<int>x{1,2,3,4};", SpaceBetweenBraces);

SpaceBetweenBraces.ColumnLimit = 24;

EXPECT_EQ("vector< int > x{ 1, 2,\n"

verifyFormat("vector< int > x{ 1, 2,\n"

" 3, 4 };",

format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));

"vector<int>x{1,2,3,4};", SpaceBetweenBraces);

EXPECT_EQ("vector< int > x{\n"

verifyFormat("vector< int > x{\n"

" 1,\n"

" 2,\n"

" 3,\n"

" 4,\n"

"};",

format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));

"vector<int>x{1,2,3,4,};", SpaceBetweenBraces);

verifyFormat("vector< int > x{};", SpaceBetweenBraces);

SpaceBetweenBraces.SpacesInParens = FormatStyle::SIPO_Custom;

SpaceBetweenBraces.SpacesInParensOptions.InEmptyParentheses = true;

verifyFormat("vector< int > x{ };", SpaceBetweenBraces);

}

TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {

verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"

▲ Show 20 Lines • Show All 212 Lines • ▼ Show 20 Lines

verifyGoogleFormat("class C {\n"

" C()\n"

" : iiiiiiii(nullptr),\n"

" kkkkkkk(nullptr),\n"

" mmmmmmm(nullptr),\n"

" nnnnnnn(nullptr) {}\n"

"};");

FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);

EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));

verifyFormat("A() : b(0) {}", "A():b(0){}", NoColumnLimit);

EXPECT_EQ("class C {\n"

verifyFormat("class C {\n"

" A() : b(0) {}\n"

"};",

format("class C{A():b(0){}};", NoColumnLimit));

"class C{A():b(0){}};", NoColumnLimit);

EXPECT_EQ("A()\n"

verifyFormat("A()\n"

" : b(0) {\n"

"}",

format("A()\n:b(0)\n{\n}", NoColumnLimit));

"A()\n:b(0)\n{\n}", NoColumnLimit);

FormatStyle NoColumnLimitWrapAfterFunction = NoColumnLimit;

NoColumnLimitWrapAfterFunction.BreakBeforeBraces = FormatStyle::BS_Custom;

NoColumnLimitWrapAfterFunction.BraceWrapping.AfterFunction = true;

verifyFormat("class C {\n"

"#pragma foo\n"

" int foo { return 0; }\n"

"};",

NoColumnLimitWrapAfterFunction);

verifyFormat("class C {\n"

"#pragma foo\n"

" void foo {}\n"

"};",

NoColumnLimitWrapAfterFunction);

FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;

DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =

FormatStyle::SFS_None;

EXPECT_EQ("A()\n"

verifyFormat("A()\n"

" : b(0) {\n"

"}",

format("A():b(0){}", DoNotMergeNoColumnLimit));

"A():b(0){}", DoNotMergeNoColumnLimit);

EXPECT_EQ("A()\n"

verifyFormat("A()\n"

" : b(0) {\n"

"}",

format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));

"A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit);

verifyFormat("#define A \\\n"

" void f() { \\\n"

" int i; \\\n"

" }",

getLLVMStyleWithColumns(20));

verifyFormat("#define A \\\n"

" void f() { int i; }",

▲ Show 20 Lines • Show All 612 Lines • ▼ Show 20 Lines

verifyFormat("if (true)\n"

" f();");

// This is simply incomplete. Formatting is not important, but must not crash.

verifyFormat("class A:");

}

TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {

verifyNoChange("#error Leave all white!!!!! space* alone!");

EXPECT_EQ("#warning Leave all white!!!!! space* alone!",

verifyNoChange("#warning Leave all white!!!!! space* alone!");

format("#warning Leave all white!!!!! space* alone!"));

verifyFormat("#error 1", " # error 1");

EXPECT_EQ("#error 1", format(" # error 1"));

verifyFormat("#warning 1", " # warning 1");

EXPECT_EQ("#warning 1", format(" # warning 1"));

}

TEST_F(FormatTest, FormatHashIfExpressions) {

verifyFormat("#if AAAA && BBBB");

verifyFormat("#if (AAAA && BBBB)");

verifyFormat("#elif (AAAA && BBBB)");

// FIXME: Come up with a better indentation for #elif.

verifyFormat(

"#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) && \\\n"

" defined(BBBBBBBB)\n"

"#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) && \\\n"

" defined(BBBBBBBB)\n"

"#endif",

getLLVMStyleWithColumns(65));

}

TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {

FormatStyle AllowsMergedIf = getGoogleStyle();

AllowsMergedIf.AllowShortIfStatementsOnASingleLine =

FormatStyle::SIS_WithoutElse;

verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);

verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);

verifyFormat("if (true)\n#error E\n return 42;", AllowsMergedIf);

EXPECT_EQ("if (true) return 42;",

verifyFormat("if (true) return 42;", "if (true)\nreturn 42;", AllowsMergedIf);

format("if (true)\nreturn 42;", AllowsMergedIf));

FormatStyle ShortMergedIf = AllowsMergedIf;

ShortMergedIf.ColumnLimit = 25;

verifyFormat("#define A \\\n"

" if (true) return 42;",

ShortMergedIf);

verifyFormat("#define A \\\n"

" f(); \\\n"

" if (true)\n"

▲ Show 20 Lines • Show All 94 Lines • ▼ Show 20 Lines

}

//===----------------------------------------------------------------------===//

// Objective-C tests.

//===----------------------------------------------------------------------===//

TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {

verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");

EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",

verifyFormat("- (NSUInteger)indexOfObject:(id)anObject;",

format("-(NSUInteger)indexOfObject:(id)anObject;"));

"-(NSUInteger)indexOfObject:(id)anObject;");

EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));

verifyFormat("- (NSInteger)Mthod1;", "-(NSInteger)Mthod1;");

EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));

verifyFormat("+ (id)Mthod2;", "+(id)Mthod2;");

EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",

verifyFormat("- (NSInteger)Method3:(id)anObject;",

format("-(NSInteger)Method3:(id)anObject;"));

"-(NSInteger)Method3:(id)anObject;");

EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",

verifyFormat("- (NSInteger)Method4:(id)anObject;",

format("-(NSInteger)Method4:(id)anObject;"));

"-(NSInteger)Method4:(id)anObject;");

EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",

verifyFormat("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",

format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));

"-(NSInteger)Method5:(id)anObject:(id)AnotherObject;");

verifyFormat("- (id)Method6:(id)A:(id)B:(id)C:(id)D;");

EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "

verifyFormat("- (void)sendAction:(SEL)aSelector to:(id)anObject "

"forAllCells:(BOOL)flag;",

"forAllCells:(BOOL)flag;");

format("- (void)sendAction:(SEL)aSelector to:(id)anObject "

"forAllCells:(BOOL)flag;"));

// Very long objectiveC method declaration.

verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"

" (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");

verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"

" inRange:(NSRange)range\n"

" outRange:(NSRange)out_range\n"

" outRange1:(NSRange)out_range1\n"

Show All 35 Lines

TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {

// If there's no return type (very rare in practice!), LLVM and Google style

// agree.

verifyFormat("- foo;");

verifyFormat("- foo:(int)f;");

verifyGoogleFormat("- foo:(int)foo;");

}

TEST_F(FormatTest, BreaksStringLiterals) {

// FIXME: unstable test case

EXPECT_EQ("\"some text \"\n"

"\"other\";",

format("\"some text other\";", getLLVMStyleWithColumns(12)));

// FIXME: unstable test case

EXPECT_EQ("\"some text \"\n"

"\"other\";",

format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));

EXPECT_EQ(

verifyFormat("#define A \\\n"

"#define A \\\n"

" \"some \" \\\n"

" \"text \" \\\n"

" \"other\";",

format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));

"#define A \"some text other\";", getLLVMStyleWithColumns(12));

EXPECT_EQ(

verifyFormat("#define A \\\n"

"#define A \\\n"

" \"so \" \\\n"

" \"text \" \\\n"

" \"other\";",

format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));

"#define A \"so text other\";", getLLVMStyleWithColumns(12));

verifyFormat("\"some text\"", getLLVMStyleWithColumns(1));

verifyFormat("\"some text\"", getLLVMStyleWithColumns(11));

// FIXME: unstable test case

EXPECT_EQ("\"some \"\n"

"\"text\"",

format("\"some text\"", getLLVMStyleWithColumns(10)));

// FIXME: unstable test case

EXPECT_EQ("\"some \"\n"

"\"text\"",

format("\"some text\"", getLLVMStyleWithColumns(7)));

// FIXME: unstable test case

EXPECT_EQ("\"some\"\n"

"\" tex\"\n"

"\"t\"",

format("\"some text\"", getLLVMStyleWithColumns(6)));

// FIXME: unstable test case

EXPECT_EQ("\"some\"\n"

"\" tex\"\n"

"\" and\"",

format("\"some tex and\"", getLLVMStyleWithColumns(6)));

// FIXME: unstable test case

EXPECT_EQ("\"some\"\n"

"\"/tex\"\n"

"\"/and\"",

format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));

EXPECT_EQ("variable =\n"

verifyFormat("variable =\n"

" \"long string \"\n"

" \"literal\";",

format("variable = \"long string literal\";",

"variable = \"long string literal\";",

getLLVMStyleWithColumns(20)));

getLLVMStyleWithColumns(20));

EXPECT_EQ("variable = f(\n"

verifyFormat("variable = f(\n"

" \"long string \"\n"

" \"literal\",\n"

" short,\n"

" loooooooooooooooooooong);",

format("variable = f(\"long string literal\", short, "

"variable = f(\"long string literal\", short, "

"loooooooooooooooooooong);",

getLLVMStyleWithColumns(20)));

getLLVMStyleWithColumns(20));

EXPECT_EQ(

verifyFormat("f(g(\"long string \"\n"

"f(g(\"long string \"\n"

" \"literal\"),\n"

" b);",

format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));

"f(g(\"long string literal\"), b);",

EXPECT_EQ("f(g(\"long string \"\n"

getLLVMStyleWithColumns(20));

verifyFormat("f(g(\"long string \"\n"

" \"literal\",\n"

" a),\n"

" b);",

format("f(g(\"long string literal\", a), b);",

"f(g(\"long string literal\", a), b);",

getLLVMStyleWithColumns(20)));

getLLVMStyleWithColumns(20));

EXPECT_EQ(

verifyFormat("f(\"one two\".split(\n"

"f(\"one two\".split(\n"

" variable));",

format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));

"f(\"one two\".split(variable));", getLLVMStyleWithColumns(20));

EXPECT_EQ("f(\"one two three four five six \"\n"

verifyFormat("f(\"one two three four five six \"\n"

" \"seven\".split(\n"

" really_looooong_variable));",

format("f(\"one two three four five six seven\"."

"f(\"one two three four five six seven\"."

"split(really_looooong_variable));",

getLLVMStyleWithColumns(33)));

getLLVMStyleWithColumns(33));

EXPECT_EQ("f(\"some \"\n"

verifyFormat("f(\"some \"\n"

" \"text\",\n"

" other);",

format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));

"f(\"some text\", other);", getLLVMStyleWithColumns(10));

// Only break as a last resort.

verifyFormat(

"aaaaaaaaaaaaaaaaaaaa(\n"

" aaaaaaaaaaaaaaaaaaaa,\n"

" aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");

// FIXME: unstable test case

EXPECT_EQ("\"splitmea\"\n"

"\"trandomp\"\n"

"\"oint\"",

format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));

// FIXME: unstable test case

EXPECT_EQ("\"split/\"\n"

"\"pathat/\"\n"

"\"slashes\"",

format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));

// FIXME: unstable test case

EXPECT_EQ("\"split/\"\n"

"\"pathat/\"\n"

"\"slashes\"",

format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));

// FIXME: unstable test case

EXPECT_EQ("\"split at \"\n"

"\"spaces/at/\"\n"

"\"slashes.at.any$\"\n"

"\"non-alphanumeric%\"\n"

"\"1111111111characte\"\n"

"\"rs\"",

format("\"split at "

"spaces/at/"

"slashes.at."

"any$non-"

"alphanumeric%"

"1111111111characte"

"rs\"",

getLLVMStyleWithColumns(20)));

// Verify that splitting the strings understands

// Style::AlwaysBreakBeforeMultilineStrings.

EXPECT_EQ("aaaaaaaaaaaa(\n"

verifyFormat("aaaaaaaaaaaa(\n"

" \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"

" \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",

format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "

"aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "

"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "

"aaaaaaaaaaaaaaaaaaaaaa\");",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"

verifyFormat("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"

" \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",

format("return \"aaaaaaaaaaaaaaaaaaaaaa "

"return \"aaaaaaaaaaaaaaaaaaaaaa "

"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "

"aaaaaaaaaaaaaaaaaaaaaa\";",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"

verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"

" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",

format("llvm::outs() << "

"llvm::outs() << "

"\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"

"aaaaaaaaaaaaaaaaaaa\";"));

"aaaaaaaaaaaaaaaaaaa\";");

EXPECT_EQ("ffff(\n"

verifyFormat("ffff(\n"

" {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"

" \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",

format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "

"ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",

getGoogleStyle()));

getGoogleStyle());

FormatStyle Style = getLLVMStyleWithColumns(12);

Style.BreakStringLiterals = false;

verifyFormat("\"some text other\";", Style);

FormatStyle AlignLeft = getLLVMStyleWithColumns(12);

AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;

EXPECT_EQ("#define A \\\n"

verifyFormat("#define A \\\n"

" \"some \" \\\n"

" \"text \" \\\n"

" \"other\";",

format("#define A \"some text other\";", AlignLeft));

"#define A \"some text other\";", AlignLeft);

}

TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {

EXPECT_EQ("C a = \"some more \"\n"

verifyFormat("C a = \"some more \"\n"

" \"text\";",

format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));

"C a = \"some more text\";", getLLVMStyleWithColumns(18));

}

TEST_F(FormatTest, FullyRemoveEmptyLines) {

FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);

NoEmptyLines.MaxEmptyLinesToKeep = 0;

EXPECT_EQ("int i = a(b());",

verifyFormat("int i = a(b());", "int i=a(\n\n b(\n\n\n )\n\n);",

format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));

NoEmptyLines);

}

TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {

// FIXME: unstable test case

EXPECT_EQ(

"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

"(\n"

" \"x\t\");",

format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

"aaaaaaa("

"\"x\t\");"));

}

TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {

// FIXME: unstable test case

EXPECT_EQ(

"u8\"utf8 string \"\n"

"u8\"literal\";",

format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));

// FIXME: unstable test case

EXPECT_EQ(

"u\"utf16 string \"\n"

"u\"literal\";",

format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));

// FIXME: unstable test case

EXPECT_EQ(

"U\"utf32 string \"\n"

"U\"literal\";",

format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));

// FIXME: unstable test case

EXPECT_EQ("L\"wide string \"\n"

"L\"literal\";",

format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));

EXPECT_EQ("@\"NSString \"\n"

verifyFormat("@\"NSString \"\n"

"@\"literal\";",

format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));

"@\"NSString literal\";", getGoogleStyleWithColumns(19));

verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));

// This input makes clang-format try to split the incomplete unicode escape

// sequence, which used to lead to a crasher.

verifyNoCrash(

"aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",

getLLVMStyleWithColumns(60));

}

TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {

FormatStyle Style = getGoogleStyleWithColumns(15);

verifyFormat("R\"x(raw literal)x\";", Style);

verifyFormat("uR\"x(raw literal)x\";", Style);

verifyFormat("LR\"x(raw literal)x\";", Style);

verifyFormat("UR\"x(raw literal)x\";", Style);

verifyFormat("u8R\"x(raw literal)x\";", Style);

}

TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {

FormatStyle Style = getLLVMStyleWithColumns(20);

// FIXME: unstable test case

EXPECT_EQ(

"_T(\"aaaaaaaaaaaaaa\")\n"

"_T(\"aaaaaaaaaaaa\")",

format(" _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));

EXPECT_EQ("f(x,\n"

verifyFormat("f(x,\n"

" _T(\"aaaaaaaaaaaa\")\n"

" _T(\"aaa\"),\n"

" z);",

format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));

"f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style);

// FIXME: Handle embedded spaces in one iteration.

// EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"

// "_T(\"aaaaaaaaaaaaa\")\n"

// "_T(\"a\")",

// format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",

// getLLVMStyleWithColumns(20)));

EXPECT_EQ(

verifyFormat("_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",

"_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",

" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style);

format(" _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));

verifyFormat("f(\n"

EXPECT_EQ("f(\n"

"#if !TEST\n"

" _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"

"#endif\n"

");",

format("f(\n"

"f(\n"

"#if !TEST\n"

"_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"

"#endif\n"

");"));

");");

EXPECT_EQ("f(\n"

verifyFormat("f(\n"

"\n"

" _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",

format("f(\n"

"f(\n"

"\n"

"_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));

"_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));");

// Regression test for accessing tokens past the end of a vector in the

// TokenLexer.

verifyNoCrash(R"(_T(

)

)");

}

TEST_F(FormatTest, BreaksStringLiteralOperands) {

// In a function call with two operands, the second can be broken with no line

// break before it.

EXPECT_EQ(

verifyFormat("func(a, \"long long \"\n"

"func(a, \"long long \"\n"

" \"long long\");",

format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));

"func(a, \"long long long long\");",

getLLVMStyleWithColumns(24));

// In a function call with three operands, the second must be broken with a

// line break before it.

EXPECT_EQ("func(a,\n"

verifyFormat("func(a,\n"

" \"long long long \"\n"

" \"long\",\n"

" c);",

format("func(a, \"long long long long\", c);",

"func(a, \"long long long long\", c);",

getLLVMStyleWithColumns(24)));

getLLVMStyleWithColumns(24));

// In a function call with three operands, the third must be broken with a

// line break before it.

EXPECT_EQ("func(a, b,\n"

verifyFormat("func(a, b,\n"

" \"long long long \"\n"

" \"long\");",

format("func(a, b, \"long long long long\");",

"func(a, b, \"long long long long\");",

getLLVMStyleWithColumns(24)));

getLLVMStyleWithColumns(24));

// In a function call with three operands, both the second and the third must

// be broken with a line break before them.

EXPECT_EQ("func(a,\n"

verifyFormat("func(a,\n"

" \"long long long \"\n"

" \"long\",\n"

" \"long long long \"\n"

" \"long\");",

format("func(a, \"long long long long\", \"long long long long\");",

"func(a, \"long long long long\", \"long long long long\");",

getLLVMStyleWithColumns(24)));

getLLVMStyleWithColumns(24));

// In a chain of << with two operands, the second can be broken with no line

// break before it.

EXPECT_EQ("a << \"line line \"\n"

verifyFormat("a << \"line line \"\n"

" \"line\";",

format("a << \"line line line\";", getLLVMStyleWithColumns(20)));

"a << \"line line line\";", getLLVMStyleWithColumns(20));

// In a chain of << with three operands, the second can be broken with no line

// break before it.

EXPECT_EQ(

verifyFormat("abcde << \"line \"\n"

"abcde << \"line \"\n"

" \"line line\"\n"

" << c;",

format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));

"abcde << \"line line line\" << c;",

getLLVMStyleWithColumns(20));

// In a chain of << with three operands, the third must be broken with a line

// break before it.

EXPECT_EQ(

verifyFormat("a << b\n"

"a << b\n"

" << \"line line \"\n"

" \"line\";",

format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));

"a << b << \"line line line\";", getLLVMStyleWithColumns(20));

// In a chain of << with three operands, the second can be broken with no line

// break before it and the third must be broken with a line break before it.

EXPECT_EQ("abcd << \"line line \"\n"

verifyFormat("abcd << \"line line \"\n"

" \"line\"\n"

" << \"line line \"\n"

" \"line\";",

format("abcd << \"line line line\" << \"line line line\";",

"abcd << \"line line line\" << \"line line line\";",

getLLVMStyleWithColumns(20)));

getLLVMStyleWithColumns(20));

// In a chain of binary operators with two operands, the second can be broken

// with no line break before it.

EXPECT_EQ(

verifyFormat("abcd + \"line line \"\n"

"abcd + \"line line \"\n"

" \"line line\";",

format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));

"abcd + \"line line line line\";", getLLVMStyleWithColumns(20));

// In a chain of binary operators with three operands, the second must be

// broken with a line break before it.

EXPECT_EQ("abcd +\n"

verifyFormat("abcd +\n"

" \"line line \"\n"

" \"line line\" +\n"

" e;",

format("abcd + \"line line line line\" + e;",

"abcd + \"line line line line\" + e;",

getLLVMStyleWithColumns(20)));

getLLVMStyleWithColumns(20));

// In a function call with two operands, with AlignAfterOpenBracket enabled,

// the first must be broken with a line break before it.

FormatStyle Style = getLLVMStyleWithColumns(25);

Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;

EXPECT_EQ("someFunction(\n"

verifyFormat("someFunction(\n"

" \"long long long \"\n"

" \"long\",\n"

" a);",

format("someFunction(\"long long long long\", a);", Style));

"someFunction(\"long long long long\", a);", Style);

Style.AlignAfterOpenBracket = FormatStyle::BAS_BlockIndent;

verifyFormat("someFunction(\n"

" \"long long long \"\n"

" \"long\",\n"

" a\n"

");",

Style);

}

TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {

EXPECT_EQ(

verifyFormat("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"

"aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",

format("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"

"aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));

" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";");

}

TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {

EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",

verifyFormat("f(g(R\"x(raw literal)x\", a), b);",

format("f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle()));

"f(g(R\"x(raw literal)x\", a), b);", getGoogleStyle());

EXPECT_EQ("fffffffffff(g(R\"x(\n"

verifyFormat("fffffffffff(g(R\"x(\n"

"multiline raw string literal xxxxxxxxxxxxxx\n"

")x\",\n"

" a),\n"

" b);",

format("fffffffffff(g(R\"x(\n"

"fffffffffff(g(R\"x(\n"

"multiline raw string literal xxxxxxxxxxxxxx\n"

")x\", a), b);",

getGoogleStyleWithColumns(20)));

getGoogleStyleWithColumns(20));

EXPECT_EQ("fffffffffff(\n"

verifyFormat("fffffffffff(\n"

" g(R\"x(qqq\n"

"multiline raw string literal xxxxxxxxxxxxxx\n"

")x\",\n"

" a),\n"

" b);",

format("fffffffffff(g(R\"x(qqq\n"

"fffffffffff(g(R\"x(qqq\n"

"multiline raw string literal xxxxxxxxxxxxxx\n"

")x\", a), b);",

getGoogleStyleWithColumns(20)));

getGoogleStyleWithColumns(20));

EXPECT_EQ("fffffffffff(R\"x(\n"

verifyNoChange("fffffffffff(R\"x(\n"

"multiline raw string literal xxxxxxxxxxxxxx\n"

")x\");",

format("fffffffffff(R\"x(\n"

getGoogleStyleWithColumns(20));

"multiline raw string literal xxxxxxxxxxxxxx\n"

verifyFormat("fffffffffff(R\"x(\n"

")x\");",

getGoogleStyleWithColumns(20)));

EXPECT_EQ("fffffffffff(R\"x(\n"

"multiline raw string literal xxxxxxxxxxxxxx\n"

")x\" + bbbbbb);",

format("fffffffffff(R\"x(\n"

"fffffffffff(R\"x(\n"

"multiline raw string literal xxxxxxxxxxxxxx\n"

")x\" + bbbbbb);",

getGoogleStyleWithColumns(20)));

getGoogleStyleWithColumns(20));

EXPECT_EQ("fffffffffff(\n"

verifyFormat("fffffffffff(\n"

" R\"x(\n"

"multiline raw string literal xxxxxxxxxxxxxx\n"

")x\" +\n"

" bbbbbb);",

format("fffffffffff(\n"

"fffffffffff(\n"

" R\"x(\n"

"multiline raw string literal xxxxxxxxxxxxxx\n"

")x\" + bbbbbb);",

getGoogleStyleWithColumns(20)));

getGoogleStyleWithColumns(20));

EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",

verifyFormat("fffffffffff(R\"(single line raw string)\" + bbbbbb);",

format("fffffffffff(\n"

"fffffffffff(\n"

" R\"(single line raw string)\" + bbbbbb);"));

" R\"(single line raw string)\" + bbbbbb);");

}

TEST_F(FormatTest, SkipsUnknownStringLiterals) {

verifyFormat("string a = \"unterminated;");

EXPECT_EQ("function(\"unterminated,\n"

verifyFormat("function(\"unterminated,\n"

" OtherParameter);",

format("function( \"unterminated,\n"

"function( \"unterminated,\n"

" OtherParameter);"));

" OtherParameter);");

}

TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {

FormatStyle Style = getLLVMStyle();

Style.Standard = FormatStyle::LS_Cpp03;

EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",

verifyFormat("#define x(_a) printf(\"foo\" _a);",

format("#define x(_a) printf(\"foo\"_a);", Style));

"#define x(_a) printf(\"foo\"_a);", Style);

}

TEST_F(FormatTest, CppLexVersion) {

FormatStyle Style = getLLVMStyle();

// Formatting of x * y differs if x is a type.

verifyFormat("void foo() { MACRO(a * b); }", Style);

verifyFormat("void foo() { MACRO(int *b); }", Style);

// LLVM style uses latest lexer.

verifyFormat("void foo() { MACRO(char8_t *b); }", Style);

Style.Standard = FormatStyle::LS_Cpp17;

// But in c++17, char8_t isn't a keyword.

verifyFormat("void foo() { MACRO(char8_t * b); }", Style);

}

TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }

TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {

EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"

verifyFormat("someFunction(\"aaabbbcccd\"\n"

" \"ddeeefff\");",

format("someFunction(\"aaabbbcccdddeeefff\");",

"someFunction(\"aaabbbcccdddeeefff\");",

getLLVMStyleWithColumns(25)));

getLLVMStyleWithColumns(25));

EXPECT_EQ("someFunction1234567890(\n"

verifyFormat("someFunction1234567890(\n"

" \"aaabbbcccdddeeefff\");",

format("someFunction1234567890(\"aaabbbcccdddeeefff\");",

"someFunction1234567890(\"aaabbbcccdddeeefff\");",

getLLVMStyleWithColumns(26)));

getLLVMStyleWithColumns(26));

EXPECT_EQ("someFunction1234567890(\n"

verifyFormat("someFunction1234567890(\n"

" \"aaabbbcccdddeeeff\"\n"

" \"f\");",

format("someFunction1234567890(\"aaabbbcccdddeeefff\");",

"someFunction1234567890(\"aaabbbcccdddeeefff\");",

getLLVMStyleWithColumns(25)));

getLLVMStyleWithColumns(25));

EXPECT_EQ("someFunction1234567890(\n"

verifyFormat("someFunction1234567890(\n"

" \"aaabbbcccdddeeeff\"\n"

" \"f\");",

format("someFunction1234567890(\"aaabbbcccdddeeefff\");",

"someFunction1234567890(\"aaabbbcccdddeeefff\");",

getLLVMStyleWithColumns(24)));

getLLVMStyleWithColumns(24));

EXPECT_EQ("someFunction(\n"

verifyFormat("someFunction(\n"

" \"aaabbbcc ddde \"\n"

" \"efff\");",

format("someFunction(\"aaabbbcc ddde efff\");",

"someFunction(\"aaabbbcc ddde efff\");",

getLLVMStyleWithColumns(25)));

getLLVMStyleWithColumns(25));

EXPECT_EQ("someFunction(\"aaabbbccc \"\n"

verifyFormat("someFunction(\"aaabbbccc \"\n"

" \"ddeeefff\");",

format("someFunction(\"aaabbbccc ddeeefff\");",

"someFunction(\"aaabbbccc ddeeefff\");",

getLLVMStyleWithColumns(25)));

getLLVMStyleWithColumns(25));

EXPECT_EQ("someFunction1234567890(\n"

verifyFormat("someFunction1234567890(\n"

" \"aaabb \"\n"

" \"cccdddeeefff\");",

format("someFunction1234567890(\"aaabb cccdddeeefff\");",

"someFunction1234567890(\"aaabb cccdddeeefff\");",

getLLVMStyleWithColumns(25)));

getLLVMStyleWithColumns(25));

EXPECT_EQ("#define A \\\n"

verifyFormat("#define A \\\n"

" string s = \\\n"

" \"123456789\" \\\n"

" \"0\"; \\\n"

" int i;",

format("#define A string s = \"1234567890\"; int i;",

"#define A string s = \"1234567890\"; int i;",

getLLVMStyleWithColumns(20)));

getLLVMStyleWithColumns(20));

EXPECT_EQ("someFunction(\n"

verifyFormat("someFunction(\n"

" \"aaabbbcc \"\n"

" \"dddeeefff\");",

format("someFunction(\"aaabbbcc dddeeefff\");",

"someFunction(\"aaabbbcc dddeeefff\");",

getLLVMStyleWithColumns(25)));

getLLVMStyleWithColumns(25));

}

TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {

verifyFormat("\"\\a\"", getLLVMStyleWithColumns(3));

verifyFormat("\"\\\"", getLLVMStyleWithColumns(2));

// FIXME: unstable test case

EXPECT_EQ("\"test\"\n"

"\"\\n\"",

format("\"test\\n\"", getLLVMStyleWithColumns(7)));

// FIXME: unstable test case

EXPECT_EQ("\"tes\\\\\"\n"

"\"n\"",

format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));

// FIXME: unstable test case

EXPECT_EQ("\"\\\\\\\\\"\n"

"\"\\n\"",

format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));

verifyFormat("\"\\uff01\"", getLLVMStyleWithColumns(7));

// FIXME: unstable test case

EXPECT_EQ("\"\\uff01\"\n"

"\"test\"",

format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));

verifyFormat("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11));

// FIXME: unstable test case

EXPECT_EQ("\"\\x000000000001\"\n"

"\"next\"",

format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));

verifyFormat("\"\\x000000000001next\"", getLLVMStyleWithColumns(15));

verifyFormat("\"\\x000000000001\"", getLLVMStyleWithColumns(7));

// FIXME: unstable test case

EXPECT_EQ("\"test\"\n"

"\"\\000000\"\n"

"\"000001\"",

format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));

// FIXME: unstable test case

EXPECT_EQ("\"test\\000\"\n"

"\"00000000\"\n"

"\"1\"",

format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));

}

TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {

verifyFormat("void f() {\n"

▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines

}

TEST_F(FormatTest, ConfigurableUseOfTab) {

FormatStyle Tab = getLLVMStyleWithColumns(42);

Tab.IndentWidth = 8;

Tab.UseTab = FormatStyle::UT_Always;

Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;

EXPECT_EQ("if (aaaaaaaa && // q\n"

verifyFormat("if (aaaaaaaa && // q\n"

" bb)\t\t// w\n"

"\t;",

format("if (aaaaaaaa &&// q\n"

"if (aaaaaaaa &&// q\n"

"bb)// w\n"

";",

Tab));

Tab);

EXPECT_EQ("if (aaa && bbb) // w\n"

verifyFormat("if (aaa && bbb) // w\n"

"\t;",

format("if(aaa&&bbb)// w\n"

"if(aaa&&bbb)// w\n"

";",

Tab));

Tab);

verifyFormat("class X {\n"

"\tvoid f() {\n"

"\t\tsomeFunction(parameter1,\n"

"\t\t\t parameter2);\n"

"\t}\n"

"};",

Tab);

▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines

verifyFormat("class TabWidth8Indent4 {\n"

"\tsomeFunction(parameter1,\n"

"\t\t parameter2);\n"

" }\n"

"};",

Tab);

Tab.TabWidth = 8;

Tab.IndentWidth = 8;

EXPECT_EQ("/*\n"

verifyFormat("/*\n"

"\t a\t\tcomment\n"

"\t in multiple lines\n"

" */",

format(" /*\t \t \n"

" /*\t \t \n"

" \t \t a\t\tcomment\t \t\n"

" \t \t in multiple lines\t\n"

" \t */",

Tab));

Tab);

TabAlignment.UseTab = FormatStyle::UT_ForIndentation;

TabAlignment.PointerAlignment = FormatStyle::PAS_Left;

verifyFormat("void f() {\n"

"\tunsigned long long big;\n"

"\tchar* ptr;\n"

"}",

TabAlignment);

Show All 21 Lines

verifyFormat("{\n"

"};",

Tab);

verifyFormat("enum AA {\n"

"\ta1, // Force multiple lines\n"

"\ta2,\n"

"\ta3\n"

"};",

Tab);

EXPECT_EQ("if (aaaaaaaa && // q\n"

verifyFormat("if (aaaaaaaa && // q\n"

" bb) // w\n"

"\t;",

format("if (aaaaaaaa &&// q\n"

"if (aaaaaaaa &&// q\n"

"bb)// w\n"

";",

Tab));

Tab);

verifyFormat("class X {\n"

"\tvoid f() {\n"

"\t\tsomeFunction(parameter1,\n"

"\t\t parameter2);\n"

"\t}\n"

"};",

Tab);

verifyFormat("{\n"

"\tQ(\n"

"\t {\n"

"\t\t int a;\n"

"\t\t someFunction(aaaaaaaa,\n"

"\t\t bbbbbbb);\n"

"\t },\n"

"\t p);\n"

"}",

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/* aaaa\n"

"\t bbbb */\n"

"}",

format("{\n"

"{\n"

"/* aaaa\n"

" bbbb */\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/*\n"

"\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t bbbbbbbbbbbbb\n"

"\t*/\n"

"}",

format("{\n"

"{\n"

"/*\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t// bbbbbbbbbbbbb\n"

"}",

format("{\n"

"{\n"

"\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/*\n"

"\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t bbbbbbbbbbbbb\n"

"\t*/\n"

"}",

format("{\n"

"{\n"

"\t/*\n"

"\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"\t*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyNoChange("{\n"

"\t/*\n"

"\n"

"\t*/\n"

"}",

format("{\n"

"\t/*\n"

"\n"

"\t*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyNoChange("{\n"

"\t/*\n"

" asdf\n"

"\t*/\n"

"}",

format("{\n"

"\t/*\n"

" asdf\n"

"\t*/\n"

"}",

Tab));

Tab);

verifyFormat("void f() {\n"

"\treturn true ? aaaaaaaaaaaaaaaaaa\n"

"\t : bbbbbbbbbbbbbbbbbb\n"

"}",

Tab);

FormatStyle TabNoBreak = Tab;

TabNoBreak.BreakBeforeTernaryOperators = false;

verifyFormat("void f() {\n"

"\treturn true ? aaaaaaaaaaaaaaaaaa :\n"

"\t bbbbbbbbbbbbbbbbbb\n"

"}",

TabNoBreak);

verifyFormat("void f() {\n"

"\treturn true ?\n"

"\t aaaaaaaaaaaaaaaaaaaa :\n"

"\t bbbbbbbbbbbbbbbbbbbb\n"

"}",

TabNoBreak);

Tab.UseTab = FormatStyle::UT_Never;

EXPECT_EQ("/*\n"

verifyFormat("/*\n"

" a\t\tcomment\n"

" in multiple lines\n"

" */",

format(" /*\t \t \n"

" /*\t \t \n"

" \t \t a\t\tcomment\t \t\n"

" \t \t in multiple lines\t\n"

" \t */",

Tab));

Tab);

EXPECT_EQ("/* some\n"

verifyFormat("/* some\n"

" comment */",

format(" \t \t /* some\n"

" \t \t /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("int a; /* some\n"

verifyFormat("int a; /* some\n"

" comment */",

format(" \t \t int a; /* some\n"

" \t \t int a; /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("int a; /* some\n"

verifyFormat("int a; /* some\n"

"comment */",

format(" \t \t int\ta; /* some\n"

" \t \t int\ta; /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("f(\"\t\t\"); /* some\n"

verifyFormat("f(\"\t\t\"); /* some\n"

" comment */",

format(" \t \t f(\"\t\t\"); /* some\n"

" \t \t f(\"\t\t\"); /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

" /*\n"

" * Comment\n"

" */\n"

" int i;\n"

"}",

format("{\n"

"{\n"

"\t/*\n"

"\t * Comment\n"

"\t */\n"

"\t int i;\n"

"}",

Tab));

Tab);

Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;

Tab.TabWidth = 8;

Tab.IndentWidth = 8;

EXPECT_EQ("if (aaaaaaaa && // q\n"

verifyFormat("if (aaaaaaaa && // q\n"

" bb) // w\n"

"\t;",

format("if (aaaaaaaa &&// q\n"

"if (aaaaaaaa &&// q\n"

"bb)// w\n"

";",

Tab));

Tab);

EXPECT_EQ("if (aaa && bbb) // w\n"

verifyFormat("if (aaa && bbb) // w\n"

"\t;",

format("if(aaa&&bbb)// w\n"

"if(aaa&&bbb)// w\n"

";",

Tab));

Tab);

verifyFormat("class X {\n"

"\tvoid f() {\n"

"\t\tsomeFunction(parameter1,\n"

"\t\t\t parameter2);\n"

"\t}\n"

"};",

Tab);

verifyFormat("#define A \\\n"

Show All 27 Lines

verifyFormat("class TabWidth8Indent4 {\n"

" void f() {\n"

"\tsomeFunction(parameter1,\n"

"\t\t parameter2);\n"

" }\n"

"};",

Tab);

Tab.TabWidth = 8;

Tab.IndentWidth = 8;

EXPECT_EQ("/*\n"

verifyFormat("/*\n"

"\t a\t\tcomment\n"

"\t in multiple lines\n"

" */",

format(" /*\t \t \n"

" /*\t \t \n"

" \t \t a\t\tcomment\t \t\n"

" \t \t in multiple lines\t\n"

" \t */",

Tab));

Tab);

verifyFormat("{\n"

"\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"

"};",

Tab);

verifyFormat("enum AA {\n"

"\ta1, // Force multiple lines\n"

"\ta2,\n"

"\ta3\n"

"};",

Tab);

EXPECT_EQ("if (aaaaaaaa && // q\n"

verifyFormat("if (aaaaaaaa && // q\n"

" bb) // w\n"

"\t;",

format("if (aaaaaaaa &&// q\n"

"if (aaaaaaaa &&// q\n"

"bb)// w\n"

";",

Tab));

Tab);

verifyFormat("class X {\n"

"\tvoid f() {\n"

"\t\tsomeFunction(parameter1,\n"

"\t\t\t parameter2);\n"

"\t}\n"

"};",

Tab);

verifyFormat("{\n"

"\tQ(\n"

"\t {\n"

"\t\t int a;\n"

"\t\t someFunction(aaaaaaaa,\n"

"\t\t\t\t bbbbbbb);\n"

"\t },\n"

"\t p);\n"

"}",

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/* aaaa\n"

"\t bbbb */\n"

"}",

format("{\n"

"{\n"

"/* aaaa\n"

" bbbb */\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/*\n"

"\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t bbbbbbbbbbbbb\n"

"\t*/\n"

"}",

format("{\n"

"{\n"

"/*\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t// bbbbbbbbbbbbb\n"

"}",

format("{\n"

"{\n"

"\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/*\n"

"\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t bbbbbbbbbbbbb\n"

"\t*/\n"

"}",

format("{\n"

"{\n"

"\t/*\n"

"\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"\t*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyNoChange("{\n"

"\t/*\n"

"\n"

"\t*/\n"

"}",

format("{\n"

"\t/*\n"

"\n"

"\t*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyNoChange("{\n"

"\t/*\n"

" asdf\n"

"\t*/\n"

"}",

format("{\n"

"\t/*\n"

" asdf\n"

"\t*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("/* some\n"

verifyFormat("/* some\n"

" comment */",

format(" \t \t /* some\n"

" \t \t /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("int a; /* some\n"

verifyFormat("int a; /* some\n"

" comment */",

format(" \t \t int a; /* some\n"

" \t \t int a; /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("int a; /* some\n"

verifyFormat("int a; /* some\n"

"comment */",

format(" \t \t int\ta; /* some\n"

" \t \t int\ta; /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("f(\"\t\t\"); /* some\n"

verifyFormat("f(\"\t\t\"); /* some\n"

" comment */",

format(" \t \t f(\"\t\t\"); /* some\n"

" \t \t f(\"\t\t\"); /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/*\n"

"\t * Comment\n"

"\t */\n"

"\tint i;\n"

"}",

format("{\n"

"{\n"

"\t/*\n"

"\t * Comment\n"

"\t */\n"

"\t int i;\n"

"}",

Tab));

Tab);

Tab.TabWidth = 2;

Tab.IndentWidth = 2;

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/* aaaa\n"

"\t\t bbbb */\n"

"}",

format("{\n"

"{\n"

"/* aaaa\n"

"\t bbbb */\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/*\n"

"\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t\tbbbbbbbbbbbbb\n"

"\t*/\n"

"}",

format("{\n"

"{\n"

"/*\n"

"\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"*/\n"

"}",

Tab));

Tab);

Tab.AlignConsecutiveAssignments.Enabled = true;

Tab.AlignConsecutiveDeclarations.Enabled = true;

Tab.TabWidth = 4;

Tab.IndentWidth = 4;

verifyFormat("class Assign {\n"

"\tvoid f() {\n"

"\t\tint x = 123;\n"

"\t\tint random = 4;\n"

"\t\tstd::string alphabet =\n"

"\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"

"\t}\n"

"};",

Tab);

Tab.UseTab = FormatStyle::UT_AlignWithSpaces;

Tab.TabWidth = 8;

Tab.IndentWidth = 8;

EXPECT_EQ("if (aaaaaaaa && // q\n"

verifyFormat("if (aaaaaaaa && // q\n"

" bb) // w\n"

"\t;",

format("if (aaaaaaaa &&// q\n"

"if (aaaaaaaa &&// q\n"

"bb)// w\n"

";",

Tab));

Tab);

EXPECT_EQ("if (aaa && bbb) // w\n"

verifyFormat("if (aaa && bbb) // w\n"

"\t;",

format("if(aaa&&bbb)// w\n"

"if(aaa&&bbb)// w\n"

";",

Tab));

Tab);

verifyFormat("class X {\n"

"\tvoid f() {\n"

"\t\tsomeFunction(parameter1,\n"

"\t\t parameter2);\n"

"\t}\n"

"};",

Tab);

verifyFormat("#define A \\\n"

Show All 27 Lines

verifyFormat("class TabWidth8Indent4 {\n"

" void f() {\n"

"\tsomeFunction(parameter1,\n"

"\t parameter2);\n"

" }\n"

"};",

Tab);

Tab.TabWidth = 8;

Tab.IndentWidth = 8;

EXPECT_EQ("/*\n"

verifyFormat("/*\n"

" a\t\tcomment\n"

" in multiple lines\n"

" */",

format(" /*\t \t \n"

" /*\t \t \n"

" \t \t a\t\tcomment\t \t\n"

" \t \t in multiple lines\t\n"

" \t */",

Tab));

Tab);

verifyFormat("{\n"

"\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"

"};",

Tab);

verifyFormat("enum AA {\n"

"\ta1, // Force multiple lines\n"

"\ta2,\n"

"\ta3\n"

"};",

Tab);

EXPECT_EQ("if (aaaaaaaa && // q\n"

verifyFormat("if (aaaaaaaa && // q\n"

" bb) // w\n"

"\t;",

format("if (aaaaaaaa &&// q\n"

"if (aaaaaaaa &&// q\n"

"bb)// w\n"

";",

Tab));

Tab);

verifyFormat("class X {\n"

"\tvoid f() {\n"

"\t\tsomeFunction(parameter1,\n"

"\t\t parameter2);\n"

"\t}\n"

"};",

Tab);

verifyFormat("{\n"

"\tQ(\n"

"\t {\n"

"\t\t int a;\n"

"\t\t someFunction(aaaaaaaa,\n"

"\t\t bbbbbbb);\n"

"\t },\n"

"\t p);\n"

"}",

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/* aaaa\n"

"\t bbbb */\n"

"}",

format("{\n"

"{\n"

"/* aaaa\n"

" bbbb */\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/*\n"

"\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t bbbbbbbbbbbbb\n"

"\t*/\n"

"}",

format("{\n"

"{\n"

"/*\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t// bbbbbbbbbbbbb\n"

"}",

format("{\n"

"{\n"

"\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/*\n"

"\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t bbbbbbbbbbbbb\n"

"\t*/\n"

"}",

format("{\n"

"{\n"

"\t/*\n"

"\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"\t*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyNoChange("{\n"

"\t/*\n"

"\n"

"\t*/\n"

"}",

format("{\n"

"\t/*\n"

"\n"

"\t*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyNoChange("{\n"

"\t/*\n"

" asdf\n"

"\t*/\n"

"}",

format("{\n"

"\t/*\n"

" asdf\n"

"\t*/\n"

"}",

Tab));

Tab);

EXPECT_EQ("/* some\n"

verifyFormat("/* some\n"

" comment */",

format(" \t \t /* some\n"

" \t \t /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("int a; /* some\n"

verifyFormat("int a; /* some\n"

" comment */",

format(" \t \t int a; /* some\n"

" \t \t int a; /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("int a; /* some\n"

verifyFormat("int a; /* some\n"

"comment */",

format(" \t \t int\ta; /* some\n"

" \t \t int\ta; /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("f(\"\t\t\"); /* some\n"

verifyFormat("f(\"\t\t\"); /* some\n"

" comment */",

format(" \t \t f(\"\t\t\"); /* some\n"

" \t \t f(\"\t\t\"); /* some\n"

" \t \t comment */",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/*\n"

"\t * Comment\n"

"\t */\n"

"\tint i;\n"

"}",

format("{\n"

"{\n"

"\t/*\n"

"\t * Comment\n"

"\t */\n"

"\t int i;\n"

"}",

Tab));

Tab);

Tab.TabWidth = 2;

Tab.IndentWidth = 2;

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/* aaaa\n"

"\t bbbb */\n"

"}",

format("{\n"

"{\n"

"/* aaaa\n"

" bbbb */\n"

"}",

Tab));

Tab);

EXPECT_EQ("{\n"

verifyFormat("{\n"

"\t/*\n"

"\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"

"\t bbbbbbbbbbbbb\n"

"\t*/\n"

"}",

format("{\n"

"{\n"

"/*\n"

" aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"

"*/\n"

"}",

Tab));

Tab);

Tab.AlignConsecutiveAssignments.Enabled = true;

Tab.AlignConsecutiveDeclarations.Enabled = true;

Tab.TabWidth = 4;

Tab.IndentWidth = 4;

verifyFormat("class Assign {\n"

"\tvoid f() {\n"

"\t\tint x = 123;\n"

"\t\tint random = 4;\n"

Show All 21 Lines

verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"

Tab);

}

TEST_F(FormatTest, ZeroTabWidth) {

FormatStyle Tab = getLLVMStyleWithColumns(42);

Tab.IndentWidth = 8;

Tab.UseTab = FormatStyle::UT_Never;

Tab.TabWidth = 0;

EXPECT_EQ("void a(){\n"

verifyFormat("void a(){\n"

" // line starts with '\t'\n"

"};",

format("void a(){\n"

"void a(){\n"

"\t// line starts with '\t'\n"

"};",

Tab));

Tab);

EXPECT_EQ("void a(){\n"

verifyFormat("void a(){\n"

" // line starts with '\t'\n"

"};",

format("void a(){\n"

"void a(){\n"

"\t\t// line starts with '\t'\n"

"};",

Tab));

Tab);

Tab.UseTab = FormatStyle::UT_ForIndentation;

EXPECT_EQ("void a(){\n"

verifyFormat("void a(){\n"

" // line starts with '\t'\n"

"};",

format("void a(){\n"

"void a(){\n"

"\t// line starts with '\t'\n"

"};",

Tab));

Tab);

EXPECT_EQ("void a(){\n"

verifyFormat("void a(){\n"

" // line starts with '\t'\n"

"};",

format("void a(){\n"

"void a(){\n"

"\t\t// line starts with '\t'\n"

"};",

Tab));

Tab);

Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;

EXPECT_EQ("void a(){\n"

verifyFormat("void a(){\n"

" // line starts with '\t'\n"

"};",

format("void a(){\n"

"void a(){\n"

"\t// line starts with '\t'\n"

"};",

Tab));

Tab);

EXPECT_EQ("void a(){\n"

verifyFormat("void a(){\n"

" // line starts with '\t'\n"

"};",

format("void a(){\n"

"void a(){\n"

"\t\t// line starts with '\t'\n"

"};",

Tab));

Tab);

Tab.UseTab = FormatStyle::UT_AlignWithSpaces;

EXPECT_EQ("void a(){\n"

verifyFormat("void a(){\n"

" // line starts with '\t'\n"

"};",

format("void a(){\n"

"void a(){\n"

"\t// line starts with '\t'\n"

"};",

Tab));

Tab);

EXPECT_EQ("void a(){\n"

verifyFormat("void a(){\n"

" // line starts with '\t'\n"

"};",

format("void a(){\n"

"void a(){\n"

"\t\t// line starts with '\t'\n"

"};",

Tab));

Tab);

Tab.UseTab = FormatStyle::UT_Always;

EXPECT_EQ("void a(){\n"

verifyFormat("void a(){\n"

"// line starts with '\t'\n"

"};",

format("void a(){\n"

"void a(){\n"

"\t// line starts with '\t'\n"

"};",

Tab));

Tab);

EXPECT_EQ("void a(){\n"

verifyFormat("void a(){\n"

"// line starts with '\t'\n"

"};",

format("void a(){\n"

"void a(){\n"

"\t\t// line starts with '\t'\n"

"};",

Tab));

Tab);

}

TEST_F(FormatTest, CalculatesOriginalColumn) {

EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

verifyFormat("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

"q\"; /* some\n"

" comment */",

format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

"q\"; /* some\n"

" comment */"));

" comment */");

EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"

verifyFormat("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"

"/* some\n"

" comment */",

format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"

"// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"

" /* some\n"

" comment */"));

" comment */");

EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

verifyFormat("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

"qqq\n"

"/* some\n"

" comment */",

format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

"// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

"qqq\n"

" /* some\n"

" comment */"));

" comment */");

EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

verifyFormat("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

"wwww; /* some\n"

" comment */",

format(" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

" inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"

"wwww; /* some\n"

" comment */"));

" comment */");

}

TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {

FormatStyle NoSpace = getLLVMStyle();

NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;

verifyFormat("while(true)\n"

" continue;",

▲ Show 20 Lines • Show All 1,187 Lines • ▼ Show 20 Lines

verifyFormat("#define a \\\n"

" \"FFFFFFFFFFFFF\" \\\n"

" \"LLLLLLLL\"",

Style);

// Test across comments

Style.MaxEmptyLinesToKeep = 10;

Style.ReflowComments = false;

Style.AlignConsecutiveMacros.AcrossComments = true;

EXPECT_EQ("#define a 3\n"

verifyFormat("#define a 3\n"

"// line comment\n"

"#define bbbb 4\n"

"#define ccc (5)",

format("#define a 3\n"

"#define a 3\n"

"// line comment\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style));

Style);

EXPECT_EQ("#define a 3\n"

verifyFormat("#define a 3\n"

"/* block comment */\n"

"#define bbbb 4\n"

"#define ccc (5)",

format("#define a 3\n"

"#define a 3\n"

"/* block comment */\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style));

Style);

EXPECT_EQ("#define a 3\n"

verifyFormat("#define a 3\n"

"/* multi-line *\n"

" * block comment */\n"

"#define bbbb 4\n"

"#define ccc (5)",

format("#define a 3\n"

"#define a 3\n"

"/* multi-line *\n"

" * block comment */\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style));

Style);

EXPECT_EQ("#define a 3\n"

verifyFormat("#define a 3\n"

"// multi-line line comment\n"

"//\n"

"#define bbbb 4\n"

"#define ccc (5)",

format("#define a 3\n"

"#define a 3\n"

"// multi-line line comment\n"

"//\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style));

Style);

EXPECT_EQ("#define a 3\n"

verifyFormat("#define a 3\n"

"// empty lines still break.\n"

"\n"

"#define bbbb 4\n"

"#define ccc (5)",

format("#define a 3\n"

"#define a 3\n"

"// empty lines still break.\n"

"\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style));

Style);

// Test across empty lines

Style.AlignConsecutiveMacros.AcrossComments = false;

Style.AlignConsecutiveMacros.AcrossEmptyLines = true;

EXPECT_EQ("#define a 3\n"

verifyFormat("#define a 3\n"

"\n"

"#define bbbb 4\n"

"#define ccc (5)",

format("#define a 3\n"

"#define a 3\n"

"\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style));

Style);

EXPECT_EQ("#define a 3\n"

verifyFormat("#define a 3\n"

"\n"

"#define bbbb 4\n"

"#define ccc (5)",

format("#define a 3\n"

"#define a 3\n"

"\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style));

Style);

EXPECT_EQ("#define a 3\n"

verifyFormat("#define a 3\n"

"// comments should break alignment\n"

"//\n"

"#define bbbb 4\n"

"#define ccc (5)",

format("#define a 3\n"

"#define a 3\n"

"// comments should break alignment\n"

"//\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style));

Style);

// Test across empty lines and comments

Style.AlignConsecutiveMacros.AcrossComments = true;

verifyFormat("#define a 3\n"

"\n"

"// line comment\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style);

EXPECT_EQ("#define a 3\n"

verifyFormat("#define a 3\n"

"\n"

"/* multi-line *\n"

" * block comment */\n"

"\n"

"#define bbbb 4\n"

"#define ccc (5)",

format("#define a 3\n"

"#define a 3\n"

"\n"

"/* multi-line *\n"

" * block comment */\n"

"\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style));

Style);

EXPECT_EQ("#define a 3\n"

verifyFormat("#define a 3\n"

"\n"

"/* multi-line *\n"

" * block comment */\n"

"\n"

"#define bbbb 4\n"

"#define ccc (5)",

format("#define a 3\n"

"#define a 3\n"

"\n"

"/* multi-line *\n"

" * block comment */\n"

"\n"

"#define bbbb 4\n"

"#define ccc (5)",

Style));

Style);

}

TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLines) {

FormatStyle Alignment = getLLVMStyle();

Alignment.AlignConsecutiveMacros.Enabled = true;

Alignment.AlignConsecutiveAssignments.Enabled = true;

Alignment.AlignConsecutiveAssignments.AcrossEmptyLines = true;

Alignment.MaxEmptyLinesToKeep = 10;

/* Test alignment across empty lines */

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"int oneTwoThree= 123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;\n"

"int oneTwo = 12;",

format("int a = 5;\n"

"int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;\n"

"int oneTwo = 12;",

Alignment));

Alignment);

/* Test across comments */

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"/* block comment */\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"/* block comment */\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"// line comment\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"// line comment\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

/* Test across comments and newlines */

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"/* block comment */\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"/* block comment */\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"// line comment\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"// line comment\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

}

TEST_F(FormatTest, AlignConsecutiveDeclarationsAcrossEmptyLinesAndComments) {

FormatStyle Alignment = getLLVMStyle();

Alignment.AlignConsecutiveDeclarations.Enabled = true;

Alignment.AlignConsecutiveDeclarations.AcrossEmptyLines = true;

Alignment.AlignConsecutiveDeclarations.AcrossComments = true;

Alignment.MaxEmptyLinesToKeep = 10;

/* Test alignment across empty lines */

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"float const oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"float const oneTwoThree = 123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"float const one = 1;\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"float const one = 1;\n"

"\n"

"int oneTwoThree = 123;",

Alignment));

Alignment);

/* Test across comments */

EXPECT_EQ("float const a = 5;\n"

verifyFormat("float const a = 5;\n"

"/* block comment */\n"

"int oneTwoThree = 123;",

format("float const a = 5;\n"

"float const a = 5;\n"

"/* block comment */\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("float const a = 5;\n"

verifyFormat("float const a = 5;\n"

"// line comment\n"

"int oneTwoThree = 123;",

format("float const a = 5;\n"

"float const a = 5;\n"

"// line comment\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

/* Test across comments and newlines */

EXPECT_EQ("float const a = 5;\n"

verifyFormat("float const a = 5;\n"

"\n"

"/* block comment */\n"

"int oneTwoThree = 123;",

format("float const a = 5;\n"

"float const a = 5;\n"

"\n"

"/* block comment */\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("float const a = 5;\n"

verifyFormat("float const a = 5;\n"

"\n"

"// line comment\n"

"int oneTwoThree = 123;",

format("float const a = 5;\n"

"float const a = 5;\n"

"\n"

"// line comment\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

}

TEST_F(FormatTest, AlignConsecutiveBitFieldsAcrossEmptyLinesAndComments) {

FormatStyle Alignment = getLLVMStyle();

Alignment.AlignConsecutiveBitFields.Enabled = true;

Alignment.AlignConsecutiveBitFields.AcrossEmptyLines = true;

Alignment.AlignConsecutiveBitFields.AcrossComments = true;

Alignment.MaxEmptyLinesToKeep = 10;

/* Test alignment across empty lines */

EXPECT_EQ("int a : 5;\n"

verifyFormat("int a : 5;\n"

"\n"

"int longbitfield : 6;",

format("int a : 5;\n"

"int a : 5;\n"

"\n"

"int longbitfield : 6;",

Alignment));

Alignment);

EXPECT_EQ("int a : 5;\n"

verifyFormat("int a : 5;\n"

"int one : 1;\n"

"\n"

"int longbitfield : 6;",

format("int a : 5;\n"

"int a : 5;\n"

"int one : 1;\n"

"\n"

"int longbitfield : 6;",

Alignment));

Alignment);

/* Test across comments */

EXPECT_EQ("int a : 5;\n"

verifyFormat("int a : 5;\n"

"/* block comment */\n"

"int longbitfield : 6;",

format("int a : 5;\n"

"int a : 5;\n"

"/* block comment */\n"

"int longbitfield : 6;",

Alignment));

Alignment);

EXPECT_EQ("int a : 5;\n"

verifyFormat("int a : 5;\n"

"int one : 1;\n"

"// line comment\n"

"int longbitfield : 6;",

format("int a : 5;\n"

"int a : 5;\n"

"int one : 1;\n"

"// line comment\n"

"int longbitfield : 6;",

Alignment));

Alignment);

/* Test across comments and newlines */

EXPECT_EQ("int a : 5;\n"

verifyFormat("int a : 5;\n"

"/* block comment */\n"

"\n"

"int longbitfield : 6;",

format("int a : 5;\n"

"int a : 5;\n"

"/* block comment */\n"

"\n"

"int longbitfield : 6;",

Alignment));

Alignment);

EXPECT_EQ("int a : 5;\n"

verifyFormat("int a : 5;\n"

"int one : 1;\n"

"\n"

"// line comment\n"

"\n"

"int longbitfield : 6;",

format("int a : 5;\n"

"int a : 5;\n"

"int one : 1;\n"

"\n"

"// line comment \n"

"\n"

"int longbitfield : 6;",

Alignment));

Alignment);

}

TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossComments) {

FormatStyle Alignment = getLLVMStyle();

Alignment.AlignConsecutiveMacros.Enabled = true;

Alignment.AlignConsecutiveAssignments.Enabled = true;

Alignment.AlignConsecutiveAssignments.AcrossComments = true;

Alignment.MaxEmptyLinesToKeep = 10;

/* Test alignment across empty lines */

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"int oneTwoThree= 123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;",

Alignment));

Alignment);

/* Test across comments */

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"/* block comment */\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"/* block comment */\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"// line comment\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"// line comment\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"/*\n"

" * multi-line block comment\n"

" */\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"/*\n"

" * multi-line block comment\n"

" */\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"//\n"

"// multi-line line comment\n"

"//\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"//\n"

"// multi-line line comment\n"

"//\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

/* Test across comments and newlines */

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"/* block comment */\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"/* block comment */\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"// line comment\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"// line comment\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

}

TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLinesAndComments) {

FormatStyle Alignment = getLLVMStyle();

Alignment.AlignConsecutiveMacros.Enabled = true;

Alignment.AlignConsecutiveAssignments.Enabled = true;

Alignment.AlignConsecutiveAssignments.AcrossEmptyLines = true;

Alignment.AlignConsecutiveAssignments.AcrossComments = true;

▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines

verifyFormat("enum foo {\n"

" a = 12;\n"

"#endif\n"

"};",

Alignment);

Alignment.MaxEmptyLinesToKeep = 10;

/* Test alignment across empty lines */

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"int oneTwoThree= 123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;\n"

"int oneTwo = 12;",

format("int a = 5;\n"

"int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;\n"

"int oneTwo = 12;",

Alignment));

Alignment);

/* Test across comments */

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"/* block comment */\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"/* block comment */\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"// line comment\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"// line comment\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

/* Test across comments and newlines */

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"/* block comment */\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"/* block comment */\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"// line comment\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"// line comment\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"//\n"

"// multi-line line comment\n"

"//\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"//\n"

"// multi-line line comment\n"

"//\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"/*\n"

" * multi-line block comment\n"

" */\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"/*\n"

" * multi-line block comment\n"

" */\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"/* block comment */\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"/* block comment */\n"

"\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"// line comment\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"// line comment\n"

"\n"

"int oneTwoThree=123;",

Alignment));

Alignment);

Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;

verifyFormat("#define A \\\n"

" int aaaa = 12; \\\n"

" int b = 23; \\\n"

" int ccc = 234; \\\n"

" int dddddddddd = 2345;",

Alignment);

▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines

verifyFormat("for (int i = 0; i < 1; i++)\n"

Alignment);

verifyFormat("for (i = 0; i < 1; i++)\n"

" x = 1;\n"

"y = 1;",

Alignment);

Alignment.ReflowComments = true;

Alignment.ColumnLimit = 50;

EXPECT_EQ("int x = 0;\n"

verifyFormat("int x = 0;\n"

"int yy = 1; /// specificlennospace\n"

"int zzz = 2;",

format("int x = 0;\n"

"int x = 0;\n"

"int yy = 1; ///specificlennospace\n"

"int zzz = 2;",

Alignment));

Alignment);

}

TEST_F(FormatTest, AlignCompoundAssignments) {

FormatStyle Alignment = getLLVMStyle();

Alignment.AlignConsecutiveAssignments.Enabled = true;

Alignment.AlignConsecutiveAssignments.AlignCompound = true;

Alignment.AlignConsecutiveAssignments.PadOperators = false;

verifyFormat("sfdbddfbdfbb = 5;\n"

Show All 35 Lines

TEST_F(FormatTest, AlignCompoundAssignments) {

verifyFormat("sfdbddfbdfbb ^= 5;\n"

"dvsdsv |= 5;\n"

"int dsvvdvsdvvv = 123;",

Alignment);

verifyFormat("sfdbddfbdfbb ^= 5;\n"

"dvsdsv <<= 5;\n"

"int dsvvdvsdvvv = 123;",

Alignment);

EXPECT_EQ("a += 5;\n"

verifyFormat("a += 5;\n"

"one = 1;\n"

"\n"

"oneTwoThree = 123;",

format("a += 5;\n"

"a += 5;\n"

"one = 1;\n"

"\n"

"oneTwoThree = 123;",

Alignment));

Alignment);

EXPECT_EQ("a += 5;\n"

verifyFormat("a += 5;\n"

"one = 1;\n"

"//\n"

"oneTwoThree = 123;",

format("a += 5;\n"

"a += 5;\n"

"one = 1;\n"

"//\n"

"oneTwoThree = 123;",

Alignment));

Alignment);

Alignment.AlignConsecutiveAssignments.AcrossEmptyLines = true;

EXPECT_EQ("a += 5;\n"

verifyFormat("a += 5;\n"

"one = 1;\n"

"\n"

"oneTwoThree = 123;",

format("a += 5;\n"

"a += 5;\n"

"one = 1;\n"

"\n"

"oneTwoThree = 123;",

Alignment));

Alignment);

EXPECT_EQ("a += 5;\n"

verifyFormat("a += 5;\n"

"one = 1;\n"

"//\n"

"oneTwoThree = 123;",

format("a += 5;\n"

"a += 5;\n"

"one = 1;\n"

"//\n"

"oneTwoThree = 123;",

Alignment));

Alignment);

Alignment.AlignConsecutiveAssignments.AcrossEmptyLines = false;

Alignment.AlignConsecutiveAssignments.AcrossComments = true;

EXPECT_EQ("a += 5;\n"

verifyFormat("a += 5;\n"

"one = 1;\n"

"\n"

"oneTwoThree = 123;",

format("a += 5;\n"

"a += 5;\n"

"one = 1;\n"

"\n"

"oneTwoThree = 123;",

Alignment));

Alignment);

EXPECT_EQ("a += 5;\n"

verifyFormat("a += 5;\n"

"one = 1;\n"

"//\n"

"oneTwoThree = 123;",

format("a += 5;\n"

"a += 5;\n"

"one = 1;\n"

"//\n"

"oneTwoThree = 123;",

Alignment));

Alignment);

Alignment.AlignConsecutiveAssignments.AcrossEmptyLines = true;

EXPECT_EQ("a += 5;\n"

verifyFormat("a += 5;\n"

"one >>= 1;\n"

"\n"

"oneTwoThree = 123;",

format("a += 5;\n"

"a += 5;\n"

"one >>= 1;\n"

"\n"

"oneTwoThree = 123;",

Alignment));

Alignment);

EXPECT_EQ("a += 5;\n"

verifyFormat("a += 5;\n"

"one = 1;\n"

"//\n"

"oneTwoThree <<= 123;",

format("a += 5;\n"

"a += 5;\n"

"one = 1;\n"

"//\n"

"oneTwoThree <<= 123;",

Alignment));

Alignment);

}

TEST_F(FormatTest, AlignConsecutiveAssignments) {

FormatStyle Alignment = getLLVMStyle();

Alignment.AlignConsecutiveMacros.Enabled = true;

verifyFormat("int a = 5;\n"

"int oneTwoThree = 123;",

Alignment);

▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines

verifyFormat("enum foo {\n"

"#if B\n"

"#else\n"

" a = 12;\n"

"#endif\n"

"};",

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"\n"

"int oneTwoThree= 123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;",

format("int a = 5;\n"

"int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;",

Alignment));

Alignment);

EXPECT_EQ("int a = 5;\n"

verifyFormat("int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;\n"

"int oneTwo = 12;",

format("int a = 5;\n"

"int a = 5;\n"

"int one = 1;\n"

"\n"

"int oneTwoThree = 123;\n"

"int oneTwo = 12;",

Alignment));

Alignment);

Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;

verifyFormat("#define A \\\n"

" int aaaa = 12; \\\n"

" int b = 23; \\\n"

" int ccc = 234; \\\n"

" int dddddddddd = 2345;",

Alignment);

Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;

▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines

verifyFormat("for (int i = 0; i < 1; i++)\n"

Alignment);

verifyFormat("for (i = 0; i < 1; i++)\n"

" x = 1;\n"

"y = 1;",

Alignment);

EXPECT_EQ(Alignment.ReflowComments, true);

Alignment.ColumnLimit = 50;

EXPECT_EQ("int x = 0;\n"

verifyFormat("int x = 0;\n"

"int yy = 1; /// specificlennospace\n"

"int zzz = 2;",

format("int x = 0;\n"

"int x = 0;\n"

"int yy = 1; ///specificlennospace\n"

"int zzz = 2;",

Alignment));

Alignment);

verifyFormat("auto aaaaaaaaaaaaaaaaaaaaa = {};\n"

"auto b = [] {\n"

" f();\n"

" return;\n"

"};",

Alignment);

verifyFormat("auto aaaaaaaaaaaaaaaaaaaaa = {};\n"

▲ Show 20 Lines • Show All 157 Lines • ▼ Show 20 Lines

verifyFormat("unsigned int *a;\n"

Alignment);

verifyFormat("Const unsigned int *c;\n"

"const unsigned int *d;\n"

"Const unsigned int &e;\n"

"const unsigned int &f;\n"

"const unsigned g;\n"

"Const unsigned h;",

Alignment);

EXPECT_EQ("float const a = 5;\n"

verifyFormat("float const a = 5;\n"

"\n"

"int oneTwoThree = 123;",

format("float const a = 5;\n"

"float const a = 5;\n"

"\n"

"int oneTwoThree= 123;",

Alignment));

Alignment);

EXPECT_EQ("float a = 5;\n"

verifyFormat("float a = 5;\n"

"int one = 1;\n"

"\n"

"unsigned oneTwoThree = 123;",

format("float a = 5;\n"

"float a = 5;\n"

"int one = 1;\n"

"\n"

"unsigned oneTwoThree = 123;",

Alignment));

Alignment);

EXPECT_EQ("float a = 5;\n"

verifyFormat("float a = 5;\n"

"int one = 1;\n"

"\n"

"unsigned oneTwoThree = 123;\n"

"int oneTwo = 12;",

format("float a = 5;\n"

"float a = 5;\n"

"int one = 1;\n"

"\n"

"unsigned oneTwoThree = 123;\n"

"int oneTwo = 12;",

Alignment));

Alignment);

// Function prototype alignment

verifyFormat("int a();\n"

"double b();",

Alignment);

verifyFormat("int a(int x);\n"

"double b();",

Alignment);

unsigned OldColumnLimit = Alignment.ColumnLimit;

// We need to set ColumnLimit to zero, in order to stress nested alignments,

// otherwise the function parameters will be re-flowed onto a single line.

Alignment.ColumnLimit = 0;

EXPECT_EQ("int a(int x,\n"

verifyFormat("int a(int x,\n"

" float y);\n"

"double b(int x,\n"

" double y);",

format("int a(int x,\n"

"int a(int x,\n"

" float y);\n"

"double b(int x,\n"

" double y);",

Alignment));

Alignment);

// This ensures that function parameters of function declarations are

// correctly indented when their owning functions are indented.

// The failure case here is for 'double y' to not be indented enough.

EXPECT_EQ("double a(int x);\n"

verifyFormat("double a(int x);\n"

"int b(int y,\n"

" double z);",

format("double a(int x);\n"

"double a(int x);\n"

"int b(int y,\n"

" double z);",

Alignment));

Alignment);

// Set ColumnLimit low so that we induce wrapping immediately after

// the function name and opening paren.

Alignment.ColumnLimit = 13;

verifyFormat("int function(\n"

" int x,\n"

" bool y);",

Alignment);

Alignment.ColumnLimit = OldColumnLimit;

▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines

verifyFormat("struct test {\n"

Alignment);

// http://llvm.org/PR52914

verifyFormat("char *a[] = {\"a\", // comment\n"

" \"bb\"};\n"

"int bbbbbbb = 0;",

Alignment);

// PAS_Right

EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"

verifyFormat("void SomeFunction(int parameter = 0) {\n"

" int const i = 1;\n"

" int *j = 2;\n"

" int big = 10000;\n"

"\n"

" unsigned oneTwoThree = 123;\n"

" int oneTwo = 12;\n"

" method();\n"

" float k = 2;\n"

" int ll = 10000;\n"

"}",

format("void SomeFunction(int parameter= 0) {\n"

"void SomeFunction(int parameter= 0) {\n"

" int const i= 1;\n"

" int *j=2;\n"

" int big = 10000;\n"

"\n"

"unsigned oneTwoThree =123;\n"

"int oneTwo = 12;\n"

" method();\n"

"float k= 2;\n"

"int ll=10000;\n"

"}",

Alignment));

Alignment);

EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"

verifyFormat("void SomeFunction(int parameter = 0) {\n"

" int const i = 1;\n"

" int **j = 2, ***k;\n"

" int &k = i;\n"

" int &&l = i + j;\n"

" int big = 10000;\n"

"\n"

" unsigned oneTwoThree = 123;\n"

" int oneTwo = 12;\n"

" method();\n"

" float k = 2;\n"

" int ll = 10000;\n"

"}",

format("void SomeFunction(int parameter= 0) {\n"

"void SomeFunction(int parameter= 0) {\n"

" int const i= 1;\n"

" int **j=2,***k;\n"

"int &k=i;\n"

"int &&l=i+j;\n"

" int big = 10000;\n"

"\n"

"unsigned oneTwoThree =123;\n"

"int oneTwo = 12;\n"

" method();\n"

"float k= 2;\n"

"int ll=10000;\n"

"}",

Alignment));

Alignment);

// variables are aligned at their name, pointers are at the right most

// position

verifyFormat("int *a;\n"

"int **b;\n"

"int ***c;\n"

"int foobar;",

Alignment);

// PAS_Left

FormatStyle AlignmentLeft = Alignment;

AlignmentLeft.PointerAlignment = FormatStyle::PAS_Left;

EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"

verifyFormat("void SomeFunction(int parameter = 0) {\n"

" int const i = 1;\n"

" int* j = 2;\n"

" int big = 10000;\n"

"\n"

" unsigned oneTwoThree = 123;\n"

" int oneTwo = 12;\n"

" method();\n"

" float k = 2;\n"

" int ll = 10000;\n"

"}",

format("void SomeFunction(int parameter= 0) {\n"

"void SomeFunction(int parameter= 0) {\n"

" int const i= 1;\n"

" int *j=2;\n"

" int big = 10000;\n"

"\n"

"unsigned oneTwoThree =123;\n"

"int oneTwo = 12;\n"

" method();\n"

"float k= 2;\n"

"int ll=10000;\n"

"}",

AlignmentLeft));

AlignmentLeft);

EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"

verifyFormat("void SomeFunction(int parameter = 0) {\n"

" int const i = 1;\n"

" int** j = 2;\n"

" int& k = i;\n"

" int&& l = i + j;\n"

" int big = 10000;\n"

"\n"

" unsigned oneTwoThree = 123;\n"

" int oneTwo = 12;\n"

" method();\n"

" float k = 2;\n"

" int ll = 10000;\n"

"}",

format("void SomeFunction(int parameter= 0) {\n"

"void SomeFunction(int parameter= 0) {\n"

" int const i= 1;\n"

" int **j=2;\n"

"int &k=i;\n"

"int &&l=i+j;\n"

" int big = 10000;\n"

"\n"

"unsigned oneTwoThree =123;\n"

"int oneTwo = 12;\n"

" method();\n"

"float k= 2;\n"

"int ll=10000;\n"

"}",

AlignmentLeft));

AlignmentLeft);

// variables are aligned at their name, pointers are at the left most position

verifyFormat("int* a;\n"

"int** b;\n"

"int*** c;\n"

"int foobar;",

AlignmentLeft);

// PAS_Middle

FormatStyle AlignmentMiddle = Alignment;

AlignmentMiddle.PointerAlignment = FormatStyle::PAS_Middle;

EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"

verifyFormat("void SomeFunction(int parameter = 0) {\n"

" int const i = 1;\n"

" int * j = 2;\n"

" int big = 10000;\n"

"\n"

" unsigned oneTwoThree = 123;\n"

" int oneTwo = 12;\n"

" method();\n"

" float k = 2;\n"

" int ll = 10000;\n"

"}",

format("void SomeFunction(int parameter= 0) {\n"

"void SomeFunction(int parameter= 0) {\n"

" int const i= 1;\n"

" int *j=2;\n"

" int big = 10000;\n"

"\n"

"unsigned oneTwoThree =123;\n"

"int oneTwo = 12;\n"

" method();\n"

"float k= 2;\n"

"int ll=10000;\n"

"}",

AlignmentMiddle));

AlignmentMiddle);

EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"

verifyFormat("void SomeFunction(int parameter = 0) {\n"

" int const i = 1;\n"

" int ** j = 2, ***k;\n"

" int & k = i;\n"

" int && l = i + j;\n"

" int big = 10000;\n"

"\n"

" unsigned oneTwoThree = 123;\n"

" int oneTwo = 12;\n"

" method();\n"

" float k = 2;\n"

" int ll = 10000;\n"

"}",

format("void SomeFunction(int parameter= 0) {\n"

"void SomeFunction(int parameter= 0) {\n"

" int const i= 1;\n"

" int **j=2,***k;\n"

"int &k=i;\n"

"int &&l=i+j;\n"

" int big = 10000;\n"

"\n"

"unsigned oneTwoThree =123;\n"

"int oneTwo = 12;\n"

" method();\n"

"float k= 2;\n"

"int ll=10000;\n"

"}",

AlignmentMiddle));

AlignmentMiddle);

// variables are aligned at their name, pointers are in the middle

verifyFormat("int * a;\n"

"int * b;\n"

"int *** c;\n"

"int foobar;",

AlignmentMiddle);

Alignment.AlignConsecutiveAssignments.Enabled = false;

▲ Show 20 Lines • Show All 160 Lines • ▼ Show 20 Lines

verifyFormat("int func() { //\n"

" int b;\n"

" unsigned c;\n"

"}",

Alignment);

// See PR37175

FormatStyle Style = getMozillaStyle();

Style.AlignConsecutiveDeclarations.Enabled = true;

EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"

verifyFormat("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"

"foo(int a);",

format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));

"DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style);

Alignment.PointerAlignment = FormatStyle::PAS_Left;

verifyFormat("unsigned int* a;\n"

"int* b;\n"

"unsigned int Const* c;\n"

"unsigned int const* d;\n"

"unsigned int Const& e;\n"

"unsigned int const& f;",

▲ Show 20 Lines • Show All 623 Lines • ▼ Show 20 Lines

verifyFormat("void foobar() { int i = 5; }\n"

"#endif",

StroustrupBraceStyle);

}

TEST_F(FormatTest, AllmanBraceBreaking) {

FormatStyle AllmanBraceStyle = getLLVMStyle();

AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;

EXPECT_EQ("namespace a\n"

verifyFormat("namespace a\n"

"{\n"

"void f();\n"

"void g();\n"

"} // namespace a",

format("namespace a\n"

"namespace a\n"

"{\n"

"void f();\n"

"void g();\n"

"}",

AllmanBraceStyle));

AllmanBraceStyle);

verifyFormat("namespace a\n"

"{\n"

"class A\n"

"{\n"

" void f()\n"

" {\n"

" if (true)\n"

▲ Show 20 Lines • Show All 910 Lines • ▼ Show 20 Lines

verifyFormat("return GradForUnaryCwise(g, {\n"

" {{\"sign\"}, \"Sign\", "

" {\"x\", \"dy\"}},\n"

" { {\"dx\"}, \"Mul\", {\"dy\""

", \"sign\"}},\n"

"});",

Style);

Style.ColumnLimit = 0;

EXPECT_EQ(

verifyFormat(

"test demo[] = {\n"

" {56, 23, \"hello world i am a very long line that really, "

"in any just world, ought to be split over multiple lines\"},\n"

" {-1, 93463, "

" \"world\"},\n"

" { 7, 5, "

" \"!!\"},\n"

"};",

format("test demo[] = {{56, 23, \"hello world i am a very long line "

"test demo[] = {{56, 23, \"hello world i am a very long line "

"that really, in any just world, ought to be split over multiple "

"lines\"},{-1, 93463, \"world\"},{7, 5, \"!!\"},};",

Style));

Style);

Style.ColumnLimit = 80;

verifyFormat("test demo[] = {\n"

" {56, 23, /* a comment */ \"hello\"},\n"

" {-1, 93463, \"world\"},\n"

" { 7, 5, \"!!\"}\n"

"};",

Style);

verifyFormat("test demo[] = {\n"

" {56, 23, \"hello\"},\n"

" {-1, 93463, \"world\" /* comment here */},\n"

" { 7, 5, \"!!\"}\n"

"};",

Style);

verifyFormat("test demo[] = {\n"

" {56, /* a comment */ 23, \"hello\"},\n"

" {-1, 93463, \"world\"},\n"

" { 7, 5, \"!!\"}\n"

"};",

Style);

Style.ColumnLimit = 20;

EXPECT_EQ(

verifyFormat("demo = std::array<\n"

"demo = std::array<\n"

" struct test, 3>{\n"

" test{\n"

" 56, 23,\n"

" \"hello \"\n"

" \"world i \"\n"

" \"am a very \"\n"

" \"long line \"\n"

" \"that \"\n"

" \"really, \"\n"

" \"in any \"\n"

" \"just \"\n"

" \"world, \"\n"

" \"ought to \"\n"

" \"be split \"\n"

" \"over \"\n"

" \"multiple \"\n"

" \"lines\"},\n"

" test{-1, 93463,\n"

" \"world\"},\n"

" test{ 7, 5,\n"

" \"!!\" },\n"

"};",

format("demo = std::array<struct test, 3>{test{56, 23, \"hello world "

"demo = std::array<struct test, 3>{test{56, 23, \"hello world "

"i am a very long line that really, in any just world, ought "

"to be split over multiple lines\"},test{-1, 93463, \"world\"},"

"test{7, 5, \"!!\"},};",

Style));

Style);

// This caused a core dump by enabling Alignment in the LLVMStyle globally

Style = getLLVMStyleWithColumns(50);

Style.AlignArrayOfStructures = FormatStyle::AIAS_Right;

verifyFormat("static A x = {\n"

" {{init1, init2, init3, init4},\n"

" {init1, init2, init3, init4}}\n"

"};",

Style);

// TODO: Fix the indentations below when this option is fully functional.

verifyFormat("int a[][] = {\n"

" {\n"

" {0, 2}, //\n"

" {1, 2} //\n"

" }\n"

"};",

Style);

Style.ColumnLimit = 100;

EXPECT_EQ(

verifyFormat(

"test demo[] = {\n"

" {56, 23,\n"

" \"hello world i am a very long line that really, in any just world"

", ought to be split over \"\n"

" \"multiple lines\" },\n"

" {-1, 93463, \"world\"},\n"

" { 7, 5, \"!!\"},\n"

"};",

format("test demo[] = {{56, 23, \"hello world i am a very long line "

"test demo[] = {{56, 23, \"hello world i am a very long line "

"that really, in any just world, ought to be split over multiple "

"lines\"},{-1, 93463, \"world\"},{7, 5, \"!!\"},};",

Style));

Style);

Style = getLLVMStyleWithColumns(50);

Style.AlignArrayOfStructures = FormatStyle::AIAS_Right;

verifyFormat("struct test demo[] = {\n"

" {56, 23, \"hello\"},\n"

" {-1, 93463, \"world\"},\n"

" { 7, 5, \"!!\"}\n"

"};\n"

Show All 12 Lines

verifyFormat("struct test demo[] = {\n"

"};\n"

"struct test demo[4] = {\n"

" { 56, 23, 21, \"oh\"}, // first line\n"

" { -1, 93463, 22, \"my\"}, // second line\n"

" { 7, 5, 1, \"goodness\"} // third line\n"

" {234, 5, 1, \"gracious\"} // fourth line\n"

"};",

Style);

EXPECT_EQ(

verifyFormat(

"test demo[] = {\n"

" {56,\n"

" \"hello world i am a very long line that really, in any just world"

", ought to be split over \"\n"

" \"multiple lines\", 23},\n"

" {-1, \"world\", 93463},\n"

" { 7, \"!!\", 5},\n"

"};",

format("test demo[] = {{56, \"hello world i am a very long line "

"test demo[] = {{56, \"hello world i am a very long line "

"that really, in any just world, ought to be split over multiple "

"lines\", 23},{-1, \"world\", 93463},{7, \"!!\", 5},};",

Style));

Style);

}

TEST_F(FormatTest, CatchAlignArrayOfStructuresLeftAlignment) {

auto Style = getLLVMStyle();

Style.AlignArrayOfStructures = FormatStyle::AIAS_Left;

/* FIXME: This case gets misformatted.

verifyFormat("auto foo = Items{\n"

" Section{0, bar(), },\n"

▲ Show 20 Lines • Show All 79 Lines • ▼ Show 20 Lines

verifyFormat("return GradForUnaryCwise(g, {\n"

" {{\"sign\"}, \"Sign\", {\"x\", "

"\"dy\"} },\n"

" {{\"dx\"}, \"Mul\", "

"{\"dy\", \"sign\"}},\n"

"});",

Style);

Style.ColumnLimit = 0;

EXPECT_EQ(

verifyFormat(

"test demo[] = {\n"

" {56, 23, \"hello world i am a very long line that really, in any "

"just world, ought to be split over multiple lines\"},\n"

" {-1, 93463, \"world\" "

" },\n"

" {7, 5, \"!!\" "

" },\n"

"};",

format("test demo[] = {{56, 23, \"hello world i am a very long line "

"test demo[] = {{56, 23, \"hello world i am a very long line "

"that really, in any just world, ought to be split over multiple "

"lines\"},{-1, 93463, \"world\"},{7, 5, \"!!\"},};",

Style));

Style);

Style.ColumnLimit = 80;

verifyFormat("test demo[] = {\n"

" {56, 23, /* a comment */ \"hello\"},\n"

" {-1, 93463, \"world\" },\n"

" {7, 5, \"!!\" }\n"

"};",

Style);

verifyFormat("test demo[] = {\n"

" {56, 23, \"hello\" },\n"

" {-1, 93463, \"world\" /* comment here */},\n"

" {7, 5, \"!!\" }\n"

"};",

Style);

verifyFormat("test demo[] = {\n"

" {56, /* a comment */ 23, \"hello\"},\n"

" {-1, 93463, \"world\"},\n"

" {7, 5, \"!!\" }\n"

"};",

Style);

Style.ColumnLimit = 20;

// FIXME: unstable test case

EXPECT_EQ(

"demo = std::array<\n"

" struct test, 3>{\n"

" test{\n"

" 56, 23,\n"

" \"hello \"\n"

" \"world i \"\n"

" \"am a very \"\n"

Show All 23 Lines

TEST_F(FormatTest, CatchAlignArrayOfStructuresLeftAlignment) {

Style = getLLVMStyleWithColumns(50);

Style.AlignArrayOfStructures = FormatStyle::AIAS_Left;

verifyFormat("static A x = {\n"

" {{init1, init2, init3, init4},\n"

" {init1, init2, init3, init4}}\n"

"};",

Style);

Style.ColumnLimit = 100;

EXPECT_EQ(

verifyFormat(

"test demo[] = {\n"

" {56, 23,\n"

" \"hello world i am a very long line that really, in any just world"

", ought to be split over \"\n"

" \"multiple lines\" },\n"

" {-1, 93463, \"world\"},\n"

" {7, 5, \"!!\" },\n"

"};",

format("test demo[] = {{56, 23, \"hello world i am a very long line "

"test demo[] = {{56, 23, \"hello world i am a very long line "

"that really, in any just world, ought to be split over multiple "

"lines\"},{-1, 93463, \"world\"},{7, 5, \"!!\"},};",

Style));

Style);

}

TEST_F(FormatTest, UnderstandsPragmas) {

verifyFormat("#pragma omp reduction(| : var)");

verifyFormat("#pragma omp reduction(+ : var)");

EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "

verifyFormat("#pragma mark Any non-hyphenated or hyphenated string "

"(including parentheses).",

format("#pragma mark Any non-hyphenated or hyphenated string "

"#pragma mark Any non-hyphenated or hyphenated string "

"(including parentheses)."));

"(including parentheses).");

EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "

verifyFormat("#pragma mark Any non-hyphenated or hyphenated string "

"(including parentheses).",

format("#pragma mark Any non-hyphenated or hyphenated string "

"#pragma mark Any non-hyphenated or hyphenated string "

"(including parentheses)."));

"(including parentheses).");

EXPECT_EQ(

"#pragma comment(linker, \\\n"

" \"argument\" \\\n"

" \"argument\"",

format("#pragma comment(linker, \\\n"

" \"argument\" \\\n"

" \"argument\"",

getStyleWithColumns(

getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp), 32)));

}

TEST_F(FormatTest, UnderstandsPragmaOmpTarget) {

verifyFormat("#pragma omp target map(to : var)");

verifyFormat("#pragma omp target map(to : var[ : N])");

verifyFormat("#pragma omp target map(to : var[0 : N])");

verifyFormat("#pragma omp target map(always, to : var[0 : N])");

EXPECT_EQ(

verifyFormat(

"#pragma omp target \\\n"

" reduction(+ : var) \\\n"

" map(to : A[0 : N]) \\\n"

" map(to : B[0 : N]) \\\n"

" map(from : C[0 : N]) \\\n"

" firstprivate(i) \\\n"

" firstprivate(j) \\\n"

" firstprivate(k)",

format(

"#pragma omp target reduction(+:var) map(to:A[0:N]) map(to:B[0:N]) "

"map(from:C[0:N]) firstprivate(i) firstprivate(j) firstprivate(k)",

getLLVMStyleWithColumns(26)));

getLLVMStyleWithColumns(26));

}

TEST_F(FormatTest, UnderstandPragmaOption) {

verifyFormat("#pragma option -C -A");

EXPECT_EQ("#pragma option -C -A", format("#pragma option -C -A"));

verifyFormat("#pragma option -C -A", "#pragma option -C -A");

}

TEST_F(FormatTest, UnderstandPragmaRegion) {

auto Style = getLLVMStyleWithColumns(0);

verifyFormat("#pragma region TEST(FOO : BAR)", Style);

verifyFormat("#pragma region TEST(FOO: NOSPACE)", Style);

}

TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {

FormatStyle Style = getLLVMStyleWithColumns(20);

// See PR41213

EXPECT_EQ("/*\n"

verifyFormat("/*\n"

" *\t9012345\n"

" * /8901\n"

" */",

format("/*\n"

"/*\n"

" *\t9012345 /8901\n"

" */",

Style));

Style);

EXPECT_EQ("/*\n"

verifyFormat("/*\n"

" *345678\n"

" *\t/8901\n"

" */",

format("/*\n"

"/*\n"

" *345678\t/8901\n"

" */",

Style));

Style);

verifyFormat("int a; // the\n"

" // comment",

Style);

EXPECT_EQ("int a; /* first line\n"

verifyNoChange("int a; /* first line\n"

" * second\n"

" * line third\n"

" * line\n"

" */",

format("int a; /* first line\n"

Style);

" * second\n"

verifyFormat("int a; // first line\n"

" * line third\n"

" * line\n"

" */",

Style));

EXPECT_EQ("int a; // first line\n"

" // second\n"

" // line third\n"

" // line",

format("int a; // first line\n"

"int a; // first line\n"

" // second line\n"

" // third line",

Style));

Style);

Style.PenaltyExcessCharacter = 90;

verifyFormat("int a; // the comment", Style);

EXPECT_EQ("int a; // the comment\n"

verifyFormat("int a; // the comment\n"

" // aaa",

format("int a; // the comment aaa", Style));

"int a; // the comment aaa", Style);

EXPECT_EQ("int a; /* first line\n"

verifyNoChange("int a; /* first line\n"

" * second line\n"

" * third line\n"

" */",

format("int a; /* first line\n"

Style);

" * second line\n"

verifyFormat("int a; // first line\n"

" * third line\n"

" */",

Style));

EXPECT_EQ("int a; // first line\n"

" // second line\n"

" // third line",

format("int a; // first line\n"

" // second line\n"

" // third line",

Style));

Style);

// FIXME: Investigate why this is not getting the same layout as the test

// above.

EXPECT_EQ("int a; /* first line\n"

verifyFormat("int a; /* first line\n"

" * second line\n"

" * third line\n"

" */",

format("int a; /* first line second line third line"

"int a; /* first line second line third line"

"\n*/",

Style));

Style);

EXPECT_EQ("// foo bar baz bazfoo\n"

verifyFormat("// foo bar baz bazfoo\n"

"// foo bar foo bar",

format("// foo bar baz bazfoo\n"

"// foo bar baz bazfoo\n"

"// foo bar foo bar",

Style));

Style);

EXPECT_EQ("// foo bar baz bazfoo\n"

verifyFormat("// foo bar baz bazfoo\n"

"// foo bar foo bar",

format("// foo bar baz bazfoo\n"

"// foo bar baz bazfoo\n"

"// foo bar foo bar",

Style));

Style);

// FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the

// next one.

EXPECT_EQ("// foo bar baz bazfoo\n"

verifyFormat("// foo bar baz bazfoo\n"

"// bar foo bar",

format("// foo bar baz bazfoo bar\n"

"// foo bar baz bazfoo bar\n"

"// foo bar",

Style));

Style);

// FIXME: unstable test case

EXPECT_EQ("// foo bar baz bazfoo\n"

"// foo bar baz bazfoo\n"

"// bar foo bar",

format("// foo bar baz bazfoo\n"

"// foo bar baz bazfoo bar\n"

"// foo bar",

Style));

// FIXME: unstable test case

EXPECT_EQ("// foo bar baz bazfoo\n"

"// foo bar baz bazfoo\n"

"// bar foo bar",

format("// foo bar baz bazfoo\n"

"// foo bar baz bazfoo bar\n"

"// foo bar",

Style));

// Make sure we do not keep protruding characters if strict mode reflow is

// cheaper than keeping protruding characters.

Style.ColumnLimit = 21;

EXPECT_EQ(

verifyFormat("// foo foo foo foo\n"

"// foo foo foo foo\n"

"// foo foo foo foo",

format("// foo foo foo foo foo foo foo foo foo foo foo foo", Style));

"// foo foo foo foo foo foo foo foo foo foo foo foo", Style);

EXPECT_EQ("int a = /* long block\n"

verifyFormat("int a = /* long block\n"

" comment */\n"

" 42;",

format("int a = /* long block comment */ 42;", Style));

"int a = /* long block comment */ 42;", Style);

}

TEST_F(FormatTest, BreakPenaltyAfterLParen) {

FormatStyle Style = getLLVMStyle();

Style.ColumnLimit = 8;

Style.PenaltyExcessCharacter = 15;

verifyFormat("int foo(\n"

" int aaaaaaaaaaaaaaaaaaaaaaaa);",

Style);

Style.PenaltyBreakOpenParenthesis = 200;

EXPECT_EQ("int foo(int aaaaaaaaaaaaaaaaaaaaaaaa);",

verifyFormat("int foo(int aaaaaaaaaaaaaaaaaaaaaaaa);",

format("int foo(\n"

"int foo(\n"

" int aaaaaaaaaaaaaaaaaaaaaaaa);",

Style));

Style);

}

TEST_F(FormatTest, BreakPenaltyAfterCastLParen) {

FormatStyle Style = getLLVMStyle();

Style.ColumnLimit = 5;

Style.PenaltyExcessCharacter = 150;

verifyFormat("foo((\n"

" int)aaaaaaaaaaaaaaaaaaaaaaaa);",

Style);

Style.PenaltyBreakOpenParenthesis = 100000;

EXPECT_EQ("foo((int)\n"

verifyFormat("foo((int)\n"

" aaaaaaaaaaaaaaaaaaaaaaaa);",

format("foo((\n"

"foo((\n"

"int)aaaaaaaaaaaaaaaaaaaaaaaa);",

Style));

Style);

}

TEST_F(FormatTest, BreakPenaltyAfterForLoopLParen) {

FormatStyle Style = getLLVMStyle();

Style.ColumnLimit = 4;

Style.PenaltyExcessCharacter = 100;

verifyFormat("for (\n"

" int iiiiiiiiiiiiiiiii =\n"

" 0;\n"

" iiiiiiiiiiiiiiiii <\n"

" 2;\n"

" iiiiiiiiiiiiiiiii++) {\n"

"}",

Style);

Style.PenaltyBreakOpenParenthesis = 1250;

EXPECT_EQ("for (int iiiiiiiiiiiiiiiii =\n"

verifyFormat("for (int iiiiiiiiiiiiiiiii =\n"

" 0;\n"

" iiiiiiiiiiiiiiiii <\n"

" 2;\n"

" iiiiiiiiiiiiiiiii++) {\n"

"}",

format("for (\n"

"for (\n"

" int iiiiiiiiiiiiiiiii =\n"

" 0;\n"

" iiiiiiiiiiiiiiiii <\n"

" 2;\n"

" iiiiiiiiiiiiiiiii++) {\n"

"}",

Style));

Style);

}

TEST_F(FormatTest, WorksFor8bitEncodings) {

// FIXME: unstable test case

EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"

"\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"

"\"\xe7\xe8\xec\xed\xfe\xfe \"\n"

"\"\xef\xee\xf0\xf3...\"",

format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "

"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "

"\xef\xee\xf0\xf3...\"",

getLLVMStyleWithColumns(12)));

Show All 22 Lines

verifyFormat("/* 一二三四五六七八九十 */",

getLLVMStyleWithColumns(35));

}

TEST_F(FormatTest, SplitsUTF8Strings) {

// Non-printable characters' width is currently considered to be the length in

// bytes in UTF8. The characters can be displayed in very different manner

// (zero-width, single width with a substitution glyph, expanded to their code

// (e.g. "<8d>"), so there's no single correct way to handle them.

// FIXME: unstable test case

EXPECT_EQ("\"aaaaÄ\"\n"

"\"\xc2\x8d\";",

format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));

// FIXME: unstable test case

EXPECT_EQ("\"aaaaaaaÄ\"\n"

"\"\xc2\x8d\";",

format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));

// FIXME: unstable test case

EXPECT_EQ("\"Однажды, в \"\n"

"\"студёную \"\n"

"\"зимнюю \"\n"

"\"пору,\"",

format("\"Однажды, в студёную зимнюю пору,\"",

getLLVMStyleWithColumns(13)));

// FIXME: unstable test case

EXPECT_EQ(

"\"一二三 \"\n"

"\"四五六 \"\n"

"\"七八九 \"\n"

"\"十\"",

format("\"一二三四五六七八九十\"", getLLVMStyleWithColumns(11)));

// FIXME: unstable test case

EXPECT_EQ("\"一\t\"\n"

"\"二 \t\"\n"

"\"三四 \"\n"

"\"五\t\"\n"

"\"六 \t\"\n"

"\"七 \"\n"

"\"八九十\tqq\"",

format("\"一\t二 \t三四五\t六 \t七八九十\tqq\"",

getLLVMStyleWithColumns(11)));

// UTF8 character in an escape sequence.

// FIXME: unstable test case

EXPECT_EQ("\"aaaaaa\"\n"

"\"\\\xC2\x8D\"",

format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));

}

TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {

EXPECT_EQ("const char *sssss =\n"

verifyFormat("const char *sssss =\n"

" \"一二三四五六七八\\\n"

" 九十\";",

format("const char *sssss = \"一二三四五六七八\\\n"

"const char *sssss = \"一二三四五六七八\\\n"

" 九十\";",

getLLVMStyleWithColumns(30)));

getLLVMStyleWithColumns(30));

}

TEST_F(FormatTest, SplitsUTF8LineComments) {

verifyFormat("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10));

EXPECT_EQ("// Я из лесу\n"

verifyFormat("// Я из лесу\n"

"// вышел; был\n"

"// сильный\n"

"// мороз.",

format("// Я из лесу вышел; был сильный мороз.",

"// Я из лесу вышел; был сильный мороз.",

getLLVMStyleWithColumns(13)));

getLLVMStyleWithColumns(13));

EXPECT_EQ("// 一二三\n"

verifyFormat("// 一二三\n"

"// 四五六七\n"

"// 八九\n"

"// 十",

format("// 一二三四五六七八九十", getLLVMStyleWithColumns(9)));

"// 一二三四五六七八九十", getLLVMStyleWithColumns(9));

}

TEST_F(FormatTest, SplitsUTF8BlockComments) {

EXPECT_EQ("/* Гляжу,\n"

verifyFormat("/* Гляжу,\n"

" * поднимается\n"

" * медленно в\n"

" * гору\n"

" * Лошадка,\n"

" * везущая\n"

" * хворосту\n"

" * воз. */",

format("/* Гляжу, поднимается медленно в гору\n"

"/* Гляжу, поднимается медленно в гору\n"

" * Лошадка, везущая хворосту воз. */",

getLLVMStyleWithColumns(13)));

getLLVMStyleWithColumns(13));

EXPECT_EQ(

verifyFormat("/* 一二三\n"

"/* 一二三\n"

" * 四五六七\n"

" * 八九\n"

" * 十 */",

format("/* 一二三四五六七八九十 */", getLLVMStyleWithColumns(9)));

"/* 一二三四五六七八九十 */", getLLVMStyleWithColumns(9));

EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"

verifyFormat("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"

" * 𝕓𝕪𝕥𝕖\n"

" * 𝖀𝕿𝕱-𝟠 */",

format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));

"/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12));

}

#endif // _MSC_VER

TEST_F(FormatTest, ConstructorInitializerIndentWidth) {

FormatStyle Style = getLLVMStyle();

Style.ConstructorInitializerIndentWidth = 4;

▲ Show 20 Lines • Show All 229 Lines • ▼ Show 20 Lines

verifyFormat("switch (variable) {\n"

" doSomething();\n"

" break;\n"

"default:\n"

" ++variable;\n"

"}",

Style);

// Wrap before binary operators.

EXPECT_EQ("void f()\n"

verifyFormat(

"void f()\n"

"{\n"

" if (aaaaaaaaaaaaaaaa\n"

" && bbbbbbbbbbbbbbbbbbbbbbbb\n"

" && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"

" return;\n"

"}",

format("void f() {\n"

"void f() {\n"

"if (aaaaaaaaaaaaaaaa\n"

"&& bbbbbbbbbbbbbbbbbbbbbbbb\n"

"&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"

"return;\n"

"}",

Style));

Style);

// Allow functions on a single line.

verifyFormat("void f() { return; }", Style);

// Allow empty blocks on a single line and insert a space in empty blocks.

EXPECT_EQ("void f() { }", format("void f() {}", Style));

verifyFormat("void f() { }", "void f() {}", Style);

EXPECT_EQ("while (true) { }", format("while (true) {}", Style));

verifyFormat("while (true) { }", "while (true) {}", Style);

// However, don't merge non-empty short loops.

EXPECT_EQ("while (true) {\n"

verifyFormat("while (true) {\n"

" continue;\n"

"}",

format("while (true) { continue; }", Style));

"while (true) { continue; }", Style);

// Constructor initializers are formatted one per line with the "," on the

// new line.

verifyFormat("Constructor()\n"

" : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"

" , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"

" aaaaaaaaaaaaaa)\n"

" , aaaaaaaaaaaaaaaaaaaaaaa()\n"

"{\n"

"}",

Style);

verifyFormat("SomeClass::Constructor()\n"

" : a(a)\n"

"{\n"

"}",

Style);

EXPECT_EQ("SomeClass::Constructor()\n"

verifyFormat("SomeClass::Constructor()\n"

" : a(a)\n"

"{\n"

"}",

format("SomeClass::Constructor():a(a){}", Style));

"SomeClass::Constructor():a(a){}", Style);

verifyFormat("SomeClass::Constructor()\n"

" : a(a)\n"

" , b(b)\n"

" , c(c)\n"

"{\n"

"}",

Style);

verifyFormat("SomeClass::Constructor()\n"

Show All 12 Lines

verifyFormat("class C {\n"

Style);

// Do not align comments.

verifyFormat("int a; // Do not\n"

"double b; // align comments.",

Style);

// Do not align operands.

EXPECT_EQ("ASSERT(aaaa\n"

verifyFormat("ASSERT(aaaa\n"

" || bbbb);",

format("ASSERT ( aaaa\n||bbbb);", Style));

"ASSERT ( aaaa\n||bbbb);", Style);

// Accept input's line breaks.

EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"

verifyFormat("if (aaaaaaaaaaaaaaa\n"

" || bbbbbbbbbbbbbbb) {\n"

" i++;\n"

"}",

format("if (aaaaaaaaaaaaaaa\n"

"if (aaaaaaaaaaaaaaa\n"

"|| bbbbbbbbbbbbbbb) { i++; }",

Style));

Style);

EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"

verifyFormat("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"

" i++;\n"

"}",

format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));

"if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style);

// Don't automatically break all macro definitions (llvm.org/PR17842).

verifyFormat("#define aNumber 10", Style);

// However, generally keep the line breaks that the user authored.

EXPECT_EQ("#define aNumber \\\n"

verifyFormat("#define aNumber \\\n"

" 10",

format("#define aNumber \\\n"

"#define aNumber \\\n"

" 10",

Style));

Style);

// Keep empty and one-element array literals on a single line.

EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"

verifyFormat("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"

" copyItems:YES];",

format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"

"NSArray*a=[[NSArray alloc] initWithArray:@[]\n"

"copyItems:YES];",

Style));

Style);

EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"

verifyFormat("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"

" copyItems:YES];",

format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"

"NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"

" copyItems:YES];",

Style));

Style);

// FIXME: This does not seem right, there should be more indentation before

// the array literal's entries. Nested blocks have the same problem.

EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"

verifyFormat("NSArray* a = [[NSArray alloc] initWithArray:@[\n"

" @\"a\",\n"

" @\"a\"\n"

"]\n"

" copyItems:YES];",

format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"

"NSArray* a = [[NSArray alloc] initWithArray:@[\n"

" @\"a\",\n"

" @\"a\"\n"

" ]\n"

" copyItems:YES];",

Style));

Style);

EXPECT_EQ(

verifyFormat(

"NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"

" copyItems:YES];",

format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"

"NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"

" copyItems:YES];",

Style));

Style);

verifyFormat("[self.a b:c c:d];", Style);

EXPECT_EQ("[self.a b:c\n"

verifyFormat("[self.a b:c\n"

" c:d];",

format("[self.a b:c\n"

"[self.a b:c\n"

"c:d];",

Style));

Style);

}

TEST_F(FormatTest, FormatsLambdas) {

verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();");

verifyFormat(

"int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();");

verifyFormat("int c = [&] { [=] { return b++; }(); }();");

verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();");

Show All 23 Lines

verifyFormat(

" x.begin(), x.end(),\n"

" [something, rather](int, int, int, int, int, int, int) {\n"

" //\n"

" });\n"

"}");

verifyFormat("SomeFunction([]() { // A cool function...\n"

" return 43;\n"

"});");

EXPECT_EQ("SomeFunction([]() {\n"

verifyFormat("SomeFunction([]() {\n"

"#define A a\n"

" return 43;\n"

"});",

format("SomeFunction([](){\n"

"SomeFunction([](){\n"

"#define A a\n"

"return 43;\n"

"});"));

"});");

verifyFormat("void f() {\n"

" SomeFunction([](decltype(x), A *a) {});\n"

" SomeFunction([](typeof(x), A *a) {});\n"

" SomeFunction([](_Atomic(x), A *a) {});\n"

" SomeFunction([](__underlying_type(x), A *a) {});\n"

"}");

verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"

" [](const aaaaaaaaaa &a) { return a; });");

▲ Show 20 Lines • Show All 986 Lines • ▼ Show 20 Lines

verifyFormat("[[SessionService sharedService] "

"loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"

" if (window) {\n"

" [self windowDidLoad:window];\n"

" } else {\n"

" [self errorLoadingWindow];\n"

" }\n"

"}];",

ZeroColumn);

EXPECT_EQ("[[SessionService sharedService]\n"

verifyFormat("[[SessionService sharedService]\n"

" loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"

" if (window) {\n"

" [self windowDidLoad:window];\n"

" } else {\n"

" [self errorLoadingWindow];\n"

" }\n"

" }];",

format("[[SessionService sharedService]\n"

"[[SessionService sharedService]\n"

"loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"

" if (window) {\n"

" [self windowDidLoad:window];\n"

" } else {\n"

" [self errorLoadingWindow];\n"

" }\n"

"}];",

ZeroColumn));

ZeroColumn);

verifyFormat("[myObject doSomethingWith:arg1\n"

" firstBlock:^(Foo *a) {\n"

" // ...\n"

" int i;\n"

" }\n"

" secondBlock:^(Bar *b) {\n"

" // ...\n"

" int i;\n"

Show All 12 Lines

verifyFormat("f(^{\n"

"});",

ZeroColumn);

verifyFormat("void (^largeBlock)(void) = ^{\n"

" // ...\n"

"};",

ZeroColumn);

ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;

EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",

verifyFormat("void (^largeBlock)(void) = ^{ int i; };",

format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));

"void (^largeBlock)(void) = ^{ int i; };", ZeroColumn);

ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;

EXPECT_EQ("void (^largeBlock)(void) = ^{\n"

verifyFormat("void (^largeBlock)(void) = ^{\n"

" int i;\n"

"};",

format("void (^largeBlock)(void) = ^{ int i; };", ZeroColumn));

"void (^largeBlock)(void) = ^{ int i; };", ZeroColumn);

}

TEST_F(FormatTest, SupportsCRLF) {

EXPECT_EQ("int a;\r\n"

verifyFormat("int a;\r\n"

"int b;\r\n"

"int c;",

format("int a;\r\n"

"int a;\r\n"

" int b;\r\n"

" int c;"));

" int c;");

EXPECT_EQ("int a;\r\n"

verifyFormat("int a;\r\n"

"int b;\r\n"

"int c;\r\n",

format("int a;\r\n"

"int a;\r\n"

" int b;\n"

" int c;\r\n"));

" int c;\r\n");

EXPECT_EQ("int a;\n"

verifyFormat("int a;\n"

"int b;\n"

"int c;",

format("int a;\r\n"

"int a;\r\n"

" int b;\n"

" int c;"));

" int c;");

// FIXME: unstable test case

EXPECT_EQ("\"aaaaaaa \"\r\n"

"\"bbbbbbb\";\r\n",

format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));

EXPECT_EQ("#define A \\\r\n"

verifyFormat("#define A \\\r\n"

" b; \\\r\n"

" c; \\\r\n"

" d;",

format("#define A \\\r\n"

"#define A \\\r\n"

" b; \\\r\n"

" c; d; ",

getGoogleStyle()));

getGoogleStyle());

EXPECT_EQ("/*\r\n"

verifyNoChange("/*\r\n"

"multi line block comments\r\n"

"should not introduce\r\n"

"an extra carriage return\r\n"

"*/",

"*/");

format("/*\r\n"

verifyFormat("/*\r\n"

"multi line block comments\r\n"

"should not introduce\r\n"

"an extra carriage return\r\n"

"*/"));

EXPECT_EQ("/*\r\n"

"\r\n"

"*/",

format("/*\r\n"

"/*\r\n"

" \r\r\r\n"

"*/"));

"*/");

FormatStyle style = getLLVMStyle();

EXPECT_EQ(style.LineEnding, FormatStyle::LE_DeriveLF);

EXPECT_EQ("union FooBarBazQux {\n"

verifyFormat("union FooBarBazQux {\n"

" int foo;\n"

" int bar;\n"

" int baz;\n"

"};",

format("union FooBarBazQux {\r\n"

"union FooBarBazQux {\r\n"

" int foo;\n"

" int bar;\r\n"

" int baz;\n"

"};",

style));

style);

style.LineEnding = FormatStyle::LE_DeriveCRLF;

EXPECT_EQ("union FooBarBazQux {\r\n"

verifyFormat("union FooBarBazQux {\r\n"

" int foo;\r\n"

" int bar;\r\n"

" int baz;\r\n"

"};",

format("union FooBarBazQux {\r\n"

"union FooBarBazQux {\r\n"

" int foo;\n"

" int bar;\r\n"

" int baz;\n"

"};",

style));

style);

style.LineEnding = FormatStyle::LE_LF;

EXPECT_EQ("union FooBarBazQux {\n"

verifyFormat("union FooBarBazQux {\n"

" int foo;\n"

" int bar;\n"

" int baz;\n"

" int qux;\n"

"};",

format("union FooBarBazQux {\r\n"

"union FooBarBazQux {\r\n"

" int foo;\n"

" int bar;\r\n"

" int baz;\n"

" int qux;\r\n"

"};",

style));

style);

style.LineEnding = FormatStyle::LE_CRLF;

EXPECT_EQ("union FooBarBazQux {\r\n"

verifyFormat("union FooBarBazQux {\r\n"

" int foo;\r\n"

" int bar;\r\n"

" int baz;\r\n"

" int qux;\r\n"

"};",

format("union FooBarBazQux {\r\n"

"union FooBarBazQux {\r\n"

" int foo;\n"

" int bar;\r\n"

" int baz;\n"

" int qux;\n"

"};",

style));

style);

style.LineEnding = FormatStyle::LE_DeriveLF;

EXPECT_EQ("union FooBarBazQux {\r\n"

verifyFormat("union FooBarBazQux {\r\n"

" int foo;\r\n"

" int bar;\r\n"

" int baz;\r\n"

" int qux;\r\n"

"};",

format("union FooBarBazQux {\r\n"

"union FooBarBazQux {\r\n"

" int foo;\n"

" int bar;\r\n"

" int baz;\n"

" int qux;\r\n"

"};",

style));

style);

style.LineEnding = FormatStyle::LE_DeriveCRLF;

EXPECT_EQ("union FooBarBazQux {\n"

verifyFormat("union FooBarBazQux {\n"

" int foo;\n"

" int bar;\n"

" int baz;\n"

" int qux;\n"

"};",

format("union FooBarBazQux {\r\n"

"union FooBarBazQux {\r\n"

" int foo;\n"

" int bar;\r\n"

" int baz;\n"

" int qux;\n"

"};",

style));

style);

}

TEST_F(FormatTest, MunchSemicolonAfterBlocks) {

verifyFormat("MY_CLASS(C) {\n"

" int i;\n"

" int j;\n"

"};");

}

TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {

FormatStyle TwoIndent = getLLVMStyleWithColumns(15);

TwoIndent.ContinuationIndentWidth = 2;

EXPECT_EQ("int i =\n"

verifyFormat("int i =\n"

" longFunction(\n"

" arg);",

format("int i = longFunction(arg);", TwoIndent));

"int i = longFunction(arg);", TwoIndent);

FormatStyle SixIndent = getLLVMStyleWithColumns(20);

SixIndent.ContinuationIndentWidth = 6;

EXPECT_EQ("int i =\n"

verifyFormat("int i =\n"

" longFunction(\n"

" arg);",

format("int i = longFunction(arg);", SixIndent));

"int i = longFunction(arg);", SixIndent);

}

TEST_F(FormatTest, WrappedClosingParenthesisIndent) {

FormatStyle Style = getLLVMStyle();

verifyFormat("int Foo::getter(\n"

" //\n"

") const {\n"

" return foo;\n"

▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, SpaceAfterTemplateKeyword) {

Style.SpaceAfterTemplateKeyword = false;

verifyFormat("template<int> void foo();", Style);

}

TEST_F(FormatTest, TripleAngleBrackets) {

verifyFormat("f<<<1, 1>>>();");

verifyFormat("f<<<1, 1, 1, s>>>();");

verifyFormat("f<<<a, b, c, d>>>();");

EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));

verifyFormat("f<<<1, 1>>>();", "f <<< 1, 1 >>> ();");

verifyFormat("f<param><<<1, 1>>>();");

verifyFormat("f<1><<<1, 1>>>();");

EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));

verifyFormat("f<param><<<1, 1>>>();", "f< param > <<< 1, 1 >>> ();");

verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

"aaaaaaaaaaa<<<\n 1, 1>>>();");

verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"

" <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");

}

TEST_F(FormatTest, MergeLessLessAtEnd) {

verifyFormat("<<");

EXPECT_EQ("< < <", format("\\\n<<<"));

verifyFormat("< < <", "\\\n<<<");

verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

"aaallvm::outs() <<");

verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

"aaaallvm::outs()\n <<");

}

TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {

std::string code = "#if A\n"

"#if B\n"

"a.\n"

"#endif\n"

" a = 1;\n"

"#else\n"

"#endif\n"

"#if C\n"

"#else\n"

"#endif\n";

verifyFormat(code);

}

TEST_F(FormatTest, HandleConflictMarkers) {

// Git/SVN conflict markers.

EXPECT_EQ("int a;\n"

verifyFormat("int a;\n"

"void f() {\n"

" callme(some(parameter1,\n"

"<<<<<<< text by the vcs\n"

" parameter2),\n"

"||||||| text by the vcs\n"

" parameter2),\n"

" parameter3,\n"

"======= text by the vcs\n"

" parameter2, parameter3),\n"

">>>>>>> text by the vcs\n"

" otherparameter);",

format("int a;\n"

"int a;\n"

"void f() {\n"

" callme(some(parameter1,\n"

"<<<<<<< text by the vcs\n"

" parameter2),\n"

"||||||| text by the vcs\n"

" parameter2),\n"

" parameter3,\n"

"======= text by the vcs\n"

" parameter2,\n"

" parameter3),\n"

">>>>>>> text by the vcs\n"

" otherparameter);"));

" otherparameter);");

// Perforce markers.

EXPECT_EQ("void f() {\n"

verifyFormat("void f() {\n"

" function(\n"

">>>> text by the vcs\n"

" parameter,\n"

"==== text by the vcs\n"

" parameter,\n"

"==== text by the vcs\n"

" parameter,\n"

"<<<< text by the vcs\n"

" parameter);",

format("void f() {\n"

"void f() {\n"

" function(\n"

">>>> text by the vcs\n"

" parameter,\n"

"==== text by the vcs\n"

" parameter,\n"

"==== text by the vcs\n"

" parameter,\n"

"<<<< text by the vcs\n"

" parameter);"));

" parameter);");

EXPECT_EQ("<<<<<<<\n"

verifyNoChange("<<<<<<<\n"

"|||||||\n"

"=======\n"

">>>>>>>",

">>>>>>>");

format("<<<<<<<\n"

"|||||||\n"

"=======\n"

">>>>>>>"));

EXPECT_EQ("<<<<<<<\n"

verifyNoChange("<<<<<<<\n"

"|||||||\n"

"int i;\n"

"=======\n"

">>>>>>>",

format("<<<<<<<\n"

"|||||||\n"

"int i;\n"

"=======\n"

">>>>>>>"));

">>>>>>>");

// FIXME: Handle parsing of macros around conflict markers correctly:

EXPECT_EQ("#define Macro \\\n"

verifyFormat("#define Macro \\\n"

"<<<<<<<\n"

"Something \\\n"

"|||||||\n"

"Else \\\n"

"=======\n"

"Other \\\n"

">>>>>>>\n"

" End int i;",

format("#define Macro \\\n"

"#define Macro \\\n"

"<<<<<<<\n"

" Something \\\n"

"|||||||\n"

" Else \\\n"

"=======\n"

" Other \\\n"

">>>>>>>\n"

" End\n"

"int i;"));

"int i;");

verifyFormat(R"(====

#ifdef A

#else

#endif

)");

}

TEST_F(FormatTest, DisableRegions) {

EXPECT_EQ("int i;\n"

verifyFormat("int i;\n"

"// clang-format off\n"

" int j;\n"

"// clang-format on\n"

"int k;",

format(" int i;\n"

" int i;\n"

" // clang-format off\n"

" int j;\n"

" // clang-format on\n"

" int k;"));

" int k;");

EXPECT_EQ("int i;\n"

verifyFormat("int i;\n"

"/* clang-format off */\n"

" int j;\n"

"/* clang-format on */\n"

"int k;",

format(" int i;\n"

" int i;\n"

" /* clang-format off */\n"

" int j;\n"

" /* clang-format on */\n"

" int k;"));

" int k;");

// Don't reflow comments within disabled regions.

EXPECT_EQ("// clang-format off\n"

verifyFormat("// clang-format off\n"

"// long long long long long long line\n"

"/* clang-format on */\n"

"/* long long long\n"

" * long long long\n"

" * line */\n"

"int i;\n"

"/* clang-format off */\n"

"/* long long long long long long line */",

format("// clang-format off\n"

"// clang-format off\n"

"// long long long long long long line\n"

"/* clang-format on */\n"

"/* long long long long long long line */\n"

"int i;\n"

"/* clang-format off */\n"

"/* long long long long long long line */",

getLLVMStyleWithColumns(20)));

getLLVMStyleWithColumns(20));

verifyFormat("int *i;\n"

"// clang-format off:\n"

"int* j;\n"

"// clang-format on: 1\n"

"int *k;",

"int* i;\n"

"// clang-format off:\n"

Show All 27 Lines

TEST_F(FormatTest, FormatsTableGenCode) {

FormatStyle Style = getLLVMStyle();

Style.Language = FormatStyle::LK_TableGen;

verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);

}

TEST_F(FormatTest, ArrayOfTemplates) {

EXPECT_EQ("auto a = new unique_ptr<int>[10];",

verifyFormat("auto a = new unique_ptr<int>[10];",

format("auto a = new unique_ptr<int > [ 10];"));

"auto a = new unique_ptr<int > [ 10];");

FormatStyle Spaces = getLLVMStyle();

Spaces.SpacesInSquareBrackets = true;

EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",

verifyFormat("auto a = new unique_ptr<int>[ 10 ];",

format("auto a = new unique_ptr<int > [10];", Spaces));

"auto a = new unique_ptr<int > [10];", Spaces);

}

TEST_F(FormatTest, ArrayAsTemplateType) {

EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",

verifyFormat("auto a = unique_ptr<Foo<Bar>[10]>;",

format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));

"auto a = unique_ptr < Foo < Bar>[ 10]> ;");

FormatStyle Spaces = getLLVMStyle();

Spaces.SpacesInSquareBrackets = true;

EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",

verifyFormat("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",

format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));

"auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces);

}

TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }

TEST_F(FormatTest, FormatSortsUsingDeclarations) {

EXPECT_EQ("using std::cin;\n"

verifyFormat("using std::cin;\n"

"using std::cout;",

format("using std::cout;\n"

"using std::cout;\n"

"using std::cin;",

getGoogleStyle()));

getGoogleStyle());

}

TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {

FormatStyle Style = getLLVMStyle();

Style.Standard = FormatStyle::LS_Cpp03;

// cpp03 recognize this string as identifier u8 and literal character 'a'

EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));

verifyFormat("auto c = u8 'a';", "auto c = u8'a';", Style);

}

TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {

// u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers

// all modes, including C++11, C++14 and C++17

verifyFormat("auto c = u8'a';");

}

TEST_F(FormatTest, DoNotFormatLikelyXml) {

verifyGoogleFormat("");

verifyNoChange(" ", getGoogleStyle());

}

TEST_F(FormatTest, StructuredBindings) {

// Structured bindings is a C++17 feature.

// all modes, including C++11, C++14 and C++17

verifyFormat("auto [a, b] = f();");

EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));

verifyFormat("auto [a, b] = f();", "auto[a, b] = f();");

EXPECT_EQ("const auto [a, b] = f();", format("const auto[a, b] = f();"));

verifyFormat("const auto [a, b] = f();", "const auto[a, b] = f();");

EXPECT_EQ("auto const [a, b] = f();", format("auto const[a, b] = f();"));

verifyFormat("auto const [a, b] = f();", "auto const[a, b] = f();");

EXPECT_EQ("auto const volatile [a, b] = f();",

verifyFormat("auto const volatile [a, b] = f();",

format("auto const volatile[a, b] = f();"));

"auto const volatile[a, b] = f();");

EXPECT_EQ("auto [a, b, c] = f();", format("auto [ a , b,c ] = f();"));

verifyFormat("auto [a, b, c] = f();", "auto [ a , b,c ] = f();");

EXPECT_EQ("auto &[a, b, c] = f();",

verifyFormat("auto &[a, b, c] = f();", "auto &[ a , b,c ] = f();");

format("auto &[ a , b,c ] = f();"));

verifyFormat("auto &&[a, b, c] = f();", "auto &&[ a , b,c ] = f();");

EXPECT_EQ("auto &&[a, b, c] = f();",

verifyFormat("auto const &[a, b] = f();", "auto const&[a, b] = f();");

format("auto &&[ a , b,c ] = f();"));

verifyFormat("auto const volatile &&[a, b] = f();",

EXPECT_EQ("auto const &[a, b] = f();", format("auto const&[a, b] = f();"));

"auto const volatile &&[a, b] = f();");

EXPECT_EQ("auto const volatile &&[a, b] = f();",

verifyFormat("auto const &&[a, b] = f();", "auto const && [a, b] = f();");

format("auto const volatile &&[a, b] = f();"));

verifyFormat("const auto &[a, b] = f();", "const auto & [a, b] = f();");

EXPECT_EQ("auto const &&[a, b] = f();",

verifyFormat("const auto volatile &&[a, b] = f();",

format("auto const && [a, b] = f();"));

"const auto volatile &&[a, b] = f();");

EXPECT_EQ("const auto &[a, b] = f();",

verifyFormat("volatile const auto &&[a, b] = f();",

format("const auto & [a, b] = f();"));

"volatile const auto &&[a, b] = f();");

EXPECT_EQ("const auto volatile &&[a, b] = f();",

verifyFormat("const auto &&[a, b] = f();", "const auto && [a, b] = f();");

format("const auto volatile &&[a, b] = f();"));

EXPECT_EQ("volatile const auto &&[a, b] = f();",

format("volatile const auto &&[a, b] = f();"));

EXPECT_EQ("const auto &&[a, b] = f();",

format("const auto && [a, b] = f();"));

// Make sure we don't mistake structured bindings for lambdas.

FormatStyle PointerMiddle = getLLVMStyle();

PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;

verifyGoogleFormat("auto [a1, b]{A * i};");

verifyFormat("auto [a2, b]{A * i};");

verifyFormat("auto [a3, b]{A * i};", PointerMiddle);

verifyGoogleFormat("auto const [a1, b]{A * i};");

verifyFormat("auto const [a2, b]{A * i};");

verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);

verifyGoogleFormat("auto const& [a1, b]{A * i};");

verifyFormat("auto const &[a2, b]{A * i};");

verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);

verifyGoogleFormat("auto const&& [a1, b]{A * i};");

verifyFormat("auto const &&[a2, b]{A * i};");

verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);

EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",

verifyFormat("for (const auto &&[a, b] : some_range) {\n}",

format("for (const auto && [a, b] : some_range) {\n}"));

"for (const auto && [a, b] : some_range) {\n}");

EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",

verifyFormat("for (const auto &[a, b] : some_range) {\n}",

format("for (const auto & [a, b] : some_range) {\n}"));

"for (const auto & [a, b] : some_range) {\n}");

EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",

verifyFormat("for (const auto [a, b] : some_range) {\n}",

format("for (const auto[a, b] : some_range) {\n}"));

"for (const auto[a, b] : some_range) {\n}");

EXPECT_EQ("auto [x, y](expr);", format("auto[x,y] (expr);"));

verifyFormat("auto [x, y](expr);", "auto[x,y] (expr);");

EXPECT_EQ("auto &[x, y](expr);", format("auto & [x,y] (expr);"));

verifyFormat("auto &[x, y](expr);", "auto & [x,y] (expr);");

EXPECT_EQ("auto &&[x, y](expr);", format("auto && [x,y] (expr);"));

verifyFormat("auto &&[x, y](expr);", "auto && [x,y] (expr);");

EXPECT_EQ("auto const &[x, y](expr);",

verifyFormat("auto const &[x, y](expr);", "auto const & [x,y] (expr);");

format("auto const & [x,y] (expr);"));

verifyFormat("auto const &&[x, y](expr);", "auto const && [x,y] (expr);");

EXPECT_EQ("auto const &&[x, y](expr);",

verifyFormat("auto [x, y]{expr};", "auto[x,y] {expr};");

format("auto const && [x,y] (expr);"));

verifyFormat("auto const &[x, y]{expr};", "auto const & [x,y] {expr};");

EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y] {expr};"));

verifyFormat("auto const &&[x, y]{expr};", "auto const && [x,y] {expr};");

EXPECT_EQ("auto const &[x, y]{expr};",

format("auto const & [x,y] {expr};"));

EXPECT_EQ("auto const &&[x, y]{expr};",

format("auto const && [x,y] {expr};"));

FormatStyle Spaces = getLLVMStyle();

Spaces.SpacesInSquareBrackets = true;

verifyFormat("auto [ a, b ] = f();", Spaces);

verifyFormat("auto &&[ a, b ] = f();", Spaces);

verifyFormat("auto &[ a, b ] = f();", Spaces);

verifyFormat("auto const &&[ a, b ] = f();", Spaces);

verifyFormat("auto const &[ a, b ] = f();", Spaces);

▲ Show 20 Lines • Show All 542 Lines • ▼ Show 20 Lines

TEST_F(FormatTest, WhitespaceSensitiveMacros) {

// Newlines are important here.

verifyNoChange("FOO(1+2 )\n", Style);

verifyNoChange("FOO(a:b:c)\n", Style);

// Don't use the helpers here, since 'mess up' will change the whitespace

// and these are all whitespace sensitive by definition

verifyNoChange("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style);

EXPECT_EQ(

verifyNoChange("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style);

owenpanAuthorUnsubmitted

Done

verifyNoChange("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style);

- verifyFormat("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style);

+ verifyNoChange("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style);

verifyNoChange("FOO(String-ized&Messy+But,: :Still=Intentional);", Style);

To be consistent with the surrounding test cases. (Will fix it before landing.)

owenpan: To be consistent with the surrounding test cases. (Will fix it before landing.)

"FOO(String-ized&Messy+But\\(: :Still)=Intentional);",

format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));

verifyNoChange("FOO(String-ized&Messy+But,: :Still=Intentional);", Style);

EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"

verifyNoChange("FOO(String-ized&Messy+But,: :\n"

" Still=Intentional);",

format("FOO(String-ized&Messy+But,: :\n"

" Still=Intentional);",

Style));

Style);

Style.AlignConsecutiveAssignments.Enabled = true;

EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"

verifyNoChange("FOO(String-ized=&Messy+But,: :\n"

" Still=Intentional);",

format("FOO(String-ized=&Messy+But,: :\n"

" Still=Intentional);",

Style));

Style);

Style.ColumnLimit = 21;

verifyNoChange("FOO(String-ized&Messy+But: :Still=Intentional);", Style);

}

TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {

// These tests are not in NamespaceEndCommentsFixerTest because that doesn't

// test its interaction with line wrapping

FormatStyle Style = getLLVMStyleWithColumns(80);

verifyFormat("namespace {\n"

"int i;\n"

"int j;\n"

"} // namespace",

Style);

verifyFormat("namespace AAA {\n"

"int i;\n"

"int j;\n"

"} // namespace AAA",

Style);

EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"

verifyFormat("namespace Averyveryveryverylongnamespace {\n"

"int i;\n"

"int j;\n"

"} // namespace Averyveryveryverylongnamespace",

format("namespace Averyveryveryverylongnamespace {\n"

"namespace Averyveryveryverylongnamespace {\n"

"int i;\n"

"int j;\n"

"}",

Style));

Style);

EXPECT_EQ(

verifyFormat(

"namespace "

"would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"

" went::mad::now {\n"

"int i;\n"

"int j;\n"

"} // namespace\n"

" // "

"would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"

"went::mad::now",

format("namespace "

"namespace "

"would::it::save::you::a::lot::of::time::if_::i::"

"just::gave::up::and_::went::mad::now {\n"

"int i;\n"

"int j;\n"

"}",

Style));

Style);

// This used to duplicate the comment again and again on subsequent runs

EXPECT_EQ(

verifyFormat(

"namespace "

"would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"

" went::mad::now {\n"

"int i;\n"

"int j;\n"

"} // namespace\n"

" // "

"would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"

"went::mad::now",

format("namespace "

"namespace "

"would::it::save::you::a::lot::of::time::if_::i::"

"just::gave::up::and_::went::mad::now {\n"

"int i;\n"

"int j;\n"

"} // namespace\n"

" // "

"would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"

"and_::went::mad::now",

Style));

Style);

}

TEST_F(FormatTest, LikelyUnlikely) {

FormatStyle Style = getLLVMStyle();

verifyFormat("if (argc > 5) [[unlikely]] {\n"

" return 29;\n"

"}",

▲ Show 20 Lines • Show All 1,041 Lines • ▼ Show 20 Lines

StringRef Source = "void Foo::slot() {\n"

" unsigned char MyChar = 'x';\n"

" emit signal(MyChar);\n"

" Q_EMIT signal(MyChar);\n"

"}";

verifyFormat(Source, Style);

Style.AlignConsecutiveDeclarations.Enabled = true;

EXPECT_EQ("void Foo::slot() {\n"

verifyFormat("void Foo::slot() {\n"

" unsigned char MyChar = 'x';\n"

" emit signal(MyChar);\n"

" Q_EMIT signal(MyChar);\n"

"}",

format(Source, Style));

Source, Style);

Style.StatementAttributeLikeMacros.push_back("emit");

verifyFormat(Source, Style);

Style.StatementAttributeLikeMacros = {};

EXPECT_EQ("void Foo::slot() {\n"

verifyFormat("void Foo::slot() {\n"

" unsigned char MyChar = 'x';\n"

" emit signal(MyChar);\n"

" Q_EMIT signal(MyChar);\n"

"}",

format(Source, Style));

Source, Style);

}

TEST_F(FormatTest, IndentAccessModifiers) {

FormatStyle Style = getLLVMStyle();

Style.IndentAccessModifiers = true;

// Members are *two* levels below the record;

// Style.IndentWidth == 2, thus yielding a 4 spaces wide indentation.

verifyFormat("class C {\n"

▲ Show 20 Lines • Show All 1,091 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[clang-format][NFC] Change EXPECT_EQ to verifyFormat or verifyNoChangClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 554815

clang/unittests/Format/FormatTest.cpp

[clang-format][NFC] Change EXPECT_EQ to verifyFormat or verifyNoChang
ClosedPublic