[clang-format][NFC] Remove extraneous newlines at end of test cases

[owenpan]

Summary

Removes some 500 newlines (\n and \r\n) at the end of test cases in FormatTest.cpp.

Also changes a few verifyFormat() to verifyNoChange() in tests InsertNewlineAtEOF and WhitespaceSensitiveMacros as messUp() removes trailing newlines as well.

[HazardyKnusperkeks]

clang/unittests/Format/FormatTest.cpp

24187–24188

This.

[owenpan]

Addressed review comments.

[owenpan]

clang/unittests/Format/FormatTest.cpp

24187–24188

Good catch! Though verifyFormat removed the newlines anyways.

clang/unittests/Format/FormatTest.cpp

 namespace format {
 namespace test {
 namespace {
 
 class FormatTest : public test::FormatTestBase {};
 
 TEST_F(FormatTest, MessUp) {
   EXPECT_EQ("1 2 3", messUp("1 2 3"));
-  EXPECT_EQ("1 2 3\n", messUp("1\n2\n3\n"));
+  EXPECT_EQ("1 2 3", messUp("1\n2\n3"));
   EXPECT_EQ("a\n//b\nc", messUp("a\n//b\nc"));
   EXPECT_EQ("a\n#b\nc", messUp("a\n#b\nc"));
   EXPECT_EQ("a\n#b c d\ne", messUp("a\n#b\\\nc\\\nd\ne"));
 }
 
 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) {
   EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language);
 }
EXPECT_EQ("if (a) {\n"
             "  f();\n"
             "}",
             format("if (a) {\n"
                    "  f();\n"
                    "}"));
   EXPECT_EQ(0, ReplacementCount);
   EXPECT_EQ("/*\r\n"
             "\r\n"
-            "*/\r\n",
+            "*/",
             format("/*\r\n"
                    "\r\n"
-                   "*/\r\n"));
+                   "*/"));
   EXPECT_EQ(0, ReplacementCount);
 }
 
 TEST_F(FormatTest, RemovesEmptyLines) {
   EXPECT_EQ("class C {\n"
             "  int i;\n"
             "};",
             format("class C {\n"
TEST_F(FormatTest, RemovesEmptyLines) {
   EXPECT_EQ("namespace a\n"
             "{\n"
             "namespace b\n"
             "{\n"
             "\n"
             "class AA {};\n"
             "\n"
             "} // namespace b\n"
-            "} // namespace a\n",
+            "} // namespace a",
             format("namespace a\n"
                    "{\n"
                    "namespace b\n"
                    "{\n"
                    "\n"
                    "\n"
                    "class AA {};\n"
                    "\n"
                    "\n"
                    "}\n"
-                   "}\n",
+                   "}",
                    CustomStyle));
   EXPECT_EQ("namespace A /* comment */\n"
             "{\n"
             "class B {}\n"
             "} // namespace A",
             format("namespace A /* comment */ { class B {} }", CustomStyle));
   EXPECT_EQ("namespace A\n"
             "{ /* comment */\n"
TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
   verifyFormat("if (a)\n"
                "  ;",
                AllowsMergedIf);
   verifyFormat("if (a)\n"
                "  if (b) return;",
                AllowsMergedIf);
 
   verifyFormat("if (a) // Can't merge this\n"
-               "  f();\n",
+               "  f();",
                AllowsMergedIf);
   verifyFormat("if (a) /* still don't merge */\n"
                "  f();",
                AllowsMergedIf);
   verifyFormat("if (a) { // Never merge this\n"
                "  f();\n"
                "}",
                AllowsMergedIf);
TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
   verifyFormat("MYIF (a)\n"
                "  ;",
                AllowsMergedIf);
   verifyFormat("MYIF (a)\n"
                "  MYIF (b) return;",
                AllowsMergedIf);
 
   verifyFormat("MYIF (a) // Can't merge this\n"
-               "  f();\n",
+               "  f();",
                AllowsMergedIf);
   verifyFormat("MYIF (a) /* still don't merge */\n"
                "  f();",
                AllowsMergedIf);
   verifyFormat("MYIF (a) { // Never merge this\n"
                "  f();\n"
                "}",
                AllowsMergedIf);
verifyFormat("if (a)\n"
                "  f();\n"
                "else {\n"
                "  g();\n"
                "}",
                AllowsMergedIf);
   verifyFormat("if (a)\n"
                "  f();\n"
                "else\n"
-               "  g();\n",
+               "  g();",
                AllowsMergedIf);
 
   verifyFormat("if (a) g();", AllowsMergedIf);
   verifyFormat("if (a) {\n"
                "  g()\n"
                "};",
                AllowsMergedIf);
   verifyFormat("if (a)\n"
verifyFormat("MYIF (a)\n"
                "  f();\n"
                "else {\n"
                "  g();\n"
                "}",
                AllowsMergedIf);
   verifyFormat("MYIF (a)\n"
                "  f();\n"
                "else\n"
-               "  g();\n",
+               "  g();",
                AllowsMergedIf);
 
   verifyFormat("MYIF (a) g();", AllowsMergedIf);
   verifyFormat("MYIF (a) {\n"
                "  g()\n"
                "};",
                AllowsMergedIf);
   verifyFormat("MYIF (a)\n"
TEST_F(FormatTest, UnderstandsMacros) {
   // Test that a macro definition never gets merged with the following
   // definition.
   // FIXME: The AAA macro definition probably should not be split into 3 lines.
   verifyFormat("#define AAA                                                    "
                "                \\\n"
                "  N                                                            "
                "                \\\n"
                "  {\n"
-               "#define BBB }\n",
+               "#define BBB }",
                Style);
-  // verifyFormat("#define AAA N { //\n", Style);
+  // verifyFormat("#define AAA N { //", Style);
 
   verifyFormat("MACRO(return)");
   verifyFormat("MACRO(co_await)");
   verifyFormat("MACRO(co_return)");
   verifyFormat("MACRO(co_yield)");
   verifyFormat("MACRO(return, something)");
   verifyFormat("MACRO(co_return, something)");
   verifyFormat("MACRO(something##something)");
verifyFormat("void f() {\n"
                "  UNKNOWN_FOREACH(Item * item, itemlist) {}\n"
                "}",
                Style);
 
   // As function-like macros.
   verifyFormat("#define foreach(x, y)\n"
                "#define Q_FOREACH(x, y)\n"
                "#define BOOST_FOREACH(x, y)\n"
-               "#define UNKNOWN_FOREACH(x, y)\n");
+               "#define UNKNOWN_FOREACH(x, y)");
 
   // Not as function-like macros.
   verifyFormat("#define foreach (x, y)\n"
                "#define Q_FOREACH (x, y)\n"
                "#define BOOST_FOREACH (x, y)\n"
-               "#define UNKNOWN_FOREACH (x, y)\n");
+               "#define UNKNOWN_FOREACH (x, y)");
 
   // handle microsoft non standard extension
   verifyFormat("for each (char c in x->MyStringProperty)");
 }
 
 TEST_F(FormatTest, FormatsWhileLoop) {
   verifyFormat("while (true) {\n}");
   verifyFormat("while (true)\n"
TEST_F(FormatTest, FormatsSwitchStatement) {
   verifyFormat("#define A          \\\n"
                "  switch (x) {     \\\n"
                "  case a:          \\\n"
                "    foo = b;       \\\n"
                "  }",
                getLLVMStyleWithColumns(20));
   verifyFormat("#define OPERATION_CASE(name)           \\\n"
                "  case OP_name:                        \\\n"
-               "    return operations::Operation##name\n",
+               "    return operations::Operation##name",
                getLLVMStyleWithColumns(40));
   verifyFormat("switch (x) {\n"
                "case 1:;\n"
                "default:;\n"
                "  int i;\n"
                "}");
 
   verifyGoogleFormat("switch (x) {\n"
verifyGoogleFormat("switch (x) {\n"
                      "    break;\n"
                      "  }\n"
                      "}");
   verifyGoogleFormat("switch (test)\n"
                      "  ;");
 
   verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
                      "  case OP_name:              \\\n"
-                     "    return operations::Operation##name\n");
+                     "    return operations::Operation##name");
   verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
                      "  // Get the correction operation class.\n"
                      "  switch (OpCode) {\n"
                      "    CASE(Add);\n"
                      "    CASE(Subtract);\n"
                      "    default:\n"
                      "      return operations::Unknown;\n"
                      "  }\n"
verifyFormat("void f() {\n"
                "}");
   verifyFormat("private[1];");
   verifyFormat("testArray[public] = 1;");
   verifyFormat("public();");
   verifyFormat("myFunc(public);");
   verifyFormat("std::vector<int> testVec = {private};");
   verifyFormat("private.p = 1;");
   verifyFormat("void function(private...){};");
-  verifyFormat("if (private && public)\n");
+  verifyFormat("if (private && public)");
   verifyFormat("private &= true;");
   verifyFormat("int x = private * public;");
   verifyFormat("public *= private;");
   verifyFormat("int x = public + private;");
   verifyFormat("private++;");
   verifyFormat("++private;");
   verifyFormat("public += private;");
   verifyFormat("public = public - private;");
   verifyFormat("public->foo();");
   verifyFormat("private--;");
   verifyFormat("--private;");
   verifyFormat("public -= 1;");
-  verifyFormat("if (!private && !public)\n");
+  verifyFormat("if (!private && !public)");
   verifyFormat("public != private;");
   verifyFormat("int x = public / private;");
   verifyFormat("public /= 2;");
   verifyFormat("public = public % 2;");
   verifyFormat("public %= 2;");
-  verifyFormat("if (public < private)\n");
+  verifyFormat("if (public < private)");
   verifyFormat("public << private;");
   verifyFormat("public <<= private;");
-  verifyFormat("if (public > private)\n");
+  verifyFormat("if (public > private)");
   verifyFormat("public >> private;");
   verifyFormat("public >>= private;");
   verifyFormat("public ^ private;");
   verifyFormat("public ^= private;");
   verifyFormat("public | private;");
   verifyFormat("public |= private;");
   verifyFormat("auto x = private ? 1 : 2;");
-  verifyFormat("if (public == private)\n");
+  verifyFormat("if (public == private)");
   verifyFormat("void foo(public, private)");
   verifyFormat("public::foo();");
 
   verifyFormat("class A {\n"
                "public:\n"
                "  std::unique_ptr<int *[]> b() { return nullptr; }\n"
                "\n"
                "private:\n"
TEST_F(FormatTest, FormatsNamespaces) {
   FormatStyle ShortInlineFunctions = getLLVMStyle();
   ShortInlineFunctions.NamespaceIndentation = FormatStyle::NI_All;
   ShortInlineFunctions.AllowShortFunctionsOnASingleLine =
       FormatStyle::SFS_Inline;
   verifyFormat("namespace {\n"
                "  void f() {\n"
                "    return;\n"
                "  }\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace { /* comment */\n"
                "  void f() {\n"
                "    return;\n"
                "  }\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace { // comment\n"
                "  void f() {\n"
                "    return;\n"
                "  }\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace {\n"
                "  int some_int;\n"
                "  void f() {\n"
                "    return;\n"
                "  }\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace interface {\n"
                "  void f() {\n"
                "    return;\n"
                "  }\n"
-               "} // namespace interface\n",
+               "} // namespace interface",
                ShortInlineFunctions);
   verifyFormat("namespace {\n"
                "  class X {\n"
                "    void f() { return; }\n"
                "  };\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace {\n"
                "  class X { /* comment */\n"
                "    void f() { return; }\n"
                "  };\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace {\n"
                "  class X { // comment\n"
                "    void f() { return; }\n"
                "  };\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace {\n"
                "  struct X {\n"
                "    void f() { return; }\n"
                "  };\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace {\n"
                "  union X {\n"
                "    void f() { return; }\n"
                "  };\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("extern \"C\" {\n"
                "void f() {\n"
                "  return;\n"
                "}\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace {\n"
                "  class X {\n"
                "    void f() { return; }\n"
                "  } x;\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace {\n"
                "  [[nodiscard]] class X {\n"
                "    void f() { return; }\n"
                "  };\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace {\n"
                "  static class X {\n"
                "    void f() { return; }\n"
                "  } x;\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
   verifyFormat("namespace {\n"
                "  constexpr class X {\n"
                "    void f() { return; }\n"
                "  } x;\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
 
   ShortInlineFunctions.IndentExternBlock = FormatStyle::IEBS_Indent;
   verifyFormat("extern \"C\" {\n"
                "  void f() {\n"
                "    return;\n"
                "  }\n"
-               "} // namespace\n",
+               "} // namespace",
                ShortInlineFunctions);
 
   Style.NamespaceIndentation = FormatStyle::NI_Inner;
   EXPECT_EQ("namespace out {\n"
             "int i;\n"
             "namespace in {\n"
             "  int i;\n"
             "} // namespace in\n"
             "} // namespace out",
             format("namespace out {\n"
                    "int i;\n"
                    "namespace in {\n"
                    "int i;\n"
                    "} // namespace in\n"
                    "} // namespace out",
                    Style));
 
   Style.NamespaceIndentation = FormatStyle::NI_None;
   verifyFormat("template <class T>\n"
                "concept a_concept = X<>;\n"
                "namespace B {\n"
                "struct b_struct {};\n"
-               "} // namespace B\n",
+               "} // namespace B",
                Style);
   verifyFormat("template <int I>\n"
                "constexpr void foo()\n"
                "  requires(I == 42)\n"
                "{}\n"
                "namespace ns {\n"
                "void foo() {}\n"
-               "} // namespace ns\n",
+               "} // namespace ns",
                Style);
 }
 
 TEST_F(FormatTest, NamespaceMacros) {
   FormatStyle Style = getLLVMStyle();
   Style.NamespaceMacros.push_back("TESTSUITE");
 
   verifyFormat("TESTSUITE(A) {\n"
EXPECT_EQ("namespace out {\n"
             "int k;\n"
             "} // namespace out",
             format("namespace out { int i;\n"
                    "namespace in { int j; } // namespace in\n"
                    "int k; } // namespace out",
                    Style));
 
   EXPECT_EQ("namespace A { namespace B { namespace C {\n"
-            "}}} // namespace A::B::C\n",
+            "}}} // namespace A::B::C",
             format("namespace A { namespace B {\n"
                    "namespace C {\n"
                    "}} // namespace B::C\n"
-                   "} // namespace A\n",
+                   "} // namespace A",
                    Style));
 
   Style.ColumnLimit = 40;
   EXPECT_EQ("namespace aaaaaaaaaa {\n"
             "namespace bbbbbbbbbb {\n"
             "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
             format("namespace aaaaaaaaaa {\n"
                    "namespace bbbbbbbbbb {\n"
verifyFormat("int f() try { return 4; } catch (...) {\n"
                "  return 5;\n"
                "}");
   verifyFormat("class A {\n"
                "  int a;\n"
                "  A() try : a(0) {\n"
                "  } catch (...) {\n"
                "    throw;\n"
                "  }\n"
-               "};\n");
+               "};");
   verifyFormat("class A {\n"
                "  int a;\n"
                "  A() try : a(0), b{1} {\n"
                "  } catch (...) {\n"
                "    throw;\n"
                "  }\n"
-               "};\n");
+               "};");
   verifyFormat("class A {\n"
                "  int a;\n"
                "  A() try : a(0), b{1}, c{2} {\n"
                "  } catch (...) {\n"
                "    throw;\n"
                "  }\n"
-               "};\n");
+               "};");
   verifyFormat("class A {\n"
                "  int a;\n"
                "  A() try : a(0), b{1}, c{2} {\n"
                "    { // New scope.\n"
                "    }\n"
                "  } catch (...) {\n"
                "    throw;\n"
                "  }\n"
-               "};\n");
+               "};");
 
   // Incomplete try-catch blocks.
   verifyIncompleteFormat("try {} catch (");
 }
 
 TEST_F(FormatTest, FormatTryAsAVariable) {
   verifyFormat("int try;");
   verifyFormat("int try, size;");
verifyFormat("__try {\n"
                "} __finally {\n"
                "  // Do nothing.\n"
                "}");
 
   verifyFormat("DEBUG({\n"
                "  __try {\n"
                "  } __finally {\n"
                "  }\n"
-               "});\n");
+               "});");
 }
 
 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
   verifyFormat("try {\n"
                "  f();\n"
                "} catch {\n"
                "  g();\n"
                "}");
TEST_F(FormatTest, BracedInitializerIndentWidth) {
   Style.BinPackArguments = true;
   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
   Style.BracedInitializerIndentWidth = 6;
 
   // Non-initializing braces are unaffected by BracedInitializerIndentWidth.
   verifyFormat("enum class {\n"
                "  One,\n"
                "  Two,\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("class Foo {\n"
                "  Foo() {}\n"
                "  void bar();\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("void foo() {\n"
                "  auto bar = baz;\n"
                "  return baz;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("auto foo = [&] {\n"
                "  auto bar = baz;\n"
                "  return baz;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("{\n"
                "  auto bar = baz;\n"
                "  return baz;\n"
-               "};\n",
+               "};",
                Style);
   // Non-brace initialization is unaffected by BracedInitializerIndentWidth.
   verifyFormat("SomeClass clazz(\n"
                "    \"xxxxxxxxxxxxxxxxxx\", \"yyyyyyyyyyyyyyyyyy\",\n"
-               "    \"zzzzzzzzzzzzzzzzzz\");\n",
+               "    \"zzzzzzzzzzzzzzzzzz\");",
                Style);
 
   // The following types of initialization are all affected by
   // BracedInitializerIndentWidth. Aggregate initialization.
   verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n"
                "      10000000, 20000000};",
                Style);
   verifyFormat("SomeStruct s{\n"
                "      \"xxxxxxxxxxxxxxxx\", \"yyyyyyyyyyyyyyyy\",\n"
-               "      \"zzzzzzzzzzzzzzzz\"};\n",
+               "      \"zzzzzzzzzzzzzzzz\"};",
                Style);
   // Designated initializers.
   verifyFormat("int LooooooooooooooooooooooooongVariable[2] = {\n"
                "      [0] = 10000000, [1] = 20000000};",
                Style);
   verifyFormat("SomeStruct s{\n"
                "      .foo = \"xxxxxxxxxxxxx\",\n"
                "      .bar = \"yyyyyyyyyyyyy\",\n"
-               "      .baz = \"zzzzzzzzzzzzz\"};\n",
+               "      .baz = \"zzzzzzzzzzzzz\"};",
                Style);
   // List initialization.
   verifyFormat("SomeStruct s{\n"
                "      \"xxxxxxxxxxxxx\",\n"
                "      \"yyyyyyyyyyyyy\",\n"
                "      \"zzzzzzzzzzzzz\",\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("SomeStruct{\n"
                "      \"xxxxxxxxxxxxx\",\n"
                "      \"yyyyyyyyyyyyy\",\n"
                "      \"zzzzzzzzzzzzz\",\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("new SomeStruct{\n"
                "      \"xxxxxxxxxxxxx\",\n"
                "      \"yyyyyyyyyyyyy\",\n"
                "      \"zzzzzzzzzzzzz\",\n"
-               "};\n",
+               "};",
                Style);
   // Member initializer.
   verifyFormat("class SomeClass {\n"
                "  SomeStruct s{\n"
                "        \"xxxxxxxxxxxxx\",\n"
                "        \"yyyyyyyyyyyyy\",\n"
                "        \"zzzzzzzzzzzzz\",\n"
                "  };\n"
-               "};\n",
+               "};",
                Style);
   // Constructor member initializer.
   verifyFormat("SomeClass::SomeClass : strct{\n"
                "                             \"xxxxxxxxxxxxx\",\n"
                "                             \"yyyyyyyyyyyyy\",\n"
                "                             \"zzzzzzzzzzzzz\",\n"
-               "                       } {}\n",
+               "                       } {}",
                Style);
   // Copy initialization.
   verifyFormat("SomeStruct s = SomeStruct{\n"
                "      \"xxxxxxxxxxxxx\",\n"
                "      \"yyyyyyyyyyyyy\",\n"
                "      \"zzzzzzzzzzzzz\",\n"
-               "};\n",
+               "};",
                Style);
   // Copy list initialization.
   verifyFormat("SomeStruct s = {\n"
                "      \"xxxxxxxxxxxxx\",\n"
                "      \"yyyyyyyyyyyyy\",\n"
                "      \"zzzzzzzzzzzzz\",\n"
-               "};\n",
+               "};",
                Style);
   // Assignment operand initialization.
   verifyFormat("s = {\n"
                "      \"xxxxxxxxxxxxx\",\n"
                "      \"yyyyyyyyyyyyy\",\n"
                "      \"zzzzzzzzzzzzz\",\n"
-               "};\n",
+               "};",
                Style);
   // Returned object initialization.
   verifyFormat("return {\n"
                "      \"xxxxxxxxxxxxx\",\n"
                "      \"yyyyyyyyyyyyy\",\n"
                "      \"zzzzzzzzzzzzz\",\n"
-               "};\n",
+               "};",
                Style);
   // Initializer list.
   verifyFormat("auto initializerList = {\n"
                "      \"xxxxxxxxxxxxx\",\n"
                "      \"yyyyyyyyyyyyy\",\n"
                "      \"zzzzzzzzzzzzz\",\n"
-               "};\n",
+               "};",
                Style);
   // Function parameter initialization.
   verifyFormat("func({\n"
                "      \"xxxxxxxxxxxxx\",\n"
                "      \"yyyyyyyyyyyyy\",\n"
                "      \"zzzzzzzzzzzzz\",\n"
-               "});\n",
+               "});",
                Style);
   // Nested init lists.
   verifyFormat("SomeStruct s = {\n"
                "      {{init1, init2, init3, init4, init5},\n"
-               "       {init1, init2, init3, init4, init5}}};\n",
+               "       {init1, init2, init3, init4, init5}}};",
                Style);
   verifyFormat("SomeStruct s = {\n"
                "      {{\n"
                "             .init1 = 1,\n"
                "             .init2 = 2,\n"
                "             .init3 = 3,\n"
                "             .init4 = 4,\n"
                "             .init5 = 5,\n"
                "       },\n"
-               "       {init1, init2, init3, init4, init5}}};\n",
+               "       {init1, init2, init3, init4, init5}}};",
                Style);
   verifyFormat("SomeArrayT a[3] = {\n"
                "      {\n"
                "            foo,\n"
                "            bar,\n"
                "      },\n"
                "      {\n"
                "            foo,\n"
verifyFormat("SomeArrayT a[3] = {\n"
                "      },\n"
                "      {baz},\n"
                "};",
                Style);
 
   // Aligning after open braces unaffected by BracedInitializerIndentWidth.
   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
   verifyFormat("SomeStruct s{\"xxxxxxxxxxxxx\", \"yyyyyyyyyyyyy\",\n"
-               "             \"zzzzzzzzzzzzz\"};\n",
+               "             \"zzzzzzzzzzzzz\"};",
                Style);
 }
 
 TEST_F(FormatTest, NestedStaticInitializers) {
-  verifyFormat("static A x = {{{}}};\n");
+  verifyFormat("static A x = {{{}}};");
   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
                "               {init1, init2, init3, init4}}};",
                getLLVMStyleWithColumns(50));
 
   verifyFormat("somes Status::global_reps[3] = {\n"
                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",

 }
 
 TEST_F(FormatTest, LayoutUnknownPPDirective) {
   verifyFormat("#;");
   verifyFormat("#\n;\n;\n;");
 }
 
 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
-  EXPECT_EQ("#line 42 \"test\"\n",
-            format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
-  EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
-                                    getLLVMStyleWithColumns(12)));
+  EXPECT_EQ("#line 42 \"test\"",
+            format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
+  EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B",
 }
 
 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
   EXPECT_EQ("#line 42 \"test\"",
             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
 }
 
TEST_F(FormatTest, IndentsPPDirectiveWithPPIndentWidth) {
   verifyFormat("#ifdef __linux__\n"
                "void foo() {\n"
                "    int x = 0;\n"
                "}\n"
                "#define FOO\n"
                "#endif\n"
                "void bar() {\n"
                "    int y = 0;\n"
-               "}\n",
+               "}",
                style);
 
   style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
   verifyFormat("#ifdef __linux__\n"
                "void foo() {\n"
                "    int x = 0;\n"
                "}\n"
                "# define FOO foo\n"
                "#endif\n"
                "void bar() {\n"
                "    int y = 0;\n"
-               "}\n",
+               "}",
                style);
 
   style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
   verifyFormat("#ifdef __linux__\n"
                "void foo() {\n"
                "    int x = 0;\n"
                "}\n"
                " #define FOO foo\n"
                "#endif\n"
                "void bar() {\n"
                "    int y = 0;\n"
-               "}\n",
+               "}",
                style);
   verifyFormat("#if 1\n"
                " // some comments\n"
                " // another\n"
                " #define foo 1\n"
                "// not a define comment\n"
                "void bar() {\n"
                "    // comment\n"

 }
 
 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
   EXPECT_EQ("// somecomment\n"
             "#include \"a.h\"\n"
             "#define A(  \\\n"
             "    A, B)\n"
             "#include \"b.h\"\n"
-            "// somecomment\n",
+            "// somecomment",
             format("  // somecomment\n"
                    "  #include \"a.h\"\n"
                    "#define A(A,\\\n"
                    "    B)\n"
                    "    #include \"b.h\"\n"
-                   " // somecomment\n",
+                   " // somecomment",
                    getLLVMStyleWithColumns(13)));
 }
 
 TEST_F(FormatTest, LayoutSingleHash) { verifyFormat("#\na;"); }
 
 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
   EXPECT_EQ("#define A    \\\n"
             "  c;         \\\n"
EXPECT_EQ("#define A \\\n"
                    "  b;",
                    getLLVMStyleWithColumns(11)));
 }
 
 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
   verifyIncompleteFormat("#define A :");
   verifyFormat("#define SOMECASES  \\\n"
                "  case 1:          \\\n"
-               "  case 2\n",
+               "  case 2",
                getLLVMStyleWithColumns(20));
   verifyFormat("#define MACRO(a) \\\n"
                "  if (a)         \\\n"
                "    f();         \\\n"
                "  else           \\\n"
                "    g()",
                getLLVMStyleWithColumns(18));
   verifyFormat("#define A template <typename T>");
EXPECT_EQ("class A : public QObject {\n"
                    "}  ;"));
 
   // Only if the next line can actually start an unwrapped line.
   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
             format("SOME_WEIRD_LOG_MACRO\n"
                    "<< SomeThing;"));
 
   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
-               "(n, buffers))\n",
+               "(n, buffers))",
                getChromiumStyle(FormatStyle::LK_Cpp));
 
   // See PR41483
   EXPECT_EQ("/**/ FOO(a)\n"
             "FOO(b)",
             format("/**/ FOO(a)\n"
                    "FOO(b)"));
 }
EXPECT_EQ("int q() {\n"
             "  f(x) &= x;\n"
             "  f(x) |= x;\n"
             "  f(x) ^= x;\n"
             "  f(x) >>= x;\n"
             "  f(x) <<= x;\n"
             "  f(x)[y].z();\n"
             "  LOG(INFO) << x;\n"
             "  ifstream(x) >> x;\n"
-            "}\n",
+            "}",
             format("int q() {\n"
                    "  f(x)\n;\n"
                    "  f(x)\n {}\n"
                    "  f(x)\n->g();\n"
                    "  f(x)\n->*g();\n"
                    "  f(x)\n.g();\n"
                    "  f(x)\n = x;\n"
                    "  f(x)\n += x;\n"
                    "  f(x)\n -= x;\n"
                    "  f(x)\n *= x;\n"
                    "  f(x)\n /= x;\n"
                    "  f(x)\n %= x;\n"
                    "  f(x)\n &= x;\n"
                    "  f(x)\n |= x;\n"
                    "  f(x)\n ^= x;\n"
                    "  f(x)\n >>= x;\n"
                    "  f(x)\n <<= x;\n"
                    "  f(x)\n[y].z();\n"
                    "  LOG(INFO)\n << x;\n"
                    "  ifstream(x)\n >> x;\n"
-                   "}\n"));
+                   "}"));
   EXPECT_EQ("int q() {\n"
             "  F(x)\n"
             "  if (1) {\n"
             "  }\n"
             "  F(x)\n"
             "  while (1) {\n"
             "  }\n"
             "  F(x)\n"
             "  G(x);\n"
             "  F(x)\n"
             "  try {\n"
             "    Q();\n"
             "  } catch (...) {\n"
             "  }\n"
-            "}\n",
+            "}",
             format("int q() {\n"
                    "F(x)\n"
                    "if (1) {}\n"
                    "F(x)\n"
                    "while (1) {}\n"
                    "F(x)\n"
                    "G(x);\n"
                    "F(x)\n"
                    "try { Q(); } catch (...) {}\n"
-                   "}\n"));
+                   "}"));
   EXPECT_EQ("class A {\n"
             "  A() : t(0) {}\n"
             "  A(int i) noexcept() : {}\n"
             "  A(X x)\n" // FIXME: function-level try blocks are broken.
             "  try : t(0) {\n"
             "  } catch (...) {\n"
             "  }\n"
             "};",
verifyFormat("#ifndef NOT_GUARD\n"
                "code();\n"
                "#endif\n"
                "code();",
                Style);
   // Test with trailing blank lines.
   verifyFormat("#ifndef HEADER_H\n"
                "#define HEADER_H\n"
                "code();\n"
-               "#endif\n",
+               "#endif",
                Style);
   // Include guards don't have #else.
   verifyFormat("#ifndef NOT_GUARD\n"
                "#  define NOT_GUARD\n"
                "code();\n"
                "#else\n"
                "#endif",
                Style);
   verifyFormat("#ifndef NOT_GUARD\n"
                "#  define NOT_GUARD\n"
                "code();\n"
                "#elif FOO\n"
                "#endif",
                Style);
   // Non-identifier #define after potential include guard.
   verifyFormat("#ifndef FOO\n"
                "#  define 1\n"
-               "#endif\n",
+               "#endif",
                Style);
   // #if closes past last non-preprocessor line.
   verifyFormat("#ifndef FOO\n"
                "#define FOO\n"
                "#if 1\n"
                "int i;\n"
                "#  define A 0\n"
                "#endif\n"
-               "#endif\n",
+               "#endif",
                Style);
   // Don't crash if there is an #elif directive without a condition.
   verifyFormat("#if 1\n"
                "int x;\n"
                "#elif\n"
                "int y;\n"
                "#else\n"
                "int z;\n"
TEST_F(FormatTest, EscapedNewlines) {
   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
   verifyNoChange("<a\n\\\\\n>");
 
   FormatStyle AlignLeft = getLLVMStyle();
   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
   EXPECT_EQ("#define MACRO(x) \\\n"
             "private:         \\\n"
-            "  int x(int a);\n",
+            "  int x(int a);",
             format("#define MACRO(x) \\\n"
                    "private:         \\\n"
-                   "  int x(int a);\n",
+                   "  int x(int a);",
                    AlignLeft));
 
   // CRLF line endings
   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
             format("#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;"));
   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
   verifyNoChange("<a\r\n\\\\\r\n>");
   EXPECT_EQ("#define MACRO(x) \\\r\n"
             "private:         \\\r\n"
-            "  int x(int a);\r\n",
+            "  int x(int a);",
             format("#define MACRO(x) \\\r\n"
                    "private:         \\\r\n"
-                   "  int x(int a);\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"

 
 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
   EXPECT_EQ(
       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
       "                      \\\n"
       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
       "\n"
       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
-      "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
+      "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);",
       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
              "\\\n"
              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
              "  \n"
              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
-             "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
+             "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);"));
 }
 
 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
   EXPECT_EQ("int\n"
             "#define A\n"
             "    a;",
             format("int\n#define A\na;"));
   verifyFormat("functionCallTo(\n"
verifyFormat("void f(param1, param2,\n"
                "}",
                getLLVMStyleWithColumns(28));
   verifyFormat("#if 1\n"
                "int i;");
   verifyFormat("#if 1\n"
                "#endif\n"
                "#if 1\n"
                "#else\n"
-               "#endif\n");
+               "#endif");
   verifyFormat("DEBUG({\n"
                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
                "});\n"
                "#if a\n"
                "#else\n"
                "#endif");
 
verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                Style);
 
   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
                "    + cc;",
                Style);
   verifyFormat("int a = aa\n"
                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
-               "        * cccccccccccccccccccccccccccccccccccc;\n",
+               "        * cccccccccccccccccccccccccccccccccccc;",
                Style);
 
   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
   verifyFormat("return (a > b\n"
                "    // comment1\n"
                "    // comment2\n"
                "    || c);",
                Style);
EXPECT_EQ("const aaaa::bbbbbbb &\n"
             "  stuff();\n"
             "}",
             format("const aaaa::bbbbbbb\n"
                    "&ccccccccc::operator++() { stuff(); }",
                    getLLVMStyleWithColumns(40)));
 }
 
 TEST_F(FormatTest, TrailingReturnType) {
-  verifyFormat("auto foo() -> int;\n");
+  verifyFormat("auto foo() -> int;");
   // correct trailing return type spacing
-  verifyFormat("auto operator->() -> int;\n");
-  verifyFormat("auto operator++(int) -> int;\n");
+  verifyFormat("auto operator->() -> int;");
+  verifyFormat("auto operator++(int) -> int;");
 
   verifyFormat("struct S {\n"
                "  auto bar() const -> int;\n"
                "};");
   verifyFormat("template <size_t Order, typename T>\n"
                "auto load_img(const std::string &filename)\n"
                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"

 
 TEST_F(FormatTest, FormatsBuilderPattern) {
   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
                "    .StartsWith(\".init\", ORDER_INIT)\n"
                "    .StartsWith(\".fini\", ORDER_FINI)\n"
                "    .StartsWith(\".hash\", ORDER_HASH)\n"
-               "    .Default(ORDER_TEXT);\n");
+               "    .Default(ORDER_TEXT);");
 
   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
   verifyFormat("aaaaaaa->aaaaaaa\n"
                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
   verifyFormat(
verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
                "    aaaaaaaaaaaaaaa != aa) {\n}");
 }
 
 TEST_F(FormatTest, BreaksAfterAssignments) {
   verifyFormat(
       "unsigned Cost =\n"
       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
-      "                        SI->getPointerAddressSpaceee());\n");
+      "                        SI->getPointerAddressSpaceee());");
   verifyFormat(
       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
 
   verifyFormat(
       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
   verifyFormat("unsigned OriginalStartColumn =\n"
verifyFormat("return a != b\n"
                "           ? a = b\n"
                "           : a = b;");
   verifyFormat("return a != b\n"
                "           // comment\n"
                "           ? a = a != b\n"
                "                     // comment\n"
                "                     ? a = b\n"
                "                     : a\n"
-               "           : a;\n");
+               "           : a;");
   verifyFormat("return a != b\n"
                "           // comment\n"
                "           ? a\n"
                "           : a = a != b\n"
                "                     // comment\n"
                "                     ? a = b\n"
                "                     : a;");
 
verifyFormat(
       "                                             : dddddddddddddddddd)\n"
       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
       "                        : 3333333333333333;",
       Style);
   verifyFormat(
       "return aaaaaaaaa        ? 1111111111111111\n"
       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
-      "                                             : dddddddddddddddddd)\n",
+      "                                             : dddddddddddddddddd)",
       Style);
   verifyFormat(
       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
       "                                             : cccccccccccccccccc);",
       Style);
   verifyFormat(
TEST_F(FormatTest, BreaksConditionalExpressions) {
   Style.AlignOperands = FormatStyle::OAS_DontAlign;
   Style.BreakBeforeTernaryOperators = false;
   // FIXME: Aligning the question marks is weird given DontAlign.
   // Consider disabling this alignment in this case. Also check whether this
   // will render the adjustment from https://reviews.llvm.org/D82199
   // unnecessary.
   verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
                "    bbbb                ? cccccccccccccccccc :\n"
-               "                          ddddd;\n",
+               "                          ddddd;",
                Style);
 
   EXPECT_EQ(
       "MMMMMMMMMMMMMMMMMMMMMMMMMMM = A ?\n"
       "    /*\n"
       "     */\n"
       "    function() {\n"
       "      try {\n"
verifyFormat(
       "                                               dddddddddddddddddd) :\n"
       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
       "                          3333333333333333;",
       Style);
   verifyFormat(
       "return aaaaaaaaa        ? 1111111111111111 :\n"
       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
-      "                                               dddddddddddddddddd)\n",
+      "                                               dddddddddddddddddd)",
       Style);
   verifyFormat(
       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
       "                                               cccccccccccccccccc);",
       Style);
   verifyFormat(
TEST_F(FormatTest, ReturnTypeBreakingStyle) {
   FormatStyle Style = getLLVMStyle();
   // No declarations or definitions should be moved to own line.
   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
   verifyFormat("class A {\n"
                "  int f() { return 1; }\n"
                "  int g();\n"
                "};\n"
                "int f() { return 1; }\n"
-               "int g();\n",
+               "int g();",
                Style);
 
   // All declarations and definitions should have the return type moved to its
   // own line.
   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
   Style.TypenameMacros = {"LIST"};
   verifyFormat("SomeType\n"
                "funcdecl(LIST(uint64_t));",
                Style);
   verifyFormat("class E {\n"
                "  int\n"
                "  f() {\n"
                "    return 1;\n"
                "  }\n"
                "  int\n"
                "  g();\n"
                "};\n"
                "int\n"
                "f() {\n"
                "  return 1;\n"
                "}\n"
                "int\n"
-               "g();\n",
+               "g();",
                Style);
 
   // Top-level definitions, and no kinds of declarations should have the
   // return type moved to its own line.
   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
   verifyFormat("class B {\n"
                "  int f() { return 1; }\n"
                "  int g();\n"
                "};\n"
                "int\n"
                "f() {\n"
                "  return 1;\n"
                "}\n"
-               "int g();\n",
+               "int g();",
                Style);
 
   // Top-level definitions and declarations should have the return type moved
   // to its own line.
   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
   verifyFormat("class C {\n"
                "  int f() { return 1; }\n"
                "  int g();\n"
                "};\n"
                "int\n"
                "f() {\n"
                "  return 1;\n"
                "}\n"
                "int\n"
-               "g();\n",
+               "g();",
                Style);
 
   // All definitions should have the return type moved to its own line, but no
   // kinds of declarations.
   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
   verifyFormat("class D {\n"
                "  int\n"
                "  f() {\n"
                "    return 1;\n"
                "  }\n"
                "  int g();\n"
                "};\n"
                "int\n"
                "f() {\n"
                "  return 1;\n"
                "}\n"
-               "int g();\n",
+               "int g();",
                Style);
   verifyFormat("const char *\n"
                "f(void) {\n" // Break here.
                "  return \"\";\n"
                "}\n"
-               "const char *bar(void);\n", // No break here.
+               "const char *bar(void);", // No break here.
                Style);
   verifyFormat("template <class T>\n"
                "T *\n"
                "f(T &c) {\n" // Break here.
                "  return NULL;\n"
                "}\n"
-               "template <class T> T *f(T &c);\n", // No break here.
+               "template <class T> T *f(T &c);", // No break here.
                Style);
   verifyFormat("class C {\n"
                "  int\n"
                "  operator+() {\n"
                "    return 1;\n"
                "  }\n"
                "  int\n"
                "  operator()() {\n"
                "    return 1;\n"
                "  }\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("void\n"
                "A::operator()() {}\n"
                "void\n"
                "A::operator>>() {}\n"
                "void\n"
                "A::operator+() {}\n"
                "void\n"
verifyFormat("void\n"
                "A::operator**() {}\n"
                "void\n"
                "A::operator<Foo> *() {}\n"
                "void\n"
                "A::operator<Foo> **() {}\n"
                "void\n"
                "A::operator<Foo> &() {}\n"
                "void\n"
-               "A::operator void **() {}\n",
+               "A::operator void **() {}",
                Style);
   verifyFormat("constexpr auto\n"
                "operator()() const -> reference {}\n"
                "constexpr auto\n"
                "operator>>() const -> reference {}\n"
                "constexpr auto\n"
                "operator+() const -> reference {}\n"
                "constexpr auto\n"
verifyFormat("constexpr auto\n"
                "operator void &() const -> reference {}\n"
                "constexpr auto\n"
                "operator void &&() const -> reference {}\n"
                "constexpr auto\n"
                "operator char *() const -> reference {}\n"
                "constexpr auto\n"
                "operator!() const -> reference {}\n"
                "constexpr auto\n"
-               "operator[]() const -> reference {}\n",
+               "operator[]() const -> reference {}",
                Style);
   verifyFormat("void *operator new(std::size_t s);", // No break here.
                Style);
   verifyFormat("void *\n"
                "operator new(std::size_t s) {}",
                Style);
   verifyFormat("void *\n"
                "operator delete[](void *ptr) {}",
                Style);
   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
   verifyFormat("const char *\n"
                "f(void)\n" // Break here.
                "{\n"
                "  return \"\";\n"
                "}\n"
-               "const char *bar(void);\n", // No break here.
+               "const char *bar(void);", // No break here.
                Style);
   verifyFormat("template <class T>\n"
                "T *\n"     // Problem here: no line break
                "f(T &c)\n" // Break here.
                "{\n"
                "  return NULL;\n"
                "}\n"
-               "template <class T> T *f(T &c);\n", // No break here.
+               "template <class T> T *f(T &c);", // No break here.
                Style);
   verifyFormat("int\n"
                "foo(A<bool> a)\n"
                "{\n"
                "  return a;\n"
-               "}\n",
+               "}",
                Style);
   verifyFormat("int\n"
                "foo(A<8> a)\n"
                "{\n"
                "  return a;\n"
-               "}\n",
+               "}",
                Style);
   verifyFormat("int\n"
                "foo(A<B<bool>, 8> a)\n"
                "{\n"
                "  return a;\n"
-               "}\n",
+               "}",
                Style);
   verifyFormat("int\n"
                "foo(A<B<8>, bool> a)\n"
                "{\n"
                "  return a;\n"
-               "}\n",
+               "}",
                Style);
   verifyFormat("int\n"
                "foo(A<B<bool>, bool> a)\n"
                "{\n"
                "  return a;\n"
-               "}\n",
+               "}",
                Style);
   verifyFormat("int\n"
                "foo(A<B<8>, 8> a)\n"
                "{\n"
                "  return a;\n"
-               "}\n",
+               "}",
                Style);
 
   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
   Style.BraceWrapping.AfterFunction = true;
   verifyFormat("int f(i);\n" // No break here.
                "int\n"       // Break here.
                "f(i)\n"
                "{\n"
TEST_F(FormatTest, ReturnTypeBreakingStyle) {
   verifyGoogleFormat("typedef ATTR(X) char x;");
 
   Style = getGNUStyle();
 
   // Test for comments at the end of function declarations.
   verifyFormat("void\n"
                "foo (int a, /*abc*/ int b) // def\n"
                "{\n"
-               "}\n",
+               "}",
                Style);
 
   verifyFormat("void\n"
                "foo (int a, /* abc */ int b) /* def */\n"
                "{\n"
-               "}\n",
+               "}",
                Style);
 
   // Definitions that should not break after return type
-  verifyFormat("void foo (int a, int b); // def\n", Style);
-  verifyFormat("void foo (int a, int b); /* def */\n", Style);
-  verifyFormat("void foo (int a, int b);\n", Style);
+  verifyFormat("void foo (int a, int b); // def", Style);
+  verifyFormat("void foo (int a, int b); /* def */", Style);
+  verifyFormat("void foo (int a, int b);", Style);
 }
 
 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
   FormatStyle NoBreak = getLLVMStyle();
   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
   FormatStyle Break = getLLVMStyle();
   Break.AlwaysBreakBeforeMultilineStrings = true;
   verifyFormat("aaaa = \"bbbb\"\n"
verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "}");
 
   // Here, it is not necessary to wrap at "." or "->".
   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
   verifyFormat(
       "aaaaaaaaaaa->aaaaaaaaa(\n"
       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
-      "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
+      "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));");
 
   verifyFormat(
       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
TEST_F(FormatTest, UnderstandsNewAndDelete) {
   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"
-            "void delete(link p);\n",
+            "void delete(link p);",
             format("void new (link p);\n"
-                   "void delete (link p);\n"));
+                   "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); }");

 TEST_F(FormatTest, UnderstandsAttributes) {
   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
   verifyFormat("__attribute__((nodebug)) ::qualified_type f();");
   FormatStyle AfterType = getLLVMStyle();
   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
   verifyFormat("__attribute__((nodebug)) void\n"
-               "foo() {}\n",
+               "foo() {}",
                AfterType);
   verifyFormat("__unused void\n"
                "foo() {}",
                AfterType);
 
   FormatStyle CustomAttrs = getLLVMStyle();
   CustomAttrs.AttributeMacros.push_back("__unused");
   CustomAttrs.AttributeMacros.push_back("__attr1");
TEST_F(FormatTest, UnderstandsSquareAttributes) {
   verifyFormat("[[nodiscard]] bool f() { return false; }");
   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
   verifyFormat("[[nodiscard]] ::qualified_type f();");
 
   // Make sure we do not mistake attributes for array subscripts.
   verifyFormat("int a() {}\n"
-               "[[unused]] int b() {}\n");
+               "[[unused]] int b() {}");
   verifyFormat("NSArray *arr;\n"
                "arr[[Foo() bar]];");
 
   // On the other hand, we still need to correctly find array subscripts.
   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
 
   // Make sure that we do not mistake Objective-C method inside array literals
   // as attributes, even if those method names are also keywords.
   verifyFormat("@[ [foo bar] ];");
   verifyFormat("@[ [NSArray class] ];");
   verifyFormat("@[ [foo enum] ];");
 
   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
 
   // Make sure we do not parse attributes as lambda introducers.
   FormatStyle MultiLineFunctions = getLLVMStyle();
   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
   verifyFormat("[[unused]] int b() {\n"
                "  return 42;\n"
-               "}\n",
+               "}",
                MultiLineFunctions);
 }
 
 TEST_F(FormatTest, AttributeClass) {
   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
   verifyFormat("class S {\n"
                "  S(S&&) = default;\n"
                "};",
verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "private:\n"
                "  int i;\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo { /* comment */\n"
                "private:\n"
                "  int i;\n"
                "  // comment\n"
                "private:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo {\n"
                "#ifdef FOO\n"
                "#endif\n"
                "private:\n"
                "  int i;\n"
                "#ifdef FOO\n"
                "private:\n"
                "#endif\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "private:\n"
                "  int i;\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "private:\n"
                "  int i;\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo { /* comment */\n"
                "private:\n"
                "  int i;\n"
                "  // comment\n"
                "private:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                "struct foo { /* comment */\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "  // comment\n"
                "\n"
                "private:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo {\n"
                "#ifdef FOO\n"
                "#endif\n"
                "private:\n"
                "  int i;\n"
                "#ifdef FOO\n"
                "private:\n"
                "#endif\n"
                "  int j;\n"
-               "};\n",
+               "};",
                "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"
-               "};\n",
+               "};",
                Style);
   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "private:\n"
                "  int i;\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo { /* comment */\n"
                "private:\n"
                "  int i;\n"
                "  // comment\n"
                "\n"
                "private:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("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"
-               "};\n",
+               "};",
                "struct foo {\n"
                "#ifdef FOO\n"
                "#endif\n"
                "private:\n"
                "  int i;\n"
                "#ifdef FOO\n"
                "private:\n"
                "#endif\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
   EXPECT_EQ("struct foo {\n"
             "\n"
             "private:\n"
             "  void f() {}\n"
             "\n"
             "private:\n"
             "  int i;\n"
             "\n"
             "protected:\n"
             "  int j;\n"
-            "};\n",
+            "};",
             format("struct foo {\n"
                    "\n"
                    "private:\n"
                    "  void f() {}\n"
                    "\n"
                    "private:\n"
                    "  int i;\n"
                    "\n"
                    "protected:\n"
                    "  int j;\n"
-                   "};\n",
+                   "};",
                    Style));
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "private:\n"
                "  int i;\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   EXPECT_EQ("struct foo { /* comment */\n"
             "\n"
             "private:\n"
             "  int i;\n"
             "  // comment\n"
             "\n"
             "private:\n"
             "  int j;\n"
-            "};\n",
+            "};",
             format("struct foo { /* comment */\n"
                    "\n"
                    "private:\n"
                    "  int i;\n"
                    "  // comment\n"
                    "\n"
                    "private:\n"
                    "  int j;\n"
-                   "};\n",
+                   "};",
                    Style));
   verifyFormat("struct foo { /* comment */\n"
                "private:\n"
                "  int i;\n"
                "  // comment\n"
                "private:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
   EXPECT_EQ("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"
-            "};\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"
-                   "};\n",
+                   "};",
                    Style));
   verifyFormat("struct foo {\n"
                "#ifdef FOO\n"
                "#endif\n"
                "private:\n"
                "  int i;\n"
                "#ifdef FOO\n"
                "private:\n"
                "#endif\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
 
   FormatStyle NoEmptyLines = getLLVMStyle();
   NoEmptyLines.MaxEmptyLinesToKeep = 0;
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "public:\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                NoEmptyLines);
 
   NoEmptyLines.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "private:\n"
                "  int i;\n"
                "public:\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                NoEmptyLines);
 
   NoEmptyLines.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "public:\n"
                "\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                NoEmptyLines);
 }
 
 TEST_F(FormatTest, FormatsAfterAccessModifiers) {
 
   FormatStyle Style = getLLVMStyle();
   EXPECT_EQ(Style.EmptyLineAfterAccessModifier, FormatStyle::ELAAMS_Never);
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
 
   // Check if lines are removed.
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
 
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
   verifyFormat("struct foo {\n"
                "private:\n"
                "\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
 
   // Check if lines are added.
   verifyFormat("struct foo {\n"
                "private:\n"
                "\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "\n"
                "  int j;\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
 
   // Leave tests rely on the code layout, test::messUp can not be used.
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
   Style.MaxEmptyLinesToKeep = 0u;
   verifyFormat("struct foo {\n"
                "private:\n"
                "  void f() {}\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "\n"
                "protected:\n"
                "  int j;\n"
-               "};\n",
+               "};",
                Style);
 
   // Check if MaxEmptyLinesToKeep is respected.
   EXPECT_EQ("struct foo {\n"
             "private:\n"
             "  void f() {}\n"
             "\n"
             "private:\n"
             "  int i;\n"
             "\n"
             "protected:\n"
             "  int j;\n"
-            "};\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"
-                   "};\n",
+                   "};",
                    Style));
 
   Style.MaxEmptyLinesToKeep = 1u;
   EXPECT_EQ("struct foo {\n"
             "private:\n"
             "\n"
             "  void f() {}\n"
             "\n"
             "private:\n"
             "\n"
             "  int i;\n"
             "\n"
             "protected:\n"
             "\n"
             "  int j;\n"
-            "};\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"
-                   "};\n",
+                   "};",
                    Style));
   // Check if no lines are kept.
   EXPECT_EQ("struct foo {\n"
             "private:\n"
             "  void f() {}\n"
             "\n"
             "private:\n"
             "  int i;\n"
             "\n"
             "protected:\n"
             "  int j;\n"
-            "};\n",
+            "};",
             format("struct foo {\n"
                    "private:\n"
                    "  void f() {}\n"
                    "\n"
                    "private:\n"
                    "  int i;\n"
                    "\n"
                    "protected:\n"
                    "  int j;\n"
-                   "};\n",
+                   "};",
                    Style));
   // Check if MaxEmptyLinesToKeep is respected.
   EXPECT_EQ("struct foo {\n"
             "private:\n"
             "\n"
             "  void f() {}\n"
             "\n"
             "private:\n"
             "\n"
             "  int i;\n"
             "\n"
             "protected:\n"
             "\n"
             "  int j;\n"
-            "};\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"
-                   "};\n",
+                   "};",
                    Style));
 
   Style.MaxEmptyLinesToKeep = 10u;
   EXPECT_EQ("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"
-            "};\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"
-                   "};\n",
+                   "};",
                    Style));
 
   // Test with comments.
   Style = getLLVMStyle();
   verifyFormat("struct foo {\n"
                "private:\n"
                "  // comment\n"
                "  void f() {}\n"
                "\n"
                "private: /* comment */\n"
                "  int i;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo {\n"
                "private:\n"
                "  // comment\n"
                "  void f() {}\n"
                "\n"
                "private: /* comment */\n"
                "  int i;\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "\n"
                "  // comment\n"
                "  void f() {}\n"
                "\n"
                "private: /* comment */\n"
                "\n"
                "  int i;\n"
-               "};\n",
+               "};",
                Style);
 
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
   verifyFormat("struct foo {\n"
                "private:\n"
                "\n"
                "  // comment\n"
                "  void f() {}\n"
                "\n"
                "private: /* comment */\n"
                "\n"
                "  int i;\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "  // comment\n"
                "  void f() {}\n"
                "\n"
                "private: /* comment */\n"
                "  int i;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo {\n"
                "private:\n"
                "\n"
                "  // comment\n"
                "  void f() {}\n"
                "\n"
                "private: /* comment */\n"
                "\n"
                "  int i;\n"
-               "};\n",
+               "};",
                Style);
 
   // Test with preprocessor defines.
   Style = getLLVMStyle();
   verifyFormat("struct foo {\n"
                "private:\n"
                "#ifdef FOO\n"
                "#endif\n"
                "  void f() {}\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo {\n"
                "private:\n"
                "#ifdef FOO\n"
                "#endif\n"
                "  void f() {}\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "\n"
                "#ifdef FOO\n"
                "#endif\n"
                "  void f() {}\n"
-               "};\n",
+               "};",
                Style);
   verifyNoChange("struct foo {\n"
                  "#ifdef FOO\n"
                  "#else\n"
                  "private:\n"
                  "\n"
                  "#endif\n"
                  "};",
TEST_F(FormatTest, FormatsAfterAccessModifiers) {
 
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
   verifyFormat("struct foo {\n"
                "private:\n"
                "\n"
                "#ifdef FOO\n"
                "#endif\n"
                "  void f() {}\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "#ifdef FOO\n"
                "#endif\n"
                "  void f() {}\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct foo {\n"
                "private:\n"
                "\n"
                "#ifdef FOO\n"
                "#endif\n"
                "  void f() {}\n"
-               "};\n",
+               "};",
                Style);
 }
 
 TEST_F(FormatTest, FormatsAfterAndBeforeAccessModifiersInteraction) {
   // Combined tests of EmptyLineAfterAccessModifier and
   // EmptyLineBeforeAccessModifier.
   FormatStyle Style = getLLVMStyle();
   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
   verifyFormat("struct foo {\n"
                "private:\n"
                "\n"
                "protected:\n"
-               "};\n",
+               "};",
                Style);
 
   Style.MaxEmptyLinesToKeep = 10u;
   // Both remove all new lines.
   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
   verifyFormat("struct foo {\n"
                "private:\n"
                "protected:\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "\n\n\n"
                "protected:\n"
-               "};\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"
             "private:\n"
             "\n\n\n"
             "protected:\n"
-            "};\n",
+            "};",
             format("struct foo {\n"
                    "private:\n"
                    "\n\n\n"
                    "protected:\n"
-                   "};\n",
+                   "};",
                    Style));
   Style.MaxEmptyLinesToKeep = 3u;
   EXPECT_EQ("struct foo {\n"
             "private:\n"
             "\n\n\n"
             "protected:\n"
-            "};\n",
+            "};",
             format("struct foo {\n"
                    "private:\n"
                    "\n\n\n"
                    "protected:\n"
-                   "};\n",
+                   "};",
                    Style));
   Style.MaxEmptyLinesToKeep = 1u;
   EXPECT_EQ("struct foo {\n"
             "private:\n"
             "\n\n\n"
             "protected:\n"
-            "};\n",
+            "};",
             format("struct foo {\n"
                    "private:\n"
                    "\n\n\n"
                    "protected:\n"
-                   "};\n",
+                   "};",
                    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"
             "private:\n"
             "\n\n\n"
             "protected:\n"
-            "};\n",
+            "};",
             format("struct foo {\n"
                    "private:\n"
                    "\n\n\n"
                    "protected:\n"
-                   "};\n",
+                   "};",
                    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"
             "private:\n"
             "\n\n\n"
             "protected:\n"
-            "};\n",
+            "};",
             format("struct foo {\n"
                    "private:\n"
                    "\n\n\n"
                    "protected:\n"
-                   "};\n",
+                   "};",
                    Style));
 
   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
   EXPECT_EQ("struct foo {\n"
             "private:\n"
             "\n\n\n"
             "protected:\n"
-            "};\n",
+            "};",
             format("struct foo {\n"
                    "private:\n"
                    "\n\n\n"
                    "protected:\n"
-                   "};\n",
+                   "};",
                    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"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "\n\n\n"
                "protected:\n"
-               "};\n",
+               "};",
                Style);
 
   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
   EXPECT_EQ("struct foo {\n"
             "private:\n"
             "\n\n\n"
             "protected:\n"
-            "};\n",
+            "};",
             format("struct foo {\n"
                    "private:\n"
                    "\n\n\n"
                    "protected:\n"
-                   "};\n",
+                   "};",
                    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"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "\n\n\n"
                "protected:\n"
-               "};\n",
+               "};",
                Style);
 
   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
   verifyFormat("struct foo {\n"
                "private:\n"
                "protected:\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "\n\n\n"
                "protected:\n"
-               "};\n",
+               "};",
                Style);
 
   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
   verifyFormat("struct foo {\n"
                "private:\n"
                "protected:\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "\n\n\n"
                "protected:\n"
-               "};\n",
+               "};",
                Style);
 
   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
   verifyFormat("struct foo {\n"
                "private:\n"
                "protected:\n"
-               "};\n",
+               "};",
                "struct foo {\n"
                "private:\n"
                "\n\n\n"
                "protected:\n"
-               "};\n",
+               "};",
                Style);
 }
 
 TEST_F(FormatTest, FormatsArrays) {
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
verifyFormat("#include <string>\n"
                "#include \"string.h\"\n"
                "#include \"string.h\"\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>\n",
+               "#include <some/very/long/include/path>",
                getLLVMStyleWithColumns(35));
   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
   EXPECT_EQ("#include <a>", format("#include<a>"));
 
   verifyFormat("#import <string>");
   verifyFormat("#import <a/b/c.h>");
   verifyFormat("#import \"a/b/string\"");
   verifyFormat("#import \"string.h\"");

 
 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
   verifyFormat("int aaaaaaaa =\n"
                "    // Overlylongcomment\n"
                "    b;",
                getLLVMStyleWithColumns(20));
   verifyFormat("function(\n"
                "    ShortArgument,\n"
-               "    LoooooooooooongArgument);\n",
+               "    LoooooooooooongArgument);",
                getLLVMStyleWithColumns(20));
 }
 
 TEST_F(FormatTest, IncorrectAccessSpecifier) {
   verifyFormat("public:");
   verifyFormat("class A {\n"
                "public\n"
                "  void f() {}\n"

 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
   verifyIncompleteFormat("namespace {\n"
                          "class Foo { Foo (\n"
                          "};\n"
                          "} // namespace");
 }
 
 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
-  EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
-  EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
-  EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
-  EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
+  EXPECT_EQ("{\n  {}", format("{\n{\n}"));
+  EXPECT_EQ("{\n  {}", format("{\n  {\n}"));
+  EXPECT_EQ("{\n  {}", format("{\n  {\n  }"));
+  EXPECT_EQ("{\n  {}\n}\n}", format("{\n  {\n    }\n  }\n}"));
 
   EXPECT_EQ("{\n"
             "  {\n"
             "    breakme(\n"
             "        qwe);\n"
-            "  }\n",
+            "  }",
             format("{\n"
                    "    {\n"
                    " breakme(qwe);\n"
-                   "}\n",
+                   "}",
                    getLLVMStyleWithColumns(10)));
 }
 
 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
   verifyFormat("int x = {\n"
                "    avariable,\n"
                "    b(alongervariable)};",
                getLLVMStyleWithColumns(25));
verifyFormat("int f()\n"
                "{\n"
                "  return 0;\n"
                "}",
                Style);
 
   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
   verifyFormat("class Foo {\n"
                "  int f() {}\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("class Foo {\n"
                "  int f() { return 0; }\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("class Foo {\n"
                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
                "  {}\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("class Foo {\n"
                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
                "  {\n"
                "    return 0;\n"
                "  }\n"
-               "};\n",
+               "};",
                Style);
 
   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
   verifyFormat("int f() {}", Style);
   verifyFormat("int f() { return 0; }", Style);
   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
                "{}",
                Style);
TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
   // This now gets parsed incorrectly as class definition.
   // verifyFormat("class A<int> f() {\n}\nint n;");
 
   // Elaborate types where incorrectly parsing the structural element would
   // break the indent.
   verifyFormat("if (true)\n"
                "  class X x;\n"
                "else\n"
-               "  f();\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!\n");
-  EXPECT_EQ(
-      "#warning Leave     all         white!!!!! space* alone!\n",
-      format("#warning Leave     all         white!!!!! space* alone!\n"));
+  verifyNoChange("#error Leave     all         white!!!!! space* alone!");
+  EXPECT_EQ("#warning Leave     all         white!!!!! space* alone!",
+            format("#warning Leave     all         white!!!!! space* alone!"));
   EXPECT_EQ("#error 1", format("  #  error   1"));
   EXPECT_EQ("#warning 1", format("  #  warning 1"));
 }
 
 TEST_F(FormatTest, FormatHashIfExpressions) {
   verifyFormat("#if AAAA && BBBB");
   verifyFormat("#if (AAAA && BBBB)");
   verifyFormat("#elif (AAAA && BBBB)");
std::string Code("A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" // 20x
                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
   // Deeply nested part is untouched, rest is formatted.
-  EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
-            format(std::string("int    i;\n") + Code + "int    j;\n",
+  EXPECT_EQ(std::string("int i;") + Code + "int j;",
+            format(std::string("int    i;") + Code + "int    j;",
                    getLLVMStyle(), SC_ExpectIncomplete));
 }
 
 //===----------------------------------------------------------------------===//
 // Objective-C tests.
 //===----------------------------------------------------------------------===//
 
 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
TEST_F(FormatTest, ConfigurableUseOfTab) {
   verifyFormat("#define A                        \\\n"
                "\tvoid f() {               \\\n"
                "\t\tsomeFunction(    \\\n"
                "\t\t    parameter1,  \\\n"
                "\t\t    parameter2); \\\n"
                "\t}",
                Tab);
   verifyFormat("int a;\t      // x\n"
-               "int bbbbbbbb; // x\n",
+               "int bbbbbbbb; // x",
                Tab);
 
   FormatStyle TabAlignment = Tab;
   TabAlignment.AlignConsecutiveDeclarations.Enabled = true;
   TabAlignment.PointerAlignment = FormatStyle::PAS_Left;
   verifyFormat("unsigned long long big;\n"
                "char*\t\t   ptr;",
                TabAlignment);
TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
   verifyFormat("double &operator[](int i) { return 0; }\n"
                "int i;",
                Spaces);
   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
   // Lambdas.
-  verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
+  verifyFormat("int c = []() -> int { return 2; }();", Spaces);
   verifyFormat("return [ i, args... ] {};", Spaces);
   verifyFormat("int foo = [ &bar ]() {};", Spaces);
   verifyFormat("int foo = [ = ]() {};", Spaces);
   verifyFormat("int foo = [ & ]() {};", Spaces);
   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
 }
 
 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
   FormatStyle NoSpaceStyle = getLLVMStyle();
   verifyFormat("int a[5];", NoSpaceStyle);
   verifyFormat("a[3] += 42;", NoSpaceStyle);
 
   verifyFormat("int a[1];", NoSpaceStyle);
   verifyFormat("int 1 [a];", NoSpaceStyle);
   verifyFormat("int a[1][2];", NoSpaceStyle);
   verifyFormat("a[7] = 5;", NoSpaceStyle);
   verifyFormat("int a = (f())[23];", NoSpaceStyle);
   verifyFormat("f([] {})", NoSpaceStyle);
 
   FormatStyle Space = getLLVMStyle();
   Space.SpaceBeforeSquareBrackets = true;
-  verifyFormat("int c = []() -> int { return 2; }();\n", Space);
+  verifyFormat("int c = []() -> int { return 2; }();", Space);
   verifyFormat("return [i, args...] {};", Space);
 
   verifyFormat("int a [5];", Space);
   verifyFormat("a [3] += 42;", Space);
   verifyFormat("constexpr char hello []{\"hello\"};", Space);
   verifyFormat("double &operator[](int i) { return 0; }\n"
                "int i;",
                Space);
TEST_F(FormatTest, AlignConsecutiveMacros) {
   verifyFormat("#define a          \\\n"
                "  \"aabbbbbbbbbbbb\"\n"
                "#define D          \\\n"
                "  \"aabbbbbbbbbbbb\" \\\n"
                "  \"ccddeeeeeeeee\"\n"
                "#define B          \\\n"
                "  \"QQQQQQQQQQQQQ\"  \\\n"
                "  \"FFFFFFFFFFFFF\"  \\\n"
-               "  \"LLLLLLLL\"\n",
+               "  \"LLLLLLLL\"",
                Style);
 
   Style.AlignConsecutiveMacros.Enabled = true;
   verifyFormat("#define a          \\\n"
                "  \"aabbbbbbbbbbbb\"\n"
                "#define D          \\\n"
                "  \"aabbbbbbbbbbbb\" \\\n"
                "  \"ccddeeeeeeeee\"\n"
                "#define B          \\\n"
                "  \"QQQQQQQQQQQQQ\"  \\\n"
                "  \"FFFFFFFFFFFFF\"  \\\n"
-               "  \"LLLLLLLL\"\n",
+               "  \"LLLLLLLL\"",
                Style);
 
   // Test across comments
   Style.MaxEmptyLinesToKeep = 10;
   Style.ReflowComments = false;
   Style.AlignConsecutiveMacros.AcrossComments = true;
   EXPECT_EQ("#define a    3\n"
             "// line comment\n"
verifyFormat("a &= 5;\n"
                "sfdbddfbdfbb ^= 5;\n"
                "dvsdsv |= 5;\n"
                "int dsvvdvsdvvv = 123;",
                Alignment);
   verifyFormat("int i = 1, j = 10;\n"
                "something = 2000;",
                Alignment);
   verifyFormat("something = 2000;\n"
-               "int i = 1, j = 10;\n",
+               "int i = 1, j = 10;",
                Alignment);
   verifyFormat("something = 2000;\n"
                "another   = 911;\n"
                "int i = 1, j = 10;\n"
                "oneMore = 1;\n"
                "i       = 2;",
                Alignment);
   verifyFormat("int a   = 5;\n"
                "int one = 1;\n"
                "method();\n"
                "int oneTwoThree = 123;\n"
                "int oneTwo      = 12;",
                Alignment);
   verifyFormat("int oneTwoThree = 123;\n"
                "int oneTwo      = 12;\n"
-               "method();\n",
+               "method();",
                Alignment);
   verifyFormat("int oneTwoThree = 123; // comment\n"
                "int oneTwo      = 12;  // comment",
                Alignment);
 
   // Bug 25167
   /* Uncomment when fixed
     verifyFormat("#if A\n"
                  "#else\n"
                  "int aaaaaaaa = 12;\n"
                  "#endif\n"
                  "#if B\n"
                  "#else\n"
                  "int a = 12;\n"
-                 "#endif\n",
+                 "#endif",
                  Alignment);
     verifyFormat("enum foo {\n"
                  "#if A\n"
                  "#else\n"
                  "  aaaaaaaa = 12;\n"
                  "#endif\n"
                  "#if B\n"
                  "#else\n"
                  "  a = 12;\n"
                  "#endif\n"
-                 "};\n",
+                 "};",
                  Alignment);
   */
 
   Alignment.MaxEmptyLinesToKeep = 10;
   /* Test alignment across empty lines */
   EXPECT_EQ("int a           = 5;\n"
             "\n"
             "int oneTwoThree = 123;",
verifyFormat(
       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
       "                          loooooooooooooooooooooongParameterB);\n"
       "int j      = 2;",
       Alignment);
 
   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
                "          typename B   = very_long_type_name_1,\n"
                "          typename T_2 = very_long_type_name_2>\n"
-               "auto foo() {}\n",
+               "auto foo() {}",
                Alignment);
   verifyFormat("int a, b = 1;\n"
                "int c  = 2;\n"
-               "int dd = 3;\n",
+               "int dd = 3;",
                Alignment);
   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
-               "float b[1][] = {{3.f}};\n",
+               "float b[1][] = {{3.f}};",
                Alignment);
   verifyFormat("for (int i = 0; i < 1; i++)\n"
-               "  int x = 1;\n",
+               "  int x = 1;",
                Alignment);
   verifyFormat("for (i = 0; i < 1; i++)\n"
                "  x = 1;\n"
-               "y = 1;\n",
+               "y = 1;",
                Alignment);
 
   Alignment.ReflowComments = true;
   Alignment.ColumnLimit = 50;
   EXPECT_EQ("int x   = 0;\n"
             "int yy  = 1; /// specificlennospace\n"
-            "int zzz = 2;\n",
+            "int zzz = 2;",
             format("int x   = 0;\n"
                    "int yy  = 1; ///specificlennospace\n"
-                   "int zzz = 2;\n",
+                   "int zzz = 2;",
                    Alignment));
 }
 
 TEST_F(FormatTest, AlignCompoundAssignments) {
   FormatStyle Alignment = getLLVMStyle();
   Alignment.AlignConsecutiveAssignments.Enabled = true;
   Alignment.AlignConsecutiveAssignments.AlignCompound = true;
   Alignment.AlignConsecutiveAssignments.PadOperators = false;
verifyFormat("sfdbddfbdfbb    ^= 5;\n"
                Alignment);
   verifyFormat("sfdbddfbdfbb     ^= 5;\n"
                "dvsdsv          <<= 5;\n"
                "int dsvvdvsdvvv   = 123;",
                Alignment);
   EXPECT_EQ("a   += 5;\n"
             "one  = 1;\n"
             "\n"
-            "oneTwoThree = 123;\n",
+            "oneTwoThree = 123;",
             format("a += 5;\n"
                    "one = 1;\n"
                    "\n"
-                   "oneTwoThree = 123;\n",
+                   "oneTwoThree = 123;",
                    Alignment));
   EXPECT_EQ("a   += 5;\n"
             "one  = 1;\n"
             "//\n"
-            "oneTwoThree = 123;\n",
+            "oneTwoThree = 123;",
             format("a += 5;\n"
                    "one = 1;\n"
                    "//\n"
-                   "oneTwoThree = 123;\n",
+                   "oneTwoThree = 123;",
                    Alignment));
   Alignment.AlignConsecutiveAssignments.AcrossEmptyLines = true;
   EXPECT_EQ("a           += 5;\n"
             "one          = 1;\n"
             "\n"
-            "oneTwoThree  = 123;\n",
+            "oneTwoThree  = 123;",
             format("a += 5;\n"
                    "one = 1;\n"
                    "\n"
-                   "oneTwoThree = 123;\n",
+                   "oneTwoThree = 123;",
                    Alignment));
   EXPECT_EQ("a   += 5;\n"
             "one  = 1;\n"
             "//\n"
-            "oneTwoThree = 123;\n",
+            "oneTwoThree = 123;",
             format("a += 5;\n"
                    "one = 1;\n"
                    "//\n"
-                   "oneTwoThree = 123;\n",
+                   "oneTwoThree = 123;",
                    Alignment));
   Alignment.AlignConsecutiveAssignments.AcrossEmptyLines = false;
   Alignment.AlignConsecutiveAssignments.AcrossComments = true;
   EXPECT_EQ("a   += 5;\n"
             "one  = 1;\n"
             "\n"
-            "oneTwoThree = 123;\n",
+            "oneTwoThree = 123;",
             format("a += 5;\n"
                    "one = 1;\n"
                    "\n"
-                   "oneTwoThree = 123;\n",
+                   "oneTwoThree = 123;",
                    Alignment));
   EXPECT_EQ("a           += 5;\n"
             "one          = 1;\n"
             "//\n"
-            "oneTwoThree  = 123;\n",
+            "oneTwoThree  = 123;",
             format("a += 5;\n"
                    "one = 1;\n"
                    "//\n"
-                   "oneTwoThree = 123;\n",
+                   "oneTwoThree = 123;",
                    Alignment));
   Alignment.AlignConsecutiveAssignments.AcrossEmptyLines = true;
   EXPECT_EQ("a            += 5;\n"
             "one         >>= 1;\n"
             "\n"
-            "oneTwoThree   = 123;\n",
+            "oneTwoThree   = 123;",
             format("a += 5;\n"
                    "one >>= 1;\n"
                    "\n"
-                   "oneTwoThree = 123;\n",
+                   "oneTwoThree = 123;",
                    Alignment));
   EXPECT_EQ("a            += 5;\n"
             "one           = 1;\n"
             "//\n"
-            "oneTwoThree <<= 123;\n",
+            "oneTwoThree <<= 123;",
             format("a += 5;\n"
                    "one = 1;\n"
                    "//\n"
-                   "oneTwoThree <<= 123;\n",
+                   "oneTwoThree <<= 123;",
                    Alignment));
 }
 
 TEST_F(FormatTest, AlignConsecutiveAssignments) {
   FormatStyle Alignment = getLLVMStyle();
   Alignment.AlignConsecutiveMacros.Enabled = true;
   verifyFormat("int a = 5;\n"
                "int oneTwoThree = 123;",
verifyFormat("aa <= 5;\n"
                "sfdbddfbdfbb ^= 5;\n"
                "dvsdsv |= 5;\n"
                "int dsvvdvsdvvv = 123;",
                Alignment);
   verifyFormat("int i = 1, j = 10;\n"
                "something = 2000;",
                Alignment);
   verifyFormat("something = 2000;\n"
-               "int i = 1, j = 10;\n",
+               "int i = 1, j = 10;",
                Alignment);
   verifyFormat("something = 2000;\n"
                "another   = 911;\n"
                "int i = 1, j = 10;\n"
                "oneMore = 1;\n"
                "i       = 2;",
                Alignment);
   verifyFormat("int a   = 5;\n"
                "int one = 1;\n"
                "method();\n"
                "int oneTwoThree = 123;\n"
                "int oneTwo      = 12;",
                Alignment);
   verifyFormat("int oneTwoThree = 123;\n"
                "int oneTwo      = 12;\n"
-               "method();\n",
+               "method();",
                Alignment);
   verifyFormat("int oneTwoThree = 123; // comment\n"
                "int oneTwo      = 12;  // comment",
                Alignment);
   verifyFormat("int f()         = default;\n"
                "int &operator() = default;\n"
                "int &operator=() {",
                Alignment);
TEST_F(FormatTest, AlignConsecutiveAssignments) {
   // https://llvm.org/PR33697
   FormatStyle AlignmentWithPenalty = getLLVMStyle();
   AlignmentWithPenalty.AlignConsecutiveAssignments.Enabled = true;
   AlignmentWithPenalty.PenaltyReturnTypeOnItsOwnLine = 5000;
   verifyFormat("class SSSSSSSSSSSSSSSSSSSSSSSSSSSS {\n"
                "  void f() = delete;\n"
                "  SSSSSSSSSSSSSSSSSSSSSSSSSSSS &operator=(\n"
                "      const SSSSSSSSSSSSSSSSSSSSSSSSSSSS &other) = delete;\n"
-               "};\n",
+               "};",
                AlignmentWithPenalty);
 
   // Bug 25167
   /* Uncomment when fixed
     verifyFormat("#if A\n"
                  "#else\n"
                  "int aaaaaaaa = 12;\n"
                  "#endif\n"
                  "#if B\n"
                  "#else\n"
                  "int a = 12;\n"
-                 "#endif\n",
+                 "#endif",
                  Alignment);
     verifyFormat("enum foo {\n"
                  "#if A\n"
                  "#else\n"
                  "  aaaaaaaa = 12;\n"
                  "#endif\n"
                  "#if B\n"
                  "#else\n"
                  "  a = 12;\n"
                  "#endif\n"
-                 "};\n",
+                 "};",
                  Alignment);
   */
 
   EXPECT_EQ("int a = 5;\n"
             "\n"
             "int oneTwoThree = 123;",
             format("int a       = 5;\n"
                    "\n"
verifyFormat(
       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
       "                          loooooooooooooooooooooongParameterB);\n"
       "int j      = 2;",
       Alignment);
 
   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
                "          typename B   = very_long_type_name_1,\n"
                "          typename T_2 = very_long_type_name_2>\n"
-               "auto foo() {}\n",
+               "auto foo() {}",
                Alignment);
   verifyFormat("int a, b = 1;\n"
                "int c  = 2;\n"
-               "int dd = 3;\n",
+               "int dd = 3;",
                Alignment);
   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
-               "float b[1][] = {{3.f}};\n",
+               "float b[1][] = {{3.f}};",
                Alignment);
   verifyFormat("for (int i = 0; i < 1; i++)\n"
-               "  int x = 1;\n",
+               "  int x = 1;",
                Alignment);
   verifyFormat("for (i = 0; i < 1; i++)\n"
                "  x = 1;\n"
-               "y = 1;\n",
+               "y = 1;",
                Alignment);
 
   EXPECT_EQ(Alignment.ReflowComments, true);
   Alignment.ColumnLimit = 50;
   EXPECT_EQ("int x   = 0;\n"
             "int yy  = 1; /// specificlennospace\n"
-            "int zzz = 2;\n",
+            "int zzz = 2;",
             format("int x   = 0;\n"
                    "int yy  = 1; ///specificlennospace\n"
-                   "int zzz = 2;\n",
+                   "int zzz = 2;",
                    Alignment));
 
   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaa = {};\n"
                "auto b                     = [] {\n"
                "  f();\n"
                "  return;\n"
                "};",
                Alignment);
verifyFormat("float const a = 5;\n"
                Alignment);
   verifyFormat("int         a = method();\n"
                "float const oneTwoThree = 133;",
                Alignment);
   verifyFormat("int i = 1, j = 10;\n"
                "something = 2000;",
                Alignment);
   verifyFormat("something = 2000;\n"
-               "int i = 1, j = 10;\n",
+               "int i = 1, j = 10;",
                Alignment);
   verifyFormat("float      something = 2000;\n"
                "double     another = 911;\n"
                "int        i = 1, j = 10;\n"
                "const int *oneMore = 1;\n"
                "unsigned   i = 2;",
                Alignment);
   verifyFormat("float a = 5;\n"
verifyFormat("float      something = 2000;\n"
                "unsigned   i       = 2;",
                Alignment);
   verifyFormat("int      oneTwoThree = {0}; // comment\n"
                "unsigned oneTwo      = 0;   // comment",
                Alignment);
   // Make sure that scope is correctly tracked, in the absence of braces
   verifyFormat("for (int i = 0; i < n; i++)\n"
                "  j = i;\n"
-               "double x = 1;\n",
+               "double x = 1;",
                Alignment);
   verifyFormat("if (int i = 0)\n"
                "  j = i;\n"
-               "double x = 1;\n",
+               "double x = 1;",
                Alignment);
   // Ensure operator[] and operator() are comprehended
   verifyFormat("struct test {\n"
                "  long long int foo();\n"
                "  int           operator[](int a);\n"
                "  double        bar();\n"
-               "};\n",
+               "};",
                Alignment);
   verifyFormat("struct test {\n"
                "  long long int foo();\n"
                "  int           operator()(int a);\n"
                "  double        bar();\n"
-               "};\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"
                    "int ll=10000;\n"
                    "}",
                    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;\n",
+               "int    foobar;",
                Alignment);
 
   // PAS_Left
   FormatStyle AlignmentLeft = Alignment;
   AlignmentLeft.PointerAlignment = FormatStyle::PAS_Left;
   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
             "  int const i   = 1;\n"
             "  int*      j   = 2;\n"
EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
                    "float k= 2;\n"
                    "int ll=10000;\n"
                    "}",
                    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;\n",
+               "int    foobar;",
                AlignmentLeft);
 
   // PAS_Middle
   FormatStyle AlignmentMiddle = Alignment;
   AlignmentMiddle.PointerAlignment = FormatStyle::PAS_Middle;
   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
             "  int const i   = 1;\n"
             "  int *     j   = 2;\n"
EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
                    "float k= 2;\n"
                    "int ll=10000;\n"
                    "}",
                    AlignmentMiddle));
   // variables are aligned at their name, pointers are in the middle
   verifyFormat("int *   a;\n"
                "int *   b;\n"
                "int *** c;\n"
-               "int     foobar;\n",
+               "int     foobar;",
                AlignmentMiddle);
 
   Alignment.AlignConsecutiveAssignments.Enabled = false;
   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
   verifyFormat("#define A \\\n"
                "  int       aaaa = 12; \\\n"
                "  float     b = 23; \\\n"
                "  const int ccc = 234; \\\n"
verifyFormat("float    ii              = 1;\n"
                "int              myvar = 1;",
                Alignment);
   Alignment.ColumnLimit = 80;
   Alignment.AlignConsecutiveAssignments.Enabled = false;
 
   verifyFormat(
       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
       "          typename LongType, typename B>\n"
-      "auto foo() {}\n",
+      "auto foo() {}",
       Alignment);
   verifyFormat("float a, b = 1;\n"
                "int   c = 2;\n"
-               "int   dd = 3;\n",
+               "int   dd = 3;",
                Alignment);
   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
-               "float b[1][] = {{3.f}};\n",
+               "float b[1][] = {{3.f}};",
                Alignment);
   Alignment.AlignConsecutiveAssignments.Enabled = true;
   verifyFormat("float a, b = 1;\n"
                "int   c  = 2;\n"
-               "int   dd = 3;\n",
+               "int   dd = 3;",
                Alignment);
   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
-               "float b[1][] = {{3.f}};\n",
+               "float b[1][] = {{3.f}};",
                Alignment);
   Alignment.AlignConsecutiveAssignments.Enabled = false;
 
   Alignment.ColumnLimit = 30;
   Alignment.BinPackParameters = false;
   verifyFormat("void foo(float     a,\n"
                "         float     b,\n"
                "         int       c,\n"
                "         uint32_t *d) {\n"
                "  int   *e = 0;\n"
                "  float  f = 0;\n"
                "  double g = 0;\n"
                "}\n"
                "void bar(ino_t     a,\n"
                "         int       b,\n"
                "         uint32_t *c,\n"
-               "         bool      d) {}\n",
+               "         bool      d) {}",
                Alignment);
   Alignment.BinPackParameters = true;
   Alignment.ColumnLimit = 80;
 
   // Bug 33507
   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
   verifyFormat(
       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
       "  static const Version verVs2017;\n"
       "  return true;\n"
-      "});\n",
+      "});",
       Alignment);
   Alignment.PointerAlignment = FormatStyle::PAS_Right;
 
   // See llvm.org/PR35641
   Alignment.AlignConsecutiveDeclarations.Enabled = true;
   verifyFormat("int func() { //\n"
                "  int      b;\n"
                "  unsigned c;\n"
verifyFormat("namespace a\n"
                "      a();\n"
                "    }\n"
                "  }\n"
                "  void g() { return; }\n"
                "};\n"
                "struct B {\n"
                "  int x;\n"
                "};\n"
-               "} // namespace a\n",
+               "} // namespace a",
                LinuxBraceStyle);
   verifyFormat("enum X {\n"
                "  Y = 0,\n"
-               "}\n",
+               "}",
                LinuxBraceStyle);
   verifyFormat("struct S {\n"
                "  int Type;\n"
                "  union {\n"
                "    int x;\n"
                "    double y;\n"
                "  } Value;\n"
                "  class C\n"
                "  {\n"
                "    MyFavoriteType Value;\n"
                "  } Class;\n"
-               "}\n",
+               "}",
                LinuxBraceStyle);
 }
 
 TEST_F(FormatTest, MozillaBraceBreaking) {
   FormatStyle MozillaBraceStyle = getLLVMStyle();
   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
   MozillaBraceStyle.FixNamespaceComments = false;
   verifyFormat("namespace a {\n"
verifyFormat("namespace a {\n"
                "  // foo\n"
                "  B,\n"
                "  C\n"
                "};\n"
                "struct B\n"
                "{\n"
                "  int x;\n"
                "};\n"
-               "}\n",
+               "}",
                MozillaBraceStyle);
   verifyFormat("struct S\n"
                "{\n"
                "  int Type;\n"
                "  union\n"
                "  {\n"
                "    int x;\n"
                "    double y;\n"
                "  } Value;\n"
                "  class C\n"
                "  {\n"
                "    MyFavoriteType Value;\n"
                "  } Class;\n"
-               "}\n",
+               "}",
                MozillaBraceStyle);
 }
 
 TEST_F(FormatTest, StroustrupBraceBreaking) {
   FormatStyle StroustrupBraceStyle = getLLVMStyle();
   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
   verifyFormat("namespace a {\n"
                "class A {\n"
                "  void f()\n"
                "  {\n"
                "    if (true) {\n"
                "      a();\n"
                "      b();\n"
                "    }\n"
                "  }\n"
                "  void g() { return; }\n"
                "};\n"
                "struct B {\n"
                "  int x;\n"
                "};\n"
-               "} // namespace a\n",
+               "} // namespace a",
                StroustrupBraceStyle);
 
   verifyFormat("void foo()\n"
                "{\n"
                "  if (a) {\n"
                "    a();\n"
                "  }\n"
                "  else {\n"
                "    b();\n"
                "  }\n"
-               "}\n",
+               "}",
                StroustrupBraceStyle);
 
   verifyFormat("#ifdef _DEBUG\n"
                "int foo(int i = 0)\n"
                "#else\n"
                "int foo(int i = 5)\n"
                "#endif\n"
                "{\n"

 TEST_F(FormatTest, AllmanBraceBreaking) {
   FormatStyle AllmanBraceStyle = getLLVMStyle();
   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
 
   EXPECT_EQ("namespace a\n"
             "{\n"
             "void f();\n"
             "void g();\n"
-            "} // namespace a\n",
+            "} // namespace a",
             format("namespace a\n"
                    "{\n"
                    "void f();\n"
                    "void g();\n"
-                   "}\n",
+                   "}",
                    AllmanBraceStyle));
 
   verifyFormat("namespace a\n"
                "{\n"
                "class A\n"
                "{\n"
                "  void f()\n"
                "  {\n"
verifyFormat("void f()\n"
                "  else if (false)\n"
                "  {\n"
                "    b();\n"
                "  }\n"
                "  else\n"
                "  {\n"
                "    c();\n"
                "  }\n"
-               "}\n",
+               "}",
                AllmanBraceStyle);
 
   verifyFormat("void f()\n"
                "{\n"
                "  for (int i = 0; i < 10; ++i)\n"
                "  {\n"
                "    a();\n"
                "  }\n"
                "  while (false)\n"
                "  {\n"
                "    b();\n"
                "  }\n"
                "  do\n"
                "  {\n"
                "    c();\n"
                "  } while (false)\n"
-               "}\n",
+               "}",
                AllmanBraceStyle);
 
   verifyFormat("void f(int a)\n"
                "{\n"
                "  switch (a)\n"
                "  {\n"
                "  case 0:\n"
                "    break;\n"
                "  case 1:\n"
                "  {\n"
                "    break;\n"
                "  }\n"
                "  case 2:\n"
                "  {\n"
                "  }\n"
                "  break;\n"
                "  default:\n"
                "    break;\n"
                "  }\n"
-               "}\n",
+               "}",
                AllmanBraceStyle);
 
   verifyFormat("enum X\n"
                "{\n"
                "  Y = 0,\n"
-               "}\n",
+               "}",
                AllmanBraceStyle);
   verifyFormat("enum X\n"
                "{\n"
                "  Y = 0\n"
-               "}\n",
+               "}",
                AllmanBraceStyle);
 
   verifyFormat("@interface BSApplicationController ()\n"
                "{\n"
                "@private\n"
                "  id _extraIvar;\n"
                "}\n"
-               "@end\n",
+               "@end",
                AllmanBraceStyle);
 
   verifyFormat("#ifdef _DEBUG\n"
                "int foo(int i = 0)\n"
                "#else\n"
                "int foo(int i = 5)\n"
                "#endif\n"
                "{\n"
BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
       FormatStyle::SIS_WithoutElse;
   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
   verifyFormat("void f(bool b)\n"
                "{\n"
                "  if (b)\n"
                "  {\n"
                "    return;\n"
                "  }\n"
-               "}\n",
+               "}",
                BreakBeforeBraceShortIfs);
   verifyFormat("void f(bool b)\n"
                "{\n"
                "  if constexpr (b)\n"
                "  {\n"
                "    return;\n"
                "  }\n"
-               "}\n",
+               "}",
                BreakBeforeBraceShortIfs);
   verifyFormat("void f(bool b)\n"
                "{\n"
                "  if CONSTEXPR (b)\n"
                "  {\n"
                "    return;\n"
                "  }\n"
-               "}\n",
+               "}",
                BreakBeforeBraceShortIfs);
   verifyFormat("void f(bool b)\n"
                "{\n"
                "  if (b) return;\n"
-               "}\n",
+               "}",
                BreakBeforeBraceShortIfs);
   verifyFormat("void f(bool b)\n"
                "{\n"
                "  if constexpr (b) return;\n"
-               "}\n",
+               "}",
                BreakBeforeBraceShortIfs);
   verifyFormat("void f(bool b)\n"
                "{\n"
                "  if CONSTEXPR (b) return;\n"
-               "}\n",
+               "}",
                BreakBeforeBraceShortIfs);
   verifyFormat("void f(bool b)\n"
                "{\n"
                "  while (b)\n"
                "  {\n"
                "    return;\n"
                "  }\n"
-               "}\n",
+               "}",
                BreakBeforeBraceShortIfs);
 }
 
 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
   FormatStyle WhitesmithsBraceStyle = getLLVMStyleWithColumns(0);
   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
 
   // Make a few changes to the style for testing purposes
verifyFormat("class A;\n"
                "  D();\n"
                "  ~D() {}\n"
                "private:\n"
                "  enum E\n"
                "    {\n"
                "    F\n"
                "    }\n"
                "  };\n"
-               "  } // namespace B\n",
+               "  } // namespace B",
                WhitesmithsBraceStyle);
   */
 
   WhitesmithsBraceStyle.NamespaceIndentation = FormatStyle::NI_None;
   verifyFormat("namespace a\n"
                "  {\n"
                "class A\n"
                "  {\n"
verifyFormat("void f()\n"
                "  else if (false)\n"
                "    {\n"
                "    b();\n"
                "    }\n"
                "  else\n"
                "    {\n"
                "    c();\n"
                "    }\n"
-               "  }\n",
+               "  }",
                WhitesmithsBraceStyle);
 
   verifyFormat("void f()\n"
                "  {\n"
                "  for (int i = 0; i < 10; ++i)\n"
                "    {\n"
                "    a();\n"
                "    }\n"
                "  while (false)\n"
                "    {\n"
                "    b();\n"
                "    }\n"
                "  do\n"
                "    {\n"
                "    c();\n"
                "    } while (false)\n"
-               "  }\n",
+               "  }",
                WhitesmithsBraceStyle);
 
   WhitesmithsBraceStyle.IndentCaseLabels = true;
   verifyFormat("void switchTest1(int a)\n"
                "  {\n"
                "  switch (a)\n"
                "    {\n"
                "    case 2:\n"
                "      {\n"
                "      }\n"
                "      break;\n"
                "    }\n"
-               "  }\n",
+               "  }",
                WhitesmithsBraceStyle);
 
   verifyFormat("void switchTest2(int a)\n"
                "  {\n"
                "  switch (a)\n"
                "    {\n"
                "    case 0:\n"
                "      break;\n"
                "    case 1:\n"
                "      {\n"
                "      break;\n"
                "      }\n"
                "    case 2:\n"
                "      {\n"
                "      }\n"
                "      break;\n"
                "    default:\n"
                "      break;\n"
                "    }\n"
-               "  }\n",
+               "  }",
                WhitesmithsBraceStyle);
 
   verifyFormat("void switchTest3(int a)\n"
                "  {\n"
                "  switch (a)\n"
                "    {\n"
                "    case 0:\n"
                "      {\n"
                "      foo(x);\n"
                "      }\n"
                "      break;\n"
                "    default:\n"
                "      {\n"
                "      foo(1);\n"
                "      }\n"
                "      break;\n"
                "    }\n"
-               "  }\n",
+               "  }",
                WhitesmithsBraceStyle);
 
   WhitesmithsBraceStyle.IndentCaseLabels = false;
 
   verifyFormat("void switchTest4(int a)\n"
                "  {\n"
                "  switch (a)\n"
                "    {\n"
                "  case 2:\n"
                "    {\n"
                "    }\n"
                "    break;\n"
                "    }\n"
-               "  }\n",
+               "  }",
                WhitesmithsBraceStyle);
 
   verifyFormat("void switchTest5(int a)\n"
                "  {\n"
                "  switch (a)\n"
                "    {\n"
                "  case 0:\n"
                "    break;\n"
                "  case 1:\n"
                "    {\n"
                "    foo();\n"
                "    break;\n"
                "    }\n"
                "  case 2:\n"
                "    {\n"
                "    }\n"
                "    break;\n"
                "  default:\n"
                "    break;\n"
                "    }\n"
-               "  }\n",
+               "  }",
                WhitesmithsBraceStyle);
 
   verifyFormat("void switchTest6(int a)\n"
                "  {\n"
                "  switch (a)\n"
                "    {\n"
                "  case 0:\n"
                "    {\n"
                "    foo(x);\n"
                "    }\n"
                "    break;\n"
                "  default:\n"
                "    {\n"
                "    foo(1);\n"
                "    }\n"
                "    break;\n"
                "    }\n"
-               "  }\n",
+               "  }",
                WhitesmithsBraceStyle);
 
   verifyFormat("enum X\n"
                "  {\n"
                "  Y = 0, // testing\n"
-               "  }\n",
+               "  }",
                WhitesmithsBraceStyle);
 
   verifyFormat("enum X\n"
                "  {\n"
                "  Y = 0\n"
-               "  }\n",
+               "  }",
                WhitesmithsBraceStyle);
   verifyFormat("enum X\n"
                "  {\n"
                "  Y = 0,\n"
                "  Z = 1\n"
-               "  };\n",
+               "  };",
                WhitesmithsBraceStyle);
 
   verifyFormat("@interface BSApplicationController ()\n"
                "  {\n"
                "@private\n"
                "  id _extraIvar;\n"
                "  }\n"
-               "@end\n",
+               "@end",
                WhitesmithsBraceStyle);
 
   verifyFormat("#ifdef _DEBUG\n"
                "int foo(int i = 0)\n"
                "#else\n"
                "int foo(int i = 5)\n"
                "#endif\n"
                "  {\n"
BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
       FormatStyle::SIS_OnlyFirstIf;
   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
   verifyFormat("void f(bool b)\n"
                "  {\n"
                "  if (b)\n"
                "    {\n"
                "    return;\n"
                "    }\n"
-               "  }\n",
+               "  }",
                BreakBeforeBraceShortIfs);
   verifyFormat("void f(bool b)\n"
                "  {\n"
                "  if (b) return;\n"
-               "  }\n",
+               "  }",
                BreakBeforeBraceShortIfs);
   verifyFormat("void f(bool b)\n"
                "  {\n"
                "  while (b)\n"
                "    {\n"
                "    return;\n"
                "    }\n"
-               "  }\n",
+               "  }",
                BreakBeforeBraceShortIfs);
 }
 
 TEST_F(FormatTest, GNUBraceBreaking) {
   FormatStyle GNUBraceStyle = getLLVMStyle();
   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
   verifyFormat("namespace a\n"
                "{\n"
verifyFormat("void f()\n"
                "  else if (false)\n"
                "    {\n"
                "      b();\n"
                "    }\n"
                "  else\n"
                "    {\n"
                "      c();\n"
                "    }\n"
-               "}\n",
+               "}",
                GNUBraceStyle);
 
   verifyFormat("void f()\n"
                "{\n"
                "  for (int i = 0; i < 10; ++i)\n"
                "    {\n"
                "      a();\n"
                "    }\n"
                "  while (false)\n"
                "    {\n"
                "      b();\n"
                "    }\n"
                "  do\n"
                "    {\n"
                "      c();\n"
                "    }\n"
                "  while (false);\n"
-               "}\n",
+               "}",
                GNUBraceStyle);
 
   verifyFormat("void f(int a)\n"
                "{\n"
                "  switch (a)\n"
                "    {\n"
                "    case 0:\n"
                "      break;\n"
                "    case 1:\n"
                "      {\n"
                "        break;\n"
                "      }\n"
                "    case 2:\n"
                "      {\n"
                "      }\n"
                "      break;\n"
                "    default:\n"
                "      break;\n"
                "    }\n"
-               "}\n",
+               "}",
                GNUBraceStyle);
 
   verifyFormat("enum X\n"
                "{\n"
                "  Y = 0,\n"
-               "}\n",
+               "}",
                GNUBraceStyle);
 
   verifyFormat("@interface BSApplicationController ()\n"
                "{\n"
                "@private\n"
                "  id _extraIvar;\n"
                "}\n"
-               "@end\n",
+               "@end",
                GNUBraceStyle);
 
   verifyFormat("#ifdef _DEBUG\n"
                "int foo(int i = 0)\n"
                "#else\n"
                "int foo(int i = 5)\n"
                "#endif\n"
                "{\n"
verifyFormat("namespace a {\n"
                "  A,\n"
                "  // foo\n"
                "  B,\n"
                "  C\n"
                "};\n"
                "struct B {\n"
                "  int x;\n"
                "};\n"
-               "}\n",
+               "}",
                WebKitBraceStyle);
   verifyFormat("struct S {\n"
                "  int Type;\n"
                "  union {\n"
                "    int x;\n"
                "    double y;\n"
                "  } Value;\n"
                "  class C {\n"
                "    MyFavoriteType Value;\n"
                "  } Class;\n"
-               "};\n",
+               "};",
                WebKitBraceStyle);
 }
 
 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
   verifyFormat("void f() {\n"
                "  try {\n"
                "  } catch (const Exception &e) {\n"
                "  }\n"
-               "}\n");
+               "}");
 }
 
 TEST_F(FormatTest, CatchAlignArrayOfStructuresRightAlignment) {
   auto Style = getLLVMStyle();
   Style.AlignArrayOfStructures = FormatStyle::AIAS_Right;
   Style.AlignConsecutiveAssignments.Enabled = true;
   Style.AlignConsecutiveDeclarations.Enabled = true;
   verifyFormat("struct test demo[] = {\n"
                "    {56,    23, \"hello\"},\n"
                "    {-1, 93463, \"world\"},\n"
                "    { 7,     5,    \"!!\"}\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("struct test demo[] = {\n"
                "    {56,    23, \"hello\"}, // first line\n"
                "    {-1, 93463, \"world\"}, // second line\n"
                "    { 7,     5,    \"!!\"}  // third line\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("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"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("struct test demo[3] = {\n"
                "    {56,    23, \"hello\"},\n"
                "    {-1, 93463, \"world\"},\n"
                "    { 7,     5,    \"!!\"}\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("struct test demo[3] = {\n"
                "    {int{56},    23, \"hello\"},\n"
                "    {int{-1}, 93463, \"world\"},\n"
                "    { int{7},     5,    \"!!\"}\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("struct test demo[] = {\n"
                "    {56,    23, \"hello\"},\n"
                "    {-1, 93463, \"world\"},\n"
                "    { 7,     5,    \"!!\"},\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("test demo[] = {\n"
                "    {56,    23, \"hello\"},\n"
                "    {-1, 93463, \"world\"},\n"
                "    { 7,     5,    \"!!\"},\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("demo = std::array<struct test, 3>{\n"
                "    test{56,    23, \"hello\"},\n"
                "    test{-1, 93463, \"world\"},\n"
                "    test{ 7,     5,    \"!!\"},\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("test demo[] = {\n"
                "    {56,    23, \"hello\"},\n"
                "#if X\n"
                "    {-1, 93463, \"world\"},\n"
                "#endif\n"
                "    { 7,     5,    \"!!\"}\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat(
       "test demo[] = {\n"
       "    { 7,    23,\n"
       "     \"hello world i am a very long line that really, in any\"\n"
       "     \"just world, ought to be split over multiple lines\"},\n"
       "    {-1, 93463,                                  \"world\"},\n"
       "    {56,     5,                                     \"!!\"}\n"
-      "};\n",
+      "};",
       Style);
 
   verifyFormat("return GradForUnaryCwise(g, {\n"
                "                                {{\"sign\"}, \"Sign\",  "
                "  {\"x\", \"dy\"}},\n"
                "                                {  {\"dx\"},  \"Mul\", {\"dy\""
                ", \"sign\"}},\n"
-               "});\n",
+               "});",
                Style);
 
   Style.ColumnLimit = 0;
   EXPECT_EQ(
       "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 "
              "that really, in any just world, ought to be split over multiple "
              "lines\"},{-1, 93463, \"world\"},{7, 5, \"!!\"},};",
              Style));
 
   Style.ColumnLimit = 80;
   verifyFormat("test demo[] = {\n"
                "    {56,    23, /* a comment */ \"hello\"},\n"
                "    {-1, 93463,                 \"world\"},\n"
                "    { 7,     5,                    \"!!\"}\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("test demo[] = {\n"
                "    {56,    23,                    \"hello\"},\n"
                "    {-1, 93463, \"world\" /* comment here */},\n"
                "    { 7,     5,                       \"!!\"}\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("test demo[] = {\n"
                "    {56, /* a comment */ 23, \"hello\"},\n"
                "    {-1,              93463, \"world\"},\n"
                "    { 7,                  5,    \"!!\"}\n"
-               "};\n",
+               "};",
                Style);
 
   Style.ColumnLimit = 20;
   EXPECT_EQ(
       "demo = std::array<\n"
       "    struct test, 3>{\n"
       "    test{\n"
       "         56,    23,\n"
verifyFormat("struct test demo[] = {\n"
                "    {-1, 93463, \"world\"},\n"
                "    { 7,     5,    \"!!\"}\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"
-               "};\n",
+               "};",
                Style);
   EXPECT_EQ(
       "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 "
              "that really, in any just world, ought to be split over multiple "
              "lines\", 23},{-1, \"world\", 93463},{7, \"!!\", 5},};",
              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"
                "    Section{1, boo()  }\n"
-               "};\n",
+               "};",
                Style);
   */
   verifyFormat("auto foo = Items{\n"
                "    Section{\n"
                "            0, bar(),\n"
                "            }\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct test demo[] = {\n"
                "    {56, 23,    \"hello\"},\n"
                "    {-1, 93463, \"world\"},\n"
                "    {7,  5,     \"!!\"   }\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct test demo[] = {\n"
                "    {56, 23,    \"hello\"}, // first line\n"
                "    {-1, 93463, \"world\"}, // second line\n"
                "    {7,  5,     \"!!\"   }  // third line\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("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"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct test demo[3] = {\n"
                "    {56, 23,    \"hello\"},\n"
                "    {-1, 93463, \"world\"},\n"
                "    {7,  5,     \"!!\"   }\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("struct test demo[3] = {\n"
                "    {int{56}, 23,    \"hello\"},\n"
                "    {int{-1}, 93463, \"world\"},\n"
                "    {int{7},  5,     \"!!\"   }\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("struct test demo[] = {\n"
                "    {56, 23,    \"hello\"},\n"
                "    {-1, 93463, \"world\"},\n"
                "    {7,  5,     \"!!\"   },\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("test demo[] = {\n"
                "    {56, 23,    \"hello\"},\n"
                "    {-1, 93463, \"world\"},\n"
                "    {7,  5,     \"!!\"   },\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("demo = std::array<struct test, 3>{\n"
                "    test{56, 23,    \"hello\"},\n"
                "    test{-1, 93463, \"world\"},\n"
                "    test{7,  5,     \"!!\"   },\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("test demo[] = {\n"
                "    {56, 23,    \"hello\"},\n"
                "#if X\n"
                "    {-1, 93463, \"world\"},\n"
                "#endif\n"
                "    {7,  5,     \"!!\"   }\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat(
       "test demo[] = {\n"
       "    {7,  23,\n"
       "     \"hello world i am a very long line that really, in any\"\n"
       "     \"just world, ought to be split over multiple lines\"},\n"
       "    {-1, 93463, \"world\"                                 },\n"
       "    {56, 5,     \"!!\"                                    }\n"
-      "};\n",
+      "};",
       Style);
 
   verifyFormat("return GradForUnaryCwise(g, {\n"
                "                                {{\"sign\"}, \"Sign\", {\"x\", "
                "\"dy\"}   },\n"
                "                                {{\"dx\"},   \"Mul\",  "
                "{\"dy\", \"sign\"}},\n"
-               "});\n",
+               "});",
                Style);
 
   Style.ColumnLimit = 0;
   EXPECT_EQ(
       "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 "
              "that really, in any just world, ought to be split over multiple "
              "lines\"},{-1, 93463, \"world\"},{7, 5, \"!!\"},};",
              Style));
 
   Style.ColumnLimit = 80;
   verifyFormat("test demo[] = {\n"
                "    {56, 23,    /* a comment */ \"hello\"},\n"
                "    {-1, 93463, \"world\"                },\n"
                "    {7,  5,     \"!!\"                   }\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("test demo[] = {\n"
                "    {56, 23,    \"hello\"                   },\n"
                "    {-1, 93463, \"world\" /* comment here */},\n"
                "    {7,  5,     \"!!\"                      }\n"
-               "};\n",
+               "};",
                Style);
 
   verifyFormat("test demo[] = {\n"
                "    {56, /* a comment */ 23, \"hello\"},\n"
                "    {-1, 93463,              \"world\"},\n"
                "    {7,  5,                  \"!!\"   }\n"
-               "};\n",
+               "};",
                Style);
 
   Style.ColumnLimit = 20;
   EXPECT_EQ(
       "demo = std::array<\n"
       "    struct test, 3>{\n"
       "    test{\n"
       "         56, 23,\n"
EXPECT_EQ("int a; /* first line\n"
             "        * second line\n"
             "        * third line\n"
             "        */",
             format("int a; /* first line second line third line"
                    "\n*/",
                    Style));
 
   EXPECT_EQ("// foo bar baz bazfoo\n"
-            "// foo bar foo bar\n",
+            "// foo bar foo bar",
             format("// foo bar baz bazfoo\n"
-                   "// foo bar foo           bar\n",
+                   "// foo bar foo           bar",
                    Style));
   EXPECT_EQ("// foo bar baz bazfoo\n"
-            "// foo bar foo bar\n",
+            "// foo bar foo bar",
             format("// foo bar baz      bazfoo\n"
-                   "// foo            bar foo bar\n",
+                   "// foo            bar foo bar",
                    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"
-            "// bar foo bar\n",
+            "// bar foo bar",
             format("// foo bar baz      bazfoo bar\n"
-                   "// foo            bar\n",
+                   "// foo            bar",
                    Style));
 
   EXPECT_EQ("// foo bar baz bazfoo\n"
             "// foo bar baz bazfoo\n"
-            "// bar foo bar\n",
+            "// bar foo bar",
             format("// foo bar baz      bazfoo\n"
                    "// foo bar baz      bazfoo bar\n"
-                   "// foo bar\n",
+                   "// foo bar",
                    Style));
 
   EXPECT_EQ("// foo bar baz bazfoo\n"
             "// foo bar baz bazfoo\n"
-            "// bar foo bar\n",
+            "// bar foo bar",
             format("// foo bar baz      bazfoo\n"
                    "// foo bar baz      bazfoo bar\n"
-                   "// foo           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(
       "// foo foo foo foo\n"
       "// foo foo foo foo\n"
-      "// foo foo foo foo\n",
-      format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
+      "// foo foo foo foo",
+      format("// foo foo foo foo foo foo foo foo foo foo foo foo", Style));
 
   EXPECT_EQ("int a = /* long block\n"
             "           comment */\n"
             "    42;",
             format("int a = /* long block comment */ 42;", Style));
 }
 
 TEST_F(FormatTest, BreakPenaltyAfterLParen) {
verifyFormat("SomeClass::Constructor()\n"
                ", b(b)\n"
                ", c(c) {}",
                Style);
 
   Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
   Style.ConstructorInitializerIndentWidth = 4;
   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
   verifyFormat(
-      "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
+      "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)",
       Style);
   verifyFormat(
       "SomeClass::Constructor()\n"
       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
       Style);
   Style.PackConstructorInitializers = FormatStyle::PCIS_NextLineOnly;
   verifyFormat("SomeClass::Constructor()\n"
                "    : aaaaaaaa(aaaaaaaa) {}",
                Style);
   verifyFormat("SomeClass::Constructor()\n"
-               "    : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
+               "    : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)",
                Style);
   verifyFormat(
       "SomeClass::Constructor()\n"
       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
       Style);
 
   Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
   Style.ConstructorInitializerIndentWidth = 4;
TEST_F(FormatTest, FormatsWithWebKitStyle) {
   EXPECT_EQ("[self.a b:c\n"
             "        c:d];",
             format("[self.a b:c\n"
                    "c:d];",
                    Style));
 }
 
 TEST_F(FormatTest, FormatsLambdas) {
-  verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
+  verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();");
   verifyFormat(
-      "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
-  verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
-  verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
-  verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
-  verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
-  verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
-  verifyFormat("auto c = [a = [b = 42] {}] {};\n");
-  verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
+      "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();");
+  verifyFormat("int c = [&] { [=] { return b++; }(); }();");
+  verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();");
+  verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();");
+  verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}");
+  verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}");
+  verifyFormat("auto c = [a = [b = 42] {}] {};");
+  verifyFormat("auto c = [a = &i + 10, b = [] {}] {};");
   verifyFormat("int x = f(*+[] {});");
   verifyFormat("void f() {\n"
                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
-               "}\n");
+               "}");
   verifyFormat("void f() {\n"
                "  other(x.begin(), //\n"
                "        x.end(),   //\n"
                "        [&](int, int) { return 1; });\n"
-               "}\n");
+               "}");
   verifyFormat("void f() {\n"
                "  other.other.other.other.other(\n"
                "      x.begin(), x.end(),\n"
                "      [something, rather](int, int, int, int, int, int, int) { "
                "return 1; });\n"
-               "}\n");
+               "}");
   verifyFormat(
       "void f() {\n"
       "  other.other.other.other.other(\n"
       "      x.begin(), x.end(),\n"
       "      [something, rather](int, int, int, int, int, int, int) {\n"
       "        //\n"
       "      });\n"
-      "}\n");
+      "}");
   verifyFormat("SomeFunction([]() { // A cool function...\n"
                "  return 43;\n"
                "});");
   EXPECT_EQ("SomeFunction([]() {\n"
             "#define A a\n"
             "  return 43;\n"
             "});",
             format("SomeFunction([](){\n"
verifyFormat("SomeFunction({[&] {\n"
                "  // comment\n"
                "}});");
   verifyFormat(
       "virtual aaaaaaaaaaaaaaaa(\n"
       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
       "    aaaaa aaaaaaaaa);");
 
   // Lambdas with return types.
-  verifyFormat("int c = []() -> int { return 2; }();\n");
-  verifyFormat("int c = []() -> int * { return 2; }();\n");
-  verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
+  verifyFormat("int c = []() -> int { return 2; }();");
+  verifyFormat("int c = []() -> int * { return 2; }();");
+  verifyFormat("int c = []() -> vector<int> { return {2}; }();");
   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
   verifyFormat("foo([]() noexcept -> int {});");
   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
   verifyFormat("[a, a]() -> a<1> {};");
   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
TEST_F(FormatTest, FormatsLambdas) {
   verifyFormat("SomeFunction({[]() -> int[] { return {}; }});");
   verifyFormat("SomeFunction({[]() -> int *[] { return {}; }});");
   verifyFormat("SomeFunction({[]() -> int (*)[] { return {}; }});");
   verifyFormat("SomeFunction({[]() -> ns::type<int (*)[]> { return {}; }});");
   verifyFormat("return int{[x = x]() { return x; }()};");
 
   // Lambdas with explicit template argument lists.
   verifyFormat(
-      "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
+      "auto L = []<template <typename> class T, class U>(T<U> &&a) {};");
   verifyFormat("auto L = []<class T>(T) {\n"
                "  {\n"
                "    f();\n"
                "    g();\n"
                "  }\n"
-               "};\n");
+               "};");
   verifyFormat("auto L = []<class... T>(T...) {\n"
                "  {\n"
                "    f();\n"
                "    g();\n"
                "  }\n"
-               "};\n");
+               "};");
   verifyFormat("auto L = []<typename... T>(T...) {\n"
                "  {\n"
                "    f();\n"
                "    g();\n"
                "  }\n"
-               "};\n");
+               "};");
   verifyFormat("auto L = []<template <typename...> class T>(T...) {\n"
                "  {\n"
                "    f();\n"
                "    g();\n"
                "  }\n"
-               "};\n");
+               "};");
   verifyFormat("auto L = []</*comment*/ class... T>(T...) {\n"
                "  {\n"
                "    f();\n"
                "    g();\n"
                "  }\n"
-               "};\n");
+               "};");
   verifyFormat("auto L = []<int... T>(T...) {\n"
                "  {\n"
                "    f();\n"
                "    g();\n"
                "  }\n"
                "};");
   verifyFormat("auto L = []<Foo... T>(T...) {\n"
                "  {\n"
verifyFormat("SomeFunction(\n"
                "      //\n"
                "    });");
 
   // A multi-line lambda passed as arg0 is always pushed to the next line.
   verifyFormat("SomeFunction(\n"
                "    [this] {\n"
                "      //\n"
                "    },\n"
-               "    1);\n");
+               "    1);");
 
   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
   // the arg0 case above.
   auto Style = getGoogleStyle();
   Style.BinPackArguments = false;
   verifyFormat("SomeFunction(\n"
                "    a,\n"
                "    [this] {\n"
                "      //\n"
                "    },\n"
-               "    b);\n",
+               "    b);",
                Style);
   verifyFormat("SomeFunction(\n"
                "    a,\n"
                "    [this] {\n"
                "      //\n"
                "    },\n"
-               "    b);\n");
+               "    b);");
 
   // A lambda with a very long line forces arg0 to be pushed out irrespective of
   // the BinPackArguments value (as long as the code is wide enough).
   verifyFormat(
       "something->SomeFunction(\n"
       "    a,\n"
       "    [this] {\n"
       "      "
       "D0000000000000000000000000000000000000000000000000000000000001();\n"
       "    },\n"
-      "    b);\n");
+      "    b);");
 
   // A multi-line lambda is pulled up as long as the introducer fits on the
   // previous line and there are no further args.
   verifyFormat("function(1, [this, that] {\n"
                "  //\n"
-               "});\n");
+               "});");
   verifyFormat("function([this, that] {\n"
                "  //\n"
-               "});\n");
+               "});");
   // FIXME: this format is not ideal and we should consider forcing the first
   // arg onto its own line.
   verifyFormat("function(a, b, c, //\n"
                "         d, [this, that] {\n"
                "           //\n"
-               "         });\n");
+               "         });");
 
   // Multiple lambdas are treated correctly even when there is a short arg0.
   verifyFormat("SomeFunction(\n"
                "    1,\n"
                "    [this] {\n"
                "      //\n"
                "    },\n"
                "    [this] {\n"
                "      //\n"
                "    },\n"
-               "    1);\n");
+               "    1);");
 
   // More complex introducers.
   verifyFormat("return [i, args...] {};");
 
   // Not lambdas.
   verifyFormat("constexpr char hello[]{\"hello\"};");
   verifyFormat("double &operator[](int i) { return 0; }\n"
                "int i;");
verifyFormat("TwoNestedLambdas_SLS_All(\n"
                LLVMWithBeforeLambdaBody);
 
   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
       FormatStyle::ShortLambdaStyle::SLS_None;
 
   verifyFormat("auto select = [this]() -> const Library::Object *\n"
                "{\n"
                "  return MyAssignment::SelectFromList(this);\n"
-               "};\n",
+               "};",
                LLVMWithBeforeLambdaBody);
 
   verifyFormat("auto select = [this]() -> const Library::Object &\n"
                "{\n"
                "  return MyAssignment::SelectFromList(this);\n"
-               "};\n",
+               "};",
                LLVMWithBeforeLambdaBody);
 
   verifyFormat("auto select = [this]() -> std::unique_ptr<Object>\n"
                "{\n"
                "  return MyAssignment::SelectFromList(this);\n"
-               "};\n",
+               "};",
                LLVMWithBeforeLambdaBody);
 
   verifyFormat("namespace test {\n"
                "class Test {\n"
                "public:\n"
                "  Test() = default;\n"
                "};\n"
                "} // namespace test",
                LLVMWithBeforeLambdaBody);
 
   // Lambdas with different indentation styles.
   Style = getLLVMStyleWithColumns(60);
   verifyFormat("Result doSomething(Promise promise) {\n"
                "  return promise.then(\n"
                "      [this, obj = std::move(s)](int bar) mutable {\n"
                "        return someObject.startAsyncAction().then(\n"
                "            [this, &obj](Result result) mutable {\n"
                "              result.processMore();\n"
                "            });\n"
                "      });\n"
-               "}\n",
+               "}",
                Style);
   Style.LambdaBodyIndentation = FormatStyle::LBI_OuterScope;
   verifyFormat("Result doSomething(Promise promise) {\n"
                "  return promise.then(\n"
                "      [this, obj = std::move(s)](int bar) mutable {\n"
                "    return obj.startAsyncAction().then(\n"
                "        [this, &obj](Result result) mutable {\n"
                "      result.processMore();\n"
                "    });\n"
                "  });\n"
-               "}\n",
+               "}",
                Style);
   verifyFormat("Result doSomething(Promise promise) {\n"
                "  return promise.then([this, obj = std::move(s)] {\n"
                "    return obj.startAsyncAction().then(\n"
                "        [this, &obj](Result result) mutable {\n"
                "      result.processMore();\n"
                "    });\n"
                "  });\n"
-               "}\n",
+               "}",
                Style);
   verifyFormat("void test() {\n"
                "  ([]() -> auto {\n"
                "    int b = 32;\n"
                "    return 3;\n"
                "  }).foo();\n"
                "}",
                Style);
   verifyFormat("void test() {\n"
                "  []() -> auto {\n"
                "    int b = 32;\n"
                "    return 3;\n"
                "  }\n"
                "}",
                Style);
   verifyFormat("std::sort(v.begin(), v.end(),\n"
                "          [](const auto &foo, const auto &bar) {\n"
                "  return foo.baz < bar.baz;\n"
-               "});\n",
+               "});",
                Style);
   verifyFormat("void test() {\n"
                "  (\n"
                "      []() -> auto {\n"
                "    int b = 32;\n"
                "    return 3;\n"
                "  },\n"
                "      foo, bar)\n"
verifyFormat("[[SessionService sharedService]\n"
                "      if (window) {\n"
                "        [self windowDidLoad:window];\n"
                "      } else {\n"
                "        [self errorLoadingWindow];\n"
                "      }\n"
                "    }];");
   verifyFormat("void (^largeBlock)(void) = ^{\n"
                "  // ...\n"
-               "};\n",
+               "};",
                getLLVMStyleWithColumns(40));
   verifyFormat("[[SessionService sharedService]\n"
                "    loadWindowWithCompletionBlock: //\n"
                "        ^(SessionWindow *window) {\n"
                "          if (window) {\n"
                "            [self windowDidLoad:window];\n"
                "          } else {\n"
                "            [self errorLoadingWindow];\n"
EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
             "  int i;\n"
             "};",
             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
 }
 
 TEST_F(FormatTest, SupportsCRLF) {
   EXPECT_EQ("int a;\r\n"
             "int b;\r\n"
-            "int c;\r\n",
+            "int c;",
             format("int a;\r\n"
                    "  int b;\r\n"
-                   "    int c;\r\n"));
+                   "    int c;"));
   EXPECT_EQ("int a;\r\n"
             "int b;\r\n"
             "int c;\r\n",
             format("int a;\r\n"
                    "  int b;\n"
                    "    int c;\r\n"));
   EXPECT_EQ("int a;\n"
             "int b;\n"
-            "int c;\n",
+            "int c;",
             format("int a;\r\n"
                    "  int b;\n"
-                   "    int c;\n"));
+                   "    int c;"));
   EXPECT_EQ("\"aaaaaaa \"\r\n"
             "\"bbbbbbb\";\r\n",
             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
   EXPECT_EQ("#define A \\\r\n"
             "  b;      \\\r\n"
             "  c;      \\\r\n"
-            "  d;\r\n",
+            "  d;",
             format("#define A \\\r\n"
                    "  b; \\\r\n"
-                   "  c; d; \r\n",
+                   "  c; d; ",
                    getGoogleStyle()));
 
   EXPECT_EQ("/*\r\n"
             "multi line block comments\r\n"
             "should not introduce\r\n"
             "an extra carriage return\r\n"
-            "*/\r\n",
+            "*/",
             format("/*\r\n"
                    "multi line block comments\r\n"
                    "should not introduce\r\n"
                    "an extra carriage return\r\n"
-                   "*/\r\n"));
+                   "*/"));
   EXPECT_EQ("/*\r\n"
             "\r\n"
             "*/",
             format("/*\r\n"
                    "    \r\r\r\n"
                    "*/"));
 
   FormatStyle style = getLLVMStyle();
TEST_F(FormatTest, SpacesInAngles) {
   verifyFormat("A<A<int>>();", Spaces);
   verifyFormat("A< A< int > >();", Spaces);
   verifyFormat("A<A<int > >();", Spaces);
   verifyFormat("A< A< int>>();", Spaces);
 
   Spaces.SpacesInAngles = FormatStyle::SIAS_Always;
   verifyFormat("// clang-format off\n"
                "foo<<<1, 1>>>();\n"
-               "// clang-format on\n",
+               "// clang-format on",
                Spaces);
   verifyFormat("// clang-format off\n"
                "foo< < <1, 1> > >();\n"
-               "// clang-format on\n",
+               "// clang-format on",
                Spaces);
 }
 
 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
   FormatStyle Style = getLLVMStyle();
   Style.SpaceAfterTemplateKeyword = false;
   verifyFormat("template<int> void foo();", Style);
 }
EXPECT_EQ("int a;\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);\n",
+            "         otherparameter);",
             format("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);\n"));
+                   "  otherparameter);"));
 
   // Perforce markers.
   EXPECT_EQ("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);\n",
+            "      parameter);",
             format("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);\n"));
+                   "  parameter);"));
 
   EXPECT_EQ("<<<<<<<\n"
             "|||||||\n"
             "=======\n"
             ">>>>>>>",
             format("<<<<<<<\n"
                    "|||||||\n"
                    "=======\n"
TEST_F(FormatTest, HandleConflictMarkers) {
   EXPECT_EQ("#define Macro \\\n"
             "<<<<<<<\n"
             "Something \\\n"
             "|||||||\n"
             "Else \\\n"
             "=======\n"
             "Other \\\n"
             ">>>>>>>\n"
-            "    End int i;\n",
+            "    End int i;",
             format("#define Macro \\\n"
                    "<<<<<<<\n"
                    "  Something \\\n"
                    "|||||||\n"
                    "  Else \\\n"
                    "=======\n"
                    "  Other \\\n"
                    ">>>>>>>\n"
                    "  End\n"
-                   "int i;\n"));
+                   "int i;"));
 
   verifyFormat(R"(====
 #ifdef A
 a
 #else
 b
 #endif
 )");
TEST_F(FormatTest, DisableRegions) {
   EXPECT_EQ("// 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 */\n",
+            "/* long long long long long long line */",
             format("// 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 */\n",
+                   "/* long long long long long long line */",
                    getLLVMStyleWithColumns(20)));
 
   verifyFormat("int *i;\n"
                "// clang-format off:\n"
                "int* j;\n"
                "// clang-format on: 1\n"
                "int *k;",
                "int* i;\n"

 }
 
 TEST_F(FormatTest, FileAndCode) {
   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
   EXPECT_EQ(FormatStyle::LK_ObjC,
-            guessLanguage("foo.h", "@interface Foo\n@end\n"));
+            guessLanguage("foo.h", "@interface Foo\n@end"));
   EXPECT_EQ(
       FormatStyle::LK_ObjC,
       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
   EXPECT_EQ(FormatStyle::LK_ObjC,
             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
+  EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo", "@interface Foo\n@end"));
   EXPECT_EQ(FormatStyle::LK_ObjC,
-            guessLanguage("foo", "@interface Foo\n@end\n"));
+            guessLanguage("foo.h", "int DoStuff(CGRect rect);"));
   EXPECT_EQ(FormatStyle::LK_ObjC,
-            guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
-  EXPECT_EQ(
-      FormatStyle::LK_ObjC,
-      guessLanguage("foo.h",
-                    "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
+            guessLanguage(
+                "foo.h", "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));"));
   EXPECT_EQ(
       FormatStyle::LK_Cpp,
       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
   // Only one of the two preprocessor regions has ObjC-like code.
   EXPECT_EQ(FormatStyle::LK_ObjC,
             guessLanguage("foo.h", "#if A\n"
                                    "#define B() C\n"
                                    "#else\n"
                                    "#define B() [NSString a:@\"\"]\n"
-                                   "#endif\n"));
+                                   "#endif"));
 }
 
 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
   EXPECT_EQ(FormatStyle::LK_ObjC,
             guessLanguage("foo.h", "array[[calculator getIndex]];"));
   EXPECT_EQ(FormatStyle::LK_Cpp,
             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
   verifyFormat("foo(-42, operator, );", Style);
   verifyFormat("foo(operator, , -42);", Style);
 }
 
 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
   FormatStyle Style = getLLVMStyle();
   Style.WhitespaceSensitiveMacros.push_back("FOO");
 
   // Newlines are important here.
-  verifyFormat("FOO(1+2 )\n", Style);
-  verifyFormat("FOO(a:b:c)\n", Style);
+  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
   verifyFormat("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style);
   EXPECT_EQ(
       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
   verifyFormat("FOO(String-ized&Messy+But,: :Still=Intentional);", Style);
verifyFormat("if (argc > 5) [[likely]] {\n"
                "  return 29;\n"
                "}",
                Style);
 
   verifyFormat("if (argc > 5) [[unlikely]] {\n"
                "  return 29;\n"
                "} else [[likely]] {\n"
                "  return 42;\n"
-               "}\n",
+               "}",
                Style);
 
   verifyFormat("if (argc > 5) [[unlikely]] {\n"
                "  return 29;\n"
                "} else if (argc > 10) [[likely]] {\n"
                "  return 99;\n"
                "} else {\n"
                "  return 42;\n"
-               "}\n",
+               "}",
                Style);
 
   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
                "  return 29;\n"
                "}",
                Style);
 
   verifyFormat("if (argc > 5) [[unlikely]]\n"
-               "  return 29;\n",
+               "  return 29;",
                Style);
   verifyFormat("if (argc > 5) [[likely]]\n"
-               "  return 29;\n",
+               "  return 29;",
                Style);
 
   verifyFormat("while (limit > 0) [[unlikely]] {\n"
                "  --limit;\n"
                "}",
                Style);
   verifyFormat("for (auto &limit : limits) [[likely]] {\n"
                "  --limit;\n"
                "}",
                Style);
 
   verifyFormat("for (auto &limit : limits) [[unlikely]]\n"
                "  --limit;",
                Style);
   verifyFormat("while (limit > 0) [[likely]]\n"
                "  --limit;",
                Style);
 
   Style.AttributeMacros.push_back("UNLIKELY");
   Style.AttributeMacros.push_back("LIKELY");
   verifyFormat("if (argc > 5) UNLIKELY\n"
-               "  return 29;\n",
+               "  return 29;",
                Style);
 
   verifyFormat("if (argc > 5) UNLIKELY {\n"
                "  return 29;\n"
                "}",
                Style);
   verifyFormat("if (argc > 5) UNLIKELY {\n"
                "  return 29;\n"
                "} else [[likely]] {\n"
                "  return 42;\n"
-               "}\n",
+               "}",
                Style);
   verifyFormat("if (argc > 5) UNLIKELY {\n"
                "  return 29;\n"
                "} else LIKELY {\n"
                "  return 42;\n"
-               "}\n",
+               "}",
                Style);
   verifyFormat("if (argc > 5) [[unlikely]] {\n"
                "  return 29;\n"
                "} else LIKELY {\n"
                "  return 42;\n"
-               "}\n",
+               "}",
                Style);
 
   verifyFormat("for (auto &limit : limits) UNLIKELY {\n"
                "  --limit;\n"
                "}",
                Style);
   verifyFormat("while (limit > 0) LIKELY {\n"
                "  --limit;\n"

 
 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"
                "    int i;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("union C {\n"
                "    int i;\n"
                "    unsigned u;\n"
-               "};\n",
+               "};",
                Style);
   // Access modifiers should be indented one level below the record.
   verifyFormat("class C {\n"
                "  public:\n"
                "    int i;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("class C {\n"
                "  public /* comment */:\n"
                "    int i;\n"
                "};",
                Style);
   verifyFormat("struct S {\n"
                "  private:\n"
                "    class C {\n"
                "        int j;\n"
                "\n"
                "      public:\n"
                "        C();\n"
                "    };\n"
                "\n"
                "  public:\n"
                "    int i;\n"
-               "};\n",
+               "};",
                Style);
   // Enumerations are not records and should be unaffected.
   Style.AllowShortEnumsOnASingleLine = false;
   verifyFormat("enum class E {\n"
                "  A,\n"
                "  B\n"
-               "};\n",
+               "};",
                Style);
   // Test with a different indentation width;
   // also proves that the result is Style.AccessModifierOffset agnostic.
   Style.IndentWidth = 3;
   verifyFormat("class C {\n"
                "   public:\n"
                "      int i;\n"
-               "};\n",
+               "};",
                Style);
   verifyFormat("class C {\n"
                "   public /**/:\n"
                "      int i;\n"
                "};",
                Style);
 }
 

 TEST_F(FormatTest, EmptyShortBlock) {
   auto Style = getLLVMStyle();
   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
 
   verifyFormat("try {\n"
                "  doA();\n"
                "} catch (Exception &e) {\n"
                "  e.printStackTrace();\n"
-               "}\n",
+               "}",
                Style);
 
   verifyFormat("try {\n"
                "  doA();\n"
-               "} catch (Exception &e) {}\n",
+               "} catch (Exception &e) {}",
                Style);
 }
 
 TEST_F(FormatTest, ShortTemplatedArgumentLists) {
   auto Style = getLLVMStyle();
 
-  verifyFormat("template <> struct S : Template<int (*)[]> {};\n", Style);
-  verifyFormat("template <> struct S : Template<int (*)[10]> {};\n", Style);
+  verifyFormat("template <> struct S : Template<int (*)[]> {};", Style);
+  verifyFormat("template <> struct S : Template<int (*)[10]> {};", Style);
   verifyFormat("struct Y : X<[] { return 0; }> {};", Style);
   verifyFormat("struct Y<[] { return 0; }> {};", Style);
 
   verifyFormat("struct Z : X<decltype([] { return 0; }){}> {};", Style);
   verifyFormat("template <int N> struct Foo<char[N]> {};", Style);
 }
 
 TEST_F(FormatTest, MultilineLambdaInConditional) {
verifyFormat("struct Foo {\n"
                "}",
                CtorDtorCode, Style);
 }
 
 TEST_F(FormatTest, InsertNewlineAtEOF) {
   FormatStyle Style = getLLVMStyle();
   Style.InsertNewlineAtEOF = true;
 
-  verifyFormat("int i;\n", Style);
+  verifyNoChange("int i;\n", Style);
   verifyFormat("int i;\n", "int i;", Style);
 }
 
 TEST_F(FormatTest, KeepEmptyLinesAtEOF) {
   FormatStyle Style = getLLVMStyle();
   Style.KeepEmptyLinesAtEOF = true;
 
   const StringRef Code{"int i;\n\n"};
verifyFormat("class Foo {\n"
                "  int interface;\n"
                "  Foo::Foo(int iface) : interface{iface} {}\n"
                "}");
 }
 
 TEST_F(FormatTest, PreprocessorOverlappingRegions) {
   verifyFormat("#ifdef\n\n"
                "#else\n"
-               "#endif\n",
+               "#endif",
                "#ifdef \n"
                "    \n"
                "\n"
                "#else \n"
-               "#endif \n",
+               "#endif ",
                getGoogleStyle());
 }
 
 TEST_F(FormatTest, RemoveParentheses) {
   FormatStyle Style = getLLVMStyle();
   EXPECT_EQ(Style.RemoveParentheses, FormatStyle::RPS_Leave);
 
   Style.RemoveParentheses = FormatStyle::RPS_MultipleParentheses;