[clang-format] NFC - clang-format the FormatTests

[MyDeveloperDay]

Summary

Ensure the clang-format unit tests are themselves clang-formatted

Having areas of the llvm code which are clang-format clean, give us more areas to run new clang-format binaries on ensuring we haven't broken anything.

It seems to me we SHOULD have this clang-formatted at a minimum, otherwise how can we expect others to use clang-format if we "don't eat our own dogfood", also if the tests are dependent on the formatting of the code then that would also be bad!

[sammccall]

Makes sense to me!

clang/unittests/Format/CleanupTest.cpp

TEST_F(CleanUpReplacementsTest, NoNewLineAtTheEndOfCodeMultipleInsertions) {
   std::string Expected =
       "#include <map>\n#include <string>\n\n#include <vector>\n";
   tooling::Replacements Replaces =
       toReplacements({createInsertion("#include <string>"),
                       createInsertion("#include <vector>")});
   EXPECT_EQ(Expected, apply(Code, Replaces));
 }
 
-
 TEST_F(CleanUpReplacementsTest, FormatCorrectLineWhenHeadersAreInserted) {
   std::string Code = "\n"
                      "int x;\n"
                      "int    a;\n"
                      "int    a;\n"
                      "int    a;";
 
   std::string Expected = "\n#include \"x.h\"\n"

clang/unittests/Format/FormatTestCSharp.cpp

if (someThings[i][j][k].Contains(myThing)) {
                Style);
 }
 
 TEST_F(FormatTestCSharp, CSharpGenericTypeConstraints) {
   FormatStyle Style = getGoogleStyle(FormatStyle::LK_CSharp);
 
   verifyFormat(R"(//
 class ItemFactory<T>
-    where T : new() {})", Style);
+    where T : new() {})",
+               Style);
 
   verifyFormat(R"(//
 class Dictionary<TKey, TVal>
     where TKey : IComparable<TKey>
     where TVal : IMyInterface {
   public void MyMethod<T>(T t)
       where T : IMyInterface { doThing(); }
 })",

clang/unittests/Format/FormatTestComments.cpp

 namespace clang {
 namespace format {
 namespace {
 
 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
 
 class FormatTestComments : public ::testing::Test {
 protected:
-  enum StatusCheck {
-    SC_ExpectComplete,
-    SC_ExpectIncomplete,
-    SC_DoNotCheck
-  };
+  enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck };
 
   std::string format(llvm::StringRef Code,
                      const FormatStyle &Style = getLLVMStyle(),
                      StatusCheck CheckComplete = SC_ExpectComplete) {
     LLVM_DEBUG(llvm::errs() << "---\n");
     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
     FormattingAttemptStatus Status;
EXPECT_EQ("/// line 1\n"
             "// line 6\n"
             "// line 7",
             format("///line 1\n"
                    "///line 2\n"
                    "//! line 3\n"
                    "//!line 4\n"
                    "//!line 5\n"
                    "// line 6\n"
-                   "//line 7", getLLVMStyleWithColumns(20)));
+                   "//line 7",
+                   getLLVMStyleWithColumns(20)));
 
   EXPECT_EQ("// aa bb cc dd",
             format("// aa bb             cc dd                   ",
                    getLLVMStyleWithColumns(15)));
 
   EXPECT_EQ("// A comment before\n"
             "// a macro\n"
             "// definition\n"
verifyFormat("int f() {\n"
                "#ifdef A // comment about A\n"
                "  // section comment 1\n"
                "  // section comment 2\n"
                "  i = 2;\n"
                "#else // comment about #else\n"
                "  // section comment 3\n"
                "  i = 4;\n"
                "#endif\n"
-               "}", getLLVMStyleWithColumns(80));
+               "}",
+               getLLVMStyleWithColumns(80));
 }
 
 TEST_F(FormatTestComments, AlignsPPElseEndifComments) {
   verifyFormat("#if A\n"
                "#else  // A\n"
                "int iiii;\n"
                "#endif // B",
                getLLVMStyleWithColumns(20));
EXPECT_EQ("int i; /* first line\n"
             format("int i; /* first line\n"
                    "        * second line\n"
                    "        * third line\n"
                    "        */",
                    getLLVMStyleWithColumns(20)));
 
   // Reflow the last two lines of a section that starts with a line having
   // different indentation.
-  EXPECT_EQ(
-      "//     long\n"
+  EXPECT_EQ("//     long\n"
             "// long long long\n"
             "// long long",
             format("//     long\n"
                    "// long long long long\n"
                    "// long",
                    getLLVMStyleWithColumns(20)));
 
   // Keep the block comment endling '*/' while reflowing.
   EXPECT_EQ("/* Long long long\n"
             " * line short */\n",
             format("/* Long long long line\n"
                    " * short */\n",
                    getLLVMStyleWithColumns(20)));
 
EXPECT_EQ("// long long long\n"
             format("// long long long long\n"
                    "// l",
                    getLLVMStyleWithColumns(20)));
 
   // Don't reflow lines starting with two punctuation characters.
   EXPECT_EQ("// long long long\n"
             "// long\n"
             "// ... --- ...",
-            format(
-                "// long long long long\n"
+            format("// long long long long\n"
                    "// ... --- ...",
                    getLLVMStyleWithColumns(20)));
 
   // Don't reflow lines starting with '@'.
   EXPECT_EQ("// long long long\n"
             "// long\n"
             "// @param arg",
             format("// long long long long\n"
                    "// @param arg",
                    getLLVMStyleWithColumns(20)));
EXPECT_EQ("/* long long long\n"
                    " * IWYU pragma:\n"
                    " */",
                    getLLVMStyleWithColumns(20)));
 
   // Reflow lines that have a non-punctuation character among their first 2
   // characters.
   EXPECT_EQ("// long long long\n"
             "// long 'long'",
-            format(
-                "// long long long long\n"
+            format("// long long long long\n"
                    "// 'long'",
                    getLLVMStyleWithColumns(20)));
 
   // Don't reflow between separate blocks of comments.
   EXPECT_EQ("/* First comment\n"
             " * block will */\n"
             "/* Snd\n"
             " */\n",
             format("/* First comment block\n"
                    " * will */\n"
EXPECT_EQ("/*\n"
                    getLLVMStyleWithColumns(10)));
   EXPECT_EQ("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
             "    /* line 1\n"
             "       bbbbbbbbbbbb */\n"
             "    bbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
             format("int aaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
                    "    /* line 1\n"
                    "       bbbbbbbbbbbb */ bbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
                    getLLVMStyleWithColumns(50)));
 
   FormatStyle NoBinPacking = getLLVMStyle();
   NoBinPacking.BinPackParameters = false;
   EXPECT_EQ("someFunction(1, /* comment 1 */\n"
             "             2, /* comment 2 */\n"
             "             3, /* comment 3 */\n"
             "             aaaa,\n"
             "             bbbb);",
EXPECT_EQ("int a; // line about a\n"
                    "       long b;",
                    getLLVMStyleWithColumns(80)));
 }
 
 TEST_F(FormatTestComments, AlignsBlockCommentDecorations) {
   EXPECT_EQ("/*\n"
             " */",
             format("/*\n"
-                   "*/", getLLVMStyle()));
+                   "*/",
+                   getLLVMStyle()));
   EXPECT_EQ("/*\n"
             " */",
             format("/*\n"
-                   " */", getLLVMStyle()));
+                   " */",
+                   getLLVMStyle()));
   EXPECT_EQ("/*\n"
             " */",
             format("/*\n"
-                   "  */", getLLVMStyle()));
+                   "  */",
+                   getLLVMStyle()));
 
   // Align a single line.
   EXPECT_EQ("/*\n"
             " * line */",
             format("/*\n"
                    "* line */",
                    getLLVMStyle()));
   EXPECT_EQ("/*\n"
EXPECT_EQ("/**\n"
                    getLLVMStyle()));
 
   // Align the end '*/' after a line.
   EXPECT_EQ("/*\n"
             " * line\n"
             " */",
             format("/*\n"
                    "* line\n"
-                   "*/", getLLVMStyle()));
+                   "*/",
+                   getLLVMStyle()));
   EXPECT_EQ("/*\n"
             " * line\n"
             " */",
             format("/*\n"
                    "   * line\n"
-                   "  */", getLLVMStyle()));
+                   "  */",
+                   getLLVMStyle()));
   EXPECT_EQ("/*\n"
             " * line\n"
             " */",
             format("/*\n"
                    "  * line\n"
-                   "  */", getLLVMStyle()));
+                   "  */",
+                   getLLVMStyle()));
 
   // Align two lines.
   EXPECT_EQ("/* line 1\n"
             " * line 2 */",
             format("/* line 1\n"
                    " * line 2 */",
                    getLLVMStyle()));
   EXPECT_EQ("/* line 1\n"
EXPECT_EQ("/*\n"
             " * line 3\n"
             " *   line 4\n"
             " */",
             format("/*\n"
                    "* line 1\n"
                    "  *  line 2\n"
                    "   * line 3\n"
                    "*   line 4\n"
-                   "*/", getLLVMStyle()));
+                   "*/",
+                   getLLVMStyle()));
 
   // Align empty or blank lines.
   EXPECT_EQ("/**\n"
             " *\n"
             " *\n"
             " *\n"
             " */",
             format("/**\n"
                    "*  \n"
                    " * \n"
                    "  *\n"
-                   "*/", getLLVMStyle()));
+                   "*/",
+                   getLLVMStyle()));
 
   // Align while breaking and reflowing.
   EXPECT_EQ("/*\n"
             " * long long long\n"
             " * long long\n"
             " *\n"
             " * long */",
             format("/*\n"
TEST_F(FormatTestComments, BreaksBeforeTrailingUnbreakableSequence) {
   // trailing sequence ); after it exceeds the column limit. Make sure we
   // correctly break the line in that case.
   verifyFormat("int a =\n"
                "    foo(/* trail */);",
                getLLVMStyleWithColumns(23));
 }
 
 TEST_F(FormatTestComments, ReflowBackslashCrash) {
   // clang-format off
   EXPECT_EQ(
 "// How to run:\n"
 "// bbbbb run \\\n"
 "// rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr\n"
 "// \\ <log_file> -- --output_directory=\"<output_directory>\"",
   format(
 "// How to run:\n"
 "// bbbbb run \\\n"
 "// rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr \\\n"
 "// <log_file> -- --output_directory=\"<output_directory>\""));
   // clang-format on
 }
 
 TEST_F(FormatTestComments, IndentsLongJavadocAnnotatedLines) {
   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Java);
   Style.ColumnLimit = 60;
   FormatStyle Style20 = getGoogleStyle(FormatStyle::LK_Java);
   Style20.ColumnLimit = 20;
   EXPECT_EQ(
EXPECT_EQ("/**\n"
             " *     long long long long long long long long long long\n"
             " *     long\n"
             " */\n",
             format("/**\n"
                    " * @param x long long long long long long long long long "
                    "long long long long long long long long long long long\n"
                    " */\n",
                    Style));
-  EXPECT_EQ(
-      "/**\n"
+  EXPECT_EQ("/**\n"
             " * Sentence that\n"
             " * should be broken.\n"
             " * @param short\n"
             " * keep indentation\n"
-      " */\n", format(
-          "/**\n"
+            " */\n",
+            format("/**\n"
                    " * Sentence that should be broken.\n"
                    " * @param short\n"
                    " * keep indentation\n"
-          " */\n", Style20));
+                   " */\n",
+                   Style20));
 
   EXPECT_EQ("/**\n"
             " * @param l1 long1\n"
             " *     to break\n"
             " * @param l2 long2\n"
             " *     to break\n"
             " */\n",
             format("/**\n"

clang/unittests/Format/FormatTestJS.cpp

static FormatStyle getGoogleJSStyleWithColumns(unsigned ColumnLimit) {
     FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
     Style.ColumnLimit = ColumnLimit;
     return Style;
   }
 
   static void verifyFormat(
       llvm::StringRef Code,
       const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
-    EXPECT_EQ(Code.str(), format(Code, Style))
-        << "Expected code is not stable";
+    EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
     std::string Result = format(test::messUp(Code), Style);
     EXPECT_EQ(Code.str(), Result) << "Formatted:\n" << Result;
   }
 
   static void verifyFormat(
-      llvm::StringRef Expected,
-      llvm::StringRef Code,
+      llvm::StringRef Expected, llvm::StringRef Code,
       const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
     EXPECT_EQ(Expected.str(), format(Expected, Style))
         << "Expected code is not stable";
     std::string Result = format(Code, Style);
     EXPECT_EQ(Expected.str(), Result) << "Formatted:\n" << Result;
   }
 };
 
EXPECT_EQ("/**\n"
                    " * jsdoc line 2\n"
                    " */",
                    getGoogleJSStyleWithColumns(20)));
   // Break a short first line if the ending '*/' is on a newline.
   EXPECT_EQ("/**\n"
             " * jsdoc line 1\n"
             " */",
             format("/** jsdoc line 1\n"
-                   " */", getGoogleJSStyleWithColumns(20)));
+                   " */",
+                   getGoogleJSStyleWithColumns(20)));
   // Don't break the first line of a short single line jsdoc comment.
   EXPECT_EQ("/** jsdoc line 1 */",
             format("/** jsdoc line 1 */", getGoogleJSStyleWithColumns(20)));
   // Don't break the first line of a single line jsdoc comment if it just fits
   // the column limit.
   EXPECT_EQ("/** jsdoc line 12 */",
             format("/** jsdoc line 12 */", getGoogleJSStyleWithColumns(20)));
   // Don't break after '/**' and before '*/' if there is no space between
EXPECT_EQ("function f() {\n"
             format("function f() {\n"
                    "/** comment about x */\n"
                    "var x = 1;\n"
                    "}",
                    getGoogleJSStyleWithColumns(20)));
 
   // Don't break the first line of a single line short jsdoc comment pragma.
   EXPECT_EQ("/** @returns j */",
-            format("/** @returns j */",
-                   getGoogleJSStyleWithColumns(20)));
+            format("/** @returns j */", getGoogleJSStyleWithColumns(20)));
 
   // Break a single line long jsdoc comment pragma.
   EXPECT_EQ("/**\n"
             " * @returns {string} jsdoc line 12\n"
             " */",
             format("/** @returns {string} jsdoc line 12 */",
                    getGoogleJSStyleWithColumns(20)));
   EXPECT_EQ("/**\n"
TEST_F(FormatTestJS, ReservedWords) {
   verifyFormat("const Axis = {\n"
                "  for: 'for',\n"
                "  x: 'x'\n"
                "};",
                "const Axis = {for: 'for', x:   'x'};");
 }
 
 TEST_F(FormatTestJS, ReservedWordsMethods) {
-  verifyFormat(
-      "class X {\n"
+  verifyFormat("class X {\n"
                "  delete() {\n"
                "    x();\n"
                "  }\n"
                "  interface() {\n"
                "    x();\n"
                "  }\n"
                "  let() {\n"
                "    x();\n"
                "  }\n"
                "}\n");
   verifyFormat("class KeywordNamedMethods {\n"
                "  do() {\n"
                "  }\n"
                "  for() {\n"
                "  }\n"
                "  while() {\n"
                "  }\n"
                "  if() {\n"
verifyFormat("namespace Foo {\n"
                "}\n");
   verifyFormat("declare namespace Foo {\n"
                "  export let x: number;\n"
                "}\n");
 }
 
 TEST_F(FormatTestJS, NamespacesMayNotWrap) {
   verifyFormat("declare namespace foobarbaz {\n"
-               "}\n", getGoogleJSStyleWithColumns(18));
+               "}\n",
+               getGoogleJSStyleWithColumns(18));
   verifyFormat("declare module foobarbaz {\n"
-               "}\n", getGoogleJSStyleWithColumns(15));
+               "}\n",
+               getGoogleJSStyleWithColumns(15));
   verifyFormat("namespace foobarbaz {\n"
-               "}\n", getGoogleJSStyleWithColumns(10));
+               "}\n",
+               getGoogleJSStyleWithColumns(10));
   verifyFormat("module foobarbaz {\n"
-               "}\n", getGoogleJSStyleWithColumns(7));
+               "}\n",
+               getGoogleJSStyleWithColumns(7));
 }
 
 TEST_F(FormatTestJS, AmbientDeclarations) {
   FormatStyle NineCols = getGoogleJSStyleWithColumns(9);
-  verifyFormat(
-      "declare class\n"
+  verifyFormat("declare class\n"
                "    X {}",
                NineCols);
-  verifyFormat(
-      "declare function\n"
-      "x();",  // TODO(martinprobst): should ideally be indented.
+  verifyFormat("declare function\n"
+               "x();", // TODO(martinprobst): should ideally be indented.
                NineCols);
   verifyFormat("declare function foo();\n"
                "let x = 1;\n");
   verifyFormat("declare function foo(): string;\n"
                "let x = 1;\n");
   verifyFormat("declare function foo(): {x: number};\n"
                "let x = 1;\n");
   verifyFormat("declare class X {}\n"
                "let x = 1;\n");
   verifyFormat("declare interface Y {}\n"
                "let x = 1;\n");
-  verifyFormat(
-      "declare enum X {\n"
+  verifyFormat("declare enum X {\n"
                "}",
                NineCols);
-  verifyFormat(
-      "declare let\n"
+  verifyFormat("declare let\n"
                "    x: number;",
                NineCols);
 }
 
 TEST_F(FormatTestJS, FormatsFreestandingFunctions) {
   verifyFormat("function outer1(a, b) {\n"
                "  function inner1(a, b) {\n"
                "    return a;\n"
                "  }\n"
                "  inner1(a, b);\n"
TEST_F(FormatTestJS, FunctionLiterals) {
 
   Style.ColumnLimit = 33;
   verifyFormat("f({a: function() { return 1; }});", Style);
   Style.ColumnLimit = 32;
   verifyFormat("f({\n"
                "  a: function() { return 1; }\n"
                "});",
                Style);
-
 }
 
 TEST_F(FormatTestJS, DontWrapEmptyLiterals) {
   verifyFormat("(aaaaaaaaaaaaaaaaaaaaa.getData as jasmine.Spy)\n"
                "    .and.returnValue(Observable.of([]));");
   verifyFormat("(aaaaaaaaaaaaaaaaaaaaa.getData as jasmine.Spy)\n"
                "    .and.returnValue(Observable.of({}));");
   verifyFormat("(aaaaaaaaaaaaaaaaaaaaa.getData as jasmine.Spy)\n"
TEST_F(FormatTestJS, ArrowFunctionStyle) {
   verifyFormat("const arrInlineNone = () => {\n"
                "};",
                Style);
   Style.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
   verifyFormat("const arr = () => {\n"
                "  x;\n"
                "};",
                Style);
-  verifyFormat("const arrInlineEmpty = () => {};",
-               Style);
+  verifyFormat("const arrInlineEmpty = () => {};", Style);
   Style.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
   verifyFormat("const arr = () => {\n"
                "  x;\n"
                "};",
                Style);
-  verifyFormat("foo(() => {});",
-               Style);
+  verifyFormat("foo(() => {});", Style);
   verifyFormat("const arrInlineInline = () => {};", Style);
 }
 
 TEST_F(FormatTestJS, ReturnStatements) {
   verifyFormat("function() {\n"
                "  return [hello, world];\n"
                "}");
 }
verifyFormat("a = 's'\n"
                "return 1",
                "a = 's'\n"
                "  return   1");
   verifyFormat("a = null\n"
                "return 1",
                "a = null\n"
                "  return   1");
   // Below "class Y {}" should ideally be on its own line.
-  verifyFormat(
-      "x = {\n"
+  verifyFormat("x = {\n"
                "  a: 1\n"
                "} class Y {}",
                "  x  =  {a  : 1}\n"
                "   class  Y {  }");
-  verifyFormat(
-      "if (x) {\n"
+  verifyFormat("if (x) {\n"
                "}\n"
                "return 1",
                "if (x) {}\n"
                " return   1");
-  verifyFormat(
-      "if (x) {\n"
+  verifyFormat("if (x) {\n"
                "}\n"
                "class X {}",
                "if (x) {}\n"
                " class X {}");
 }
 
 TEST_F(FormatTestJS, ImportExportASI) {
-  verifyFormat(
-      "import {x} from 'y'\n"
+  verifyFormat("import {x} from 'y'\n"
                "export function z() {}",
                "import   {x} from 'y'\n"
                "  export function z() {}");
   // Below "class Y {}" should ideally be on its own line.
-  verifyFormat(
-      "export {x} class Y {}",
-      "  export {x}\n"
+  verifyFormat("export {x} class Y {}", "  export {x}\n"
                                         "  class  Y {\n}");
-  verifyFormat(
-      "if (x) {\n"
+  verifyFormat("if (x) {\n"
                "}\n"
                "export class Y {}",
                "if ( x ) { }\n"
                " export class Y {}");
 }
 
 TEST_F(FormatTestJS, ClosureStyleCasts) {
   verifyFormat("var x = /** @type {foo} */ (bar);");
 }
 
 TEST_F(FormatTestJS, TryCatch) {
   verifyFormat("try {\n"
verifyFormat("var x = {\n"
                "  }\n"
                "};");
   verifyFormat("function someFunc(args: string[]):\n"
                "    {longReturnValue: string[]} {}",
                getGoogleJSStyleWithColumns(60));
   verifyFormat(
       "var someValue = (v as aaaaaaaaaaaaaaaaaaaa<T>[])\n"
       "                    .someFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
-  verifyFormat("const xIsALongIdent:\n""    YJustBarelyFitsLinex[];",
+  verifyFormat("const xIsALongIdent:\n"
+               "    YJustBarelyFitsLinex[];",
                getGoogleJSStyleWithColumns(20));
   verifyFormat("const x = {\n"
                "  y: 1\n"
                "} as const;");
 }
 
 TEST_F(FormatTestJS, UnionIntersectionTypes) {
   verifyFormat("let x: A|B = A | B;");
   verifyFormat("let x: A&B|C = A & B;");
verifyFormat("class C {\n"
                "  foo() {}\n"
                "  [bar]() {}\n"
                "}\n");
   verifyFormat("class C {\n  private x: string = 12;\n}");
   verifyFormat("class C {\n  private static x: string = 12;\n}");
   verifyFormat("class C {\n  static x(): string {\n    return 'asd';\n  }\n}");
   verifyFormat("class C extends P implements I {}");
   verifyFormat("class C extends p.P implements i.I {}");
-  verifyFormat(
-      "x(class {\n"
+  verifyFormat("x(class {\n"
                "  a(): A {}\n"
                "});");
   verifyFormat("class Test {\n"
                "  aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n"
                "      aaaaaaaaaaaaaaaaaaaaaa {}\n"
                "}");
   verifyFormat("foo = class Name {\n"
                "  constructor() {}\n"
                "};");
   verifyFormat("foo = class {\n"
verifyFormat("export type X = {\n"
                "  b?: string,\n"
                "};\n");
 }
 
 TEST_F(FormatTestJS, TypeInterfaceLineWrapping) {
   const FormatStyle &Style = getGoogleJSStyleWithColumns(20);
   verifyFormat("type LongTypeIsReallyUnreasonablyLong =\n"
                "    string;\n",
-               "type LongTypeIsReallyUnreasonablyLong = string;\n",
-               Style);
-  verifyFormat(
-      "interface AbstractStrategyFactoryProvider {\n"
+               "type LongTypeIsReallyUnreasonablyLong = string;\n", Style);
+  verifyFormat("interface AbstractStrategyFactoryProvider {\n"
                "  a: number\n"
                "}\n",
                "interface AbstractStrategyFactoryProvider { a: number }\n",
                Style);
 }
 
 TEST_F(FormatTestJS, RemoveEmptyLinesInArrowFunctions) {
   verifyFormat("x = () => {\n"
                "  foo();\n"
                "  bar();\n"
                "};\n",
                "x = () => {\n"
verifyFormat("import {\n"
                "  }    from\n"
                "      'some/path/longer/than/column/limit/module.js'  ; ",
                Style);
 }
 
 TEST_F(FormatTestJS, TemplateStrings) {
   // Keeps any whitespace/indentation within the template string.
   verifyFormat("var x = `hello\n"
                "     ${name}\n"
                "  !`;",
                "var x    =    `hello\n"
-                   "     ${  name    }\n"
-                   "  !`;");
 
   verifyFormat("var x =\n"
                "    `hello ${world}` >= some();",
                getGoogleJSStyleWithColumns(34)); // Barely doesn't fit.
   verifyFormat("var x = `hello ${world}` >= some();",
                getGoogleJSStyleWithColumns(35)); // Barely fits.
   verifyFormat("var x = `hellö ${wörld}` >= söme();",
                getGoogleJSStyleWithColumns(35)); // Fits due to UTF-8.
   verifyFormat("var x = `hello\n"
                "  ${world}` >=\n"
                "    some();",
                "var x =\n"
-                   "    `hello\n"
-                   "  ${world}` >= some();",
-                   getGoogleJSStyleWithColumns(21)); // Barely doesn't fit.
   verifyFormat("var x = `hello\n"
                "  ${world}` >= some();",
                "var x =\n"
-                   "    `hello\n"
-                   "  ${world}` >= some();",
-                   getGoogleJSStyleWithColumns(22)); // Barely fits.
 
   verifyFormat("var x =\n"
                "    `h`;",
                getGoogleJSStyleWithColumns(11));
   verifyFormat("var x =\n    `multi\n  line`;", "var x = `multi\n  line`;",
                getGoogleJSStyleWithColumns(13));
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
                "    `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);");
   // Repro for an obscure width-miscounting issue with template strings.
   verifyFormat(
       "someLongVariable =\n"
       "    "
       "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;",
       "someLongVariable = "
       "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;");
 
   // Make sure template strings get a proper ColumnWidth assigned, even if they
   // are first token in line.
-  verifyFormat(
-      "var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
+  verifyFormat("var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
                "    `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;");
 
   // Two template strings.
   verifyFormat("var x = `hello` == `hello`;");
 
   // Comments in template strings.
   verifyFormat("var x = `//a`;\n"
                "var y;",
                "var x =\n `//a`;\n"
-                   "var y  ;");
   verifyFormat("var x = `/*a`;\n"
                "var y;",
                "var x =\n `/*a`;\n"
                "var y;");
   // Unterminated string literals in a template string.
   verifyFormat("var x = `'`;  // comment with matching quote '\n"
                "var y;");
   verifyFormat("var x = `\"`;  // comment with matching quote \"\n"
verifyFormat("/**\n"
                getGoogleJSStyleWithColumns(20));
   verifyFormat("/**\n"
                " * @see http://very/very/long/url/is/long\n"
                " */",
                "/**\n"
                " * @see http://very/very/long/url/is/long\n"
                " */",
                getGoogleJSStyleWithColumns(20));
-  verifyFormat(
-      "/**\n"
+  verifyFormat("/**\n"
                " * @param This is a\n"
                " *     long comment\n"
                " *     but no type\n"
                " */",
                "/**\n"
                " * @param This is a long comment but no type\n"
                " */",
                getGoogleJSStyleWithColumns(20));
   // Break and reindent @param line and reflow unrelated lines.
   EXPECT_EQ("{\n"
             "  /**\n"
             "   * long long long\n"
             "   * long\n"
             "   * @param {this.is.a.long.path.to.a.Type}\n"
             "   *     a\n"
             "   * long long long\n"
verifyFormat("// Comment that needs wrapping. Comment that needs wrapping. "
                "// Trailing line.\n"
                "// @ts-check");
 }
 
 TEST_F(FormatTestJS, RequoteStringsSingle) {
   verifyFormat("var x = 'foo';", "var x = \"foo\";");
   verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo'o'\";");
   verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo\\'o'\";");
-  verifyFormat(
-      "var x =\n"
+  verifyFormat("var x =\n"
                "    'foo\\'';",
-      // Code below is 15 chars wide, doesn't fit into the line with the
-      // \ escape added.
+               // Code below is 15 chars wide, doesn't fit into the line with
+               // the \ escape added.
                "var x = \"foo'\";", getGoogleJSStyleWithColumns(15));
   // Removes no-longer needed \ escape from ".
   verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";");
   // Code below fits into 15 chars *after* removing the \ escape.
   verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";",
                getGoogleJSStyleWithColumns(15));
   verifyFormat("// clang-format off\n"
                "let x = \"double\";\n"
                "// clang-format on\n"

 TEST_F(FormatTestJS, NonNullAssertionOperator) {
   verifyFormat("let x = foo!.bar();\n");
   verifyFormat("let x = foo ? bar! : baz;\n");
   verifyFormat("let x = !foo;\n");
   verifyFormat("if (!+a) {\n}");
   verifyFormat("let x = foo[0]!;\n");
   verifyFormat("let x = (foo)!;\n");
   verifyFormat("let x = x(foo!);\n");
-  verifyFormat(
-      "a.aaaaaa(a.a!).then(\n"
+  verifyFormat("a.aaaaaa(a.a!).then(\n"
                "    x => x(x));\n",
                getGoogleJSStyleWithColumns(20));
   verifyFormat("let x = foo! - 1;\n");
   verifyFormat("let x = {foo: 1}!;\n");
-  verifyFormat(
-      "let x = hello.foo()!\n"
+  verifyFormat("let x = hello.foo()!\n"
                "            .foo()!\n"
                "            .foo()!\n"
                "            .foo()!;\n",
                getGoogleJSStyleWithColumns(20));
   verifyFormat("let x = namespace!;\n");
   verifyFormat("return !!x;\n");
 }
 
 TEST_F(FormatTestJS, CppKeywords) {
   // Make sure we don't mess stuff up because of C++ keywords.
   verifyFormat("return operator && (aa);");
   // .. or QT ones.
verifyFormat("class Foo {\n"
                "  method(a = true ? 1 : 2) {}\n"
                "}");
 }
 
 TEST_F(FormatTestJS, ImportComments) {
   verifyFormat("import {x} from 'x';  // from some location",
                getGoogleJSStyleWithColumns(25));
   verifyFormat("// taze: x from 'location'", getGoogleJSStyleWithColumns(10));
-  verifyFormat("/// <reference path=\"some/location\" />", getGoogleJSStyleWithColumns(10));
+  verifyFormat("/// <reference path=\"some/location\" />",
+               getGoogleJSStyleWithColumns(10));
 }
 
 TEST_F(FormatTestJS, Exponentiation) {
   verifyFormat("squared = x ** 2;");
   verifyFormat("squared **= 2;");
 }
 
 TEST_F(FormatTestJS, NestedLiterals) {
   FormatStyle FourSpaces = getGoogleJSStyleWithColumns(15);
   FourSpaces.IndentWidth = 4;
   verifyFormat("var l = [\n"
                "    [\n"
                "        1,\n"
                "    ],\n"
-               "];", FourSpaces);
+               "];",
+               FourSpaces);
   verifyFormat("var l = [\n"
                "    {\n"
                "        1: 1,\n"
                "    },\n"
-               "];", FourSpaces);
+               "];",
+               FourSpaces);
   verifyFormat("someFunction(\n"
                "    p1,\n"
                "    [\n"
                "        1,\n"
                "    ],\n"
-               ");", FourSpaces);
+               ");",
+               FourSpaces);
   verifyFormat("someFunction(\n"
                "    p1,\n"
                "    {\n"
                "        1: 1,\n"
                "    },\n"
-               ");", FourSpaces);
+               ");",
+               FourSpaces);
   verifyFormat("var o = {\n"
                "    1: 1,\n"
                "    2: {\n"
                "        3: 3,\n"
                "    },\n"
-               "};", FourSpaces);
+               "};",
+               FourSpaces);
   verifyFormat("var o = {\n"
                "    1: 1,\n"
                "    2: [\n"
                "        3,\n"
                "    ],\n"
-               "};", FourSpaces);
+               "};",
+               FourSpaces);
 }
 
 TEST_F(FormatTestJS, BackslashesInComments) {
   verifyFormat("// hello \\\n"
                "if (x) foo();\n",
                "// hello \\\n"
                "     if ( x) \n"
                "   foo();\n");

clang/unittests/Format/FormatTestJava.cpp

verifyFormat("{\n"
                "      String bbbbbbbbbbbbbbb) {}\n"
                "}",
                getStyleWithColumns(60));
   verifyFormat("@Annotation(\"Some\"\n"
                "    + \" text\")\n"
                "List<Integer> list;");
 
   verifyFormat(
       "@Test\n"
       "@Feature({\"Android-TabSwitcher\"})\n"
       "@CommandLineFlags.Add({ChromeSwitches.DISABLE_FIRST_RUN_EXPERIENCE})\n"
       "@Features.EnableFeatures({FEATURE})\n"
       "public void test(@Foo.bar(\"baz\") @Quux.Qoob int theFirstParaaaaam,\n"
       "    @Foo.bar(\"baz\") @Quux.Qoob int theSecondParaaaaaaaaaaaaaaaam) {}");
 }
 
 TEST_F(FormatTestJava, Generics) {
   verifyFormat("Iterable<?> a;");
   verifyFormat("Iterable<?> a;");
   verifyFormat("Iterable<? extends SomeObject> a;");
 
   verifyFormat("A.<B>doSomething();");
verifyFormat("void methodName(Object arg1,\n"
                "    Object arg2, Object arg3) {}",
                getStyleWithColumns(40));
   verifyFormat("void methodName(\n"
                "    Object arg1, Object arg2) {}",
                getStyleWithColumns(40));
 }
 
 TEST_F(FormatTestJava, MethodReference) {
-  EXPECT_EQ(
-      "private void foo() {\n"
+  EXPECT_EQ("private void foo() {\n"
             "  f(this::methodReference);\n"
             "  f(C.super::methodReference);\n"
             "  Consumer<String> c = System.out::println;\n"
             "  Iface<Integer> mRef = Ty::<Integer>meth;\n"
             "}",
             format("private void foo() {\n"
                    "  f(this ::methodReference);\n"
                    "  f(C.super ::methodReference);\n"
                    "  Consumer<String> c = System.out ::println;\n"
                    "  Iface<Integer> mRef = Ty :: <Integer> meth;\n"
                    "}"));
 }
 
 TEST_F(FormatTestJava, CppKeywords) {
   verifyFormat("public void union(Type a, Type b);");
   verifyFormat("public void struct(Object o);");
   verifyFormat("public void delete(Object o);");
   verifyFormat("return operator && (aa);");
 }
EXPECT_EQ("/**\n"
             " * javadoc line 1\n"
             " * javadoc line 2\n"
             " */",
             format("/** javadoc line 1\n"
                    " * javadoc line 2 */"));
 }
 
 TEST_F(FormatTestJava, RetainsLogicalShifts) {
-    verifyFormat("void f() {\n"
-                 "  int a = 1;\n"
-                 "  a >>>= 1;\n"
-                 "}");
-    verifyFormat("void f() {\n"
-                 "  int a = 1;\n"
-                 "  a = a >>> 1;\n"
-                 "}");
 }
 
-
-} // end namespace tooling
+} // namespace format
 } // end namespace clang

clang/unittests/Format/FormatTestObjC.cpp

 
 class FormatTestObjC : public ::testing::Test {
 protected:
   FormatTestObjC() {
     Style = getLLVMStyle();
     Style.Language = FormatStyle::LK_ObjC;
   }
 
-  enum StatusCheck {
-    SC_ExpectComplete,
-    SC_ExpectIncomplete,
-    SC_DoNotCheck
-  };
+  enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck };
 
   std::string format(llvm::StringRef Code,
                      StatusCheck CheckComplete = SC_ExpectComplete) {
     LLVM_DEBUG(llvm::errs() << "---\n");
     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
     FormattingAttemptStatus Status;
     tooling::Replacements Replaces =
protected:
   void verifyIncompleteFormat(StringRef Code) {
     EXPECT_EQ(Code.str(), format(test::messUp(Code), SC_ExpectIncomplete));
   }
 
   FormatStyle Style;
 };
 
 TEST(FormatTestObjCStyle, DetectsObjCInHeaders) {
-  auto Style = getStyle("LLVM", "a.h", "none", "@interface\n"
-                                               "- (id)init;");
+  auto Style = getStyle("LLVM", "a.h", "none",
+                        "@interface\n"
   ASSERT_TRUE((bool)Style);
   EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
 
-  Style = getStyle("LLVM", "a.h", "none", "@interface\n"
-                                          "+ (id)init;");
+  Style = getStyle("LLVM", "a.h", "none",
+                   "@interface\n"
   ASSERT_TRUE((bool)Style);
   EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
 
-  Style = getStyle("LLVM", "a.h", "none", "@interface\n"
-                                          "@end\n"
-                                          "//comment");
+  Style = getStyle("LLVM", "a.h", "none",
+                   "@interface\n"
   ASSERT_TRUE((bool)Style);
   EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
 
-  Style = getStyle("LLVM", "a.h", "none", "@interface\n"
-                                          "@end //comment");
+  Style = getStyle("LLVM", "a.h", "none",
+                   "@interface\n"
   ASSERT_TRUE((bool)Style);
   EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
 
   // No recognizable ObjC.
   Style = getStyle("LLVM", "a.h", "none", "void f() {}");
   ASSERT_TRUE((bool)Style);
   EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
 
TEST(FormatTestObjCStyle, DetectsObjCInHeaders) {
   ASSERT_TRUE((bool)Style);
   EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
 
   Style = getStyle("{}", "a.h", "none",
                    "const int protocol = 1;\nconst int end = 2;\n");
   ASSERT_TRUE((bool)Style);
   EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
 
-  Style =
-      getStyle("{}", "a.h", "none", "typedef NS_ENUM(int, Foo) {};\n");
+  Style = getStyle("{}", "a.h", "none", "typedef NS_ENUM(int, Foo) {};\n");
   ASSERT_TRUE((bool)Style);
   EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
 
-  Style = getStyle("{}", "a.h", "none",
-                   "typedef NS_CLOSED_ENUM(int, Foo) {};\n");
+  Style =
+      getStyle("{}", "a.h", "none", "typedef NS_CLOSED_ENUM(int, Foo) {};\n");
   ASSERT_TRUE((bool)Style);
   EXPECT_EQ(FormatStyle::LK_ObjC, Style->Language);
 
   Style = getStyle("{}", "a.h", "none", "enum Foo {};");
   ASSERT_TRUE((bool)Style);
   EXPECT_EQ(FormatStyle::LK_Cpp, Style->Language);
 
   Style =
verifyFormat("- (void)drawRectOn:(id)surface\n"
                "            ofSize:(aaaaaaaa)height\n"
                "                  :(size_t)width\n"
                "          atOrigin:(size_t)x\n"
                "                  :(size_t)y\n"
                "             aaaaa:(a)yyy\n"
                "               bbb:(d)cccc;");
   verifyFormat("- (void)drawRectOn:(id)surface ofSize:(aaa)height:(bbb)width;");
 
-  // BraceWrapping AfterFunction is respected for ObjC methods 
+  // BraceWrapping AfterFunction is respected for ObjC methods
   Style = getGoogleStyle(FormatStyle::LK_ObjC);
   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
   Style.BraceWrapping.AfterFunction = true;
   verifyFormat("@implementation Foo\n"
                "- (void)foo:(id)bar\n"
                "{\n"
                "}\n"
                "@end\n");
TEST_F(FormatTestObjC, FormatObjCMethodExpr) {
   Style.Language = FormatStyle::LK_ObjC;
   Style.ContinuationIndentWidth = 8;
   verifyFormat("[self performSelectorOnMainThread:@selector(loadAccessories)\n"
                "                       withObject:nil\n"
                "                    waitUntilDone:false];");
   verifyFormat("[self performSelector:@selector(loadAccessories)\n"
                "        withObjectOnMainThread:nil\n"
                "                 waitUntilDone:false];");
-  verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaa\n"
-               "        performSelectorOnMainThread:@selector(loadAccessories)\n"
-               "                         withObject:nil\n"
-               "                      waitUntilDone:false];");
-  verifyFormat("[self // force wrapping\n"
-               "        performSelectorOnMainThread:@selector(loadAccessories)\n"
-               "                         withObject:nil\n"
-               "                      waitUntilDone:false];");
+  verifyFormat(
+      "[aaaaaaaaaaaaaaaaaaaaaaaaa\n"
+  verifyFormat(
+      "[self // force wrapping\n"
 }
 
 TEST_F(FormatTestObjC, ObjCAt) {
   verifyFormat("@autoreleasepool");
   verifyFormat("@catch");
   verifyFormat("@class");
   verifyFormat("@compatibility_alias");
   verifyFormat("@defs");
TEST_F(FormatTestObjC, DisambiguatesCallsFromCppLambdas) {
   // is formatted as:
   //   x = ([a foo:bar] & b -> c == 'd');
   // verifyFormat("x = ([a foo:bar] & b->c == 'd');");
   // verifyFormat("x = ([a foo:bar] > b->c == 'd');");
   // verifyFormat("x = ([a foo:bar] < b->c == 'd');");
   // verifyFormat("x = ([a foo:bar] >> b->c == 'd');");
 }
 
-TEST_F(FormatTestObjC,  DisambiguatesCallsFromStructuredBindings) {
+TEST_F(FormatTestObjC, DisambiguatesCallsFromStructuredBindings) {
   verifyFormat("int f() {\n"
                "  if (a && [f arg])\n"
                "    return 0;\n"
                "}");
   verifyFormat("int f() {\n"
                "  if (a & [f arg])\n"
                "    return 0;\n"
                "}");

clang/unittests/Format/FormatTestProto.cpp

verifyFormat("option (MyProto.options) = {\n"
                "}");
   verifyFormat("option (MyProto.options) = {\n"
                "  repeatedd: [\n"
                "    'eyaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'\n"
                "  ]\n"
                "}");
 }
 
-
-} // end namespace tooling
+} // namespace format
 } // end namespace clang

clang/unittests/Format/FormatTestRawStrings.cpp

TEST_F(FormatTestRawStrings, UsesConfigurationOverBaseStyle) {
   // llvm style puts '*' on the right.
   // google style puts '*' on the left.
 
   // Uses the configured google style inside raw strings even if BasedOnStyle in
   // the raw string format is llvm.
   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
   EXPECT_EQ(0, parseConfiguration("---\n"
                                   "Language: Cpp\n"
-                                  "BasedOnStyle: Google", &Style).value());
+                                  "BasedOnStyle: Google",
+                                  &Style)
+                   .value());
   Style.RawStringFormats = {{
       FormatStyle::LK_Cpp,
       {"cpp"},
       {},
       /*CanonicalDelimiter=*/"",
       /*BasedOnStyle=*/"llvm",
   }};
   expect_eq(R"test(int* i = R"cpp(int* j = 0;)cpp";)test",

 // clang-format off
 s = R"pb(item:      1)pb";
 // clang-format on
 t = R"pb(item:      1)pb";)test",
                    getRawStringPbStyleWithColumns(40)));
 }
 
 TEST_F(FormatTestRawStrings, ReformatsShortRawStringsOnSingleLine) {
-  expect_eq(
-      R"test(P p = TP(R"pb()pb");)test",
-      format(
-          R"test(P p = TP(R"pb( )pb");)test",
+  expect_eq(R"test(P p = TP(R"pb()pb");)test",
+            format(R"test(P p = TP(R"pb( )pb");)test",
                    getRawStringPbStyleWithColumns(40)));
-  expect_eq(
-      R"test(P p = TP(R"pb(item_1: 1)pb");)test",
-      format(
-          R"test(P p = TP(R"pb(item_1:1)pb");)test",
+  expect_eq(R"test(P p = TP(R"pb(item_1: 1)pb");)test",
+            format(R"test(P p = TP(R"pb(item_1:1)pb");)test",
                    getRawStringPbStyleWithColumns(40)));
-  expect_eq(
-      R"test(P p = TP(R"pb(item_1: 1)pb");)test",
-      format(
-          R"test(P p = TP(R"pb(  item_1 :  1   )pb");)test",
+  expect_eq(R"test(P p = TP(R"pb(item_1: 1)pb");)test",
+            format(R"test(P p = TP(R"pb(  item_1 :  1   )pb");)test",
                    getRawStringPbStyleWithColumns(40)));
-  expect_eq(
-      R"test(P p = TP(R"pb(item_1: 1 item_2: 2)pb");)test",
-      format(
-          R"test(P p = TP(R"pb(item_1:1 item_2:2)pb");)test",
+  expect_eq(R"test(P p = TP(R"pb(item_1: 1 item_2: 2)pb");)test",
+            format(R"test(P p = TP(R"pb(item_1:1 item_2:2)pb");)test",
                    getRawStringPbStyleWithColumns(40)));
   // Merge two short lines into one.
   expect_eq(R"test(
 std::string s = R"pb(
   item_1: 1 item_2: 2
 )pb";
 )test",
             format(R"test(
 std::string s = R"pb(
   item_1:1
   item_2:2
 )pb";
 )test",
                    getRawStringPbStyleWithColumns(40)));
 }
 
 TEST_F(FormatTestRawStrings, BreaksShortRawStringsWhenNeeded) {
   // The raw string contains multiple submessage entries, so break for
   // readability.
   expect_eq(R"test(
 P p = TP(R"pb(item_1 < 1 >
               item_2: { 2 })pb");)test",
             format(
                 R"test(
 P p = TP(R"pb(item_1<1> item_2:{2})pb");)test",
                 getRawStringPbStyleWithColumns(40)));
 }
 
 TEST_F(FormatTestRawStrings, BreaksRawStringsExceedingColumnLimit) {
   expect_eq(R"test(
 P p = TPPPPPPPPPPPPPPP(
     R"pb(item_1: 1, item_2: 2)pb");)test",
             format(R"test(
 P p = TPPPPPPPPPPPPPPP(R"pb(item_1: 1, item_2: 2)pb");)test",
                    getRawStringPbStyleWithColumns(40)));
 
   expect_eq(R"test(
 P p =
     TPPPPPPPPPPPPPPP(
         R"pb(item_1: 1,
              item_2: 2,
              item_3: 3)pb");)test",
             format(R"test(
 P p = TPPPPPPPPPPPPPPP(R"pb(item_1: 1, item_2: 2, item_3: 3)pb");)test",
                    getRawStringPbStyleWithColumns(40)));
 
   expect_eq(R"test(
 P p = TP(R"pb(item_1 < 1 >
               item_2: < 2 >
               item_3 {})pb");)test",
             format(R"test(
 P p = TP(R"pb(item_1<1> item_2:<2> item_3{ })pb");)test",
                    getRawStringPbStyleWithColumns(40)));
 
   expect_eq(
       R"test(
 P p = TP(R"pb(item_1: 1,
               item_2: 2,
               item_3: 3,
               item_4: 4)pb");)test",
       format(
ASSERT_TRUE(ParseFromString(R"pb(item_1: 1, item_2: 2)pb"), ptr);)test",
   expect_eq(R"test(
 ASSERT_TRUE(
     ParseFromString(
         R"pb(item_1: 1 item_2: 2)pb"),
     ptr);)test",
             format(R"test(
 ASSERT_TRUE(ParseFromString(R"pb(item_1: 1 item_2: 2)pb"), ptr);)test",
                    getRawStringPbStyleWithColumns(40)));
-
 }
 
 TEST_F(FormatTestRawStrings, RawStringsInOperands) {
   // Formats the raw string first operand of a binary operator expression.
   expect_eq(R"test(auto S = R"pb(item_1: 1)pb" + rest;)test",
             format(R"test(auto S = R"pb(item_1:1)pb" + rest;)test",
                    getRawStringPbStyleWithColumns(40)));
 
auto S =
     (count < 3)
         ? R"pb(item_1: 1)pb"
         : R"pb(item_2: 2, item_3: 3)pb";
 )test",
             format(R"test(
 auto S=(count<3)?R"pb(item_1:1)pb":R"pb(item_2:2,item_3:3)pb";
 )test",
                    getRawStringPbStyleWithColumns(40)));
-
 }
 
 TEST_F(FormatTestRawStrings, PrefixAndSuffixAlignment) {
   // Keep the suffix at the end of line if not on newline.
   expect_eq(R"test(
 int s() {
   auto S = PTP(
       R"pb(

 TEST_F(FormatTestRawStrings, DontFormatNonRawStrings) {
   expect_eq(R"test(a = R"pb(key:value)";)test",
             format(R"test(a = R"pb(key:value)";)test",
                    getRawStringPbStyleWithColumns(20)));
 }
 
 TEST_F(FormatTestRawStrings, FormatsRawStringsWithEnclosingFunctionName) {
   FormatStyle Style = getRawStringPbStyleWithColumns(40);
-  Style.RawStringFormats[0].EnclosingFunctions.push_back(
-      "PARSE_TEXT_PROTO");
+  Style.RawStringFormats[0].EnclosingFunctions.push_back("PARSE_TEXT_PROTO");
   Style.RawStringFormats[0].EnclosingFunctions.push_back("ParseTextProto");
   expect_eq(R"test(a = PARSE_TEXT_PROTO(R"(key: value)");)test",
             format(R"test(a = PARSE_TEXT_PROTO(R"(key:value)");)test", Style));
 
   expect_eq(R"test(
 a = PARSE_TEXT_PROTO /**/ (
     /**/ R"(key: value)");)test",
             format(R"test(

 xxxxxxxaaaaax wwwwwww = _Verxrrrrrrrr(PARSE_TEXT_PROTO(R"pb(
   Category: aaaaaaaaaaaaaaaaaaaaaaaaaa
 )pb"));
 )test",
             format(R"test(
 xxxxxxxaaaaax wwwwwww = _Verxrrrrrrrr(PARSE_TEXT_PROTO(R"pb(
   Category: aaaaaaaaaaaaaaaaaaaaaaaaaa
 )pb"));
-)test", Style));
+)test",
+                   Style));
   // The '(' in R"pb is at column 61, break.
   expect_eq(R"test(
 xxxxxxxaaaaax wwwwwww =
     _Verxrrrrrrrrr(PARSE_TEXT_PROTO(R"pb(
       Category: aaaaaaaaaaaaaaaaaaaaaaaaaa
     )pb"));
 )test",
             format(R"test(
 xxxxxxxaaaaax wwwwwww = _Verxrrrrrrrrr(PARSE_TEXT_PROTO(R"pb(
       Category: aaaaaaaaaaaaaaaaaaaaaaaaaa
 )pb"));
-)test", Style));
+)test",
+                   Style));
 }
 
 TEST_F(FormatTestRawStrings, KeepsRBraceFolloedByMoreLBracesOnSameLine) {
   FormatStyle Style = getRawStringPbStyleWithColumns(80);
 
   expect_eq(
-                    R"test(
 int f() {
   if (1) {
     TTTTTTTTTTTTTTTTTTTTT s = PARSE_TEXT_PROTO(R"pb(
       ttttttttt {
         ppppppppppppp {
           [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_1: "123_1" }
           [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_2: "123_2" }
         }
       }
     )pb");
   }
 }
 )test",
-            format(
-                    R"test(
 int f() {
   if (1) {
    TTTTTTTTTTTTTTTTTTTTT s = PARSE_TEXT_PROTO(R"pb(
    ttttttttt {
    ppppppppppppp {
    [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_1: "123_1" }
    [cccccccccc.pppppppppppppp.TTTTTTTTTTTTTTTTTTTT] { field_2: "123_2" }}}
    )pb");
   }
 }
 )test",
-                    Style));
 }
 
 TEST_F(FormatTestRawStrings,
        DoNotFormatUnrecognizedDelimitersInRecognizedFunctions) {
   FormatStyle Style = getRawStringPbStyleWithColumns(60);
-  Style.RawStringFormats[0].EnclosingFunctions.push_back(
-      "EqualsProto");
+  Style.RawStringFormats[0].EnclosingFunctions.push_back("EqualsProto");
   // EqualsProto is a recognized function, but the Raw delimiter is
   // unrecognized. Do not touch the string in this case, since it might be
   // special.
   expect_eq(R"test(
 void f() {
   aaaaaaaaa(bbbbbbbbb, EqualsProto(R"Raw(
 item {
   key: value

 int f() {
   int a = g(x, h(R"pb(
               key: 1 #
               key: 2
             )pb"), 3, 4);
 }
 )test",
                    Style));
-  
   expect_eq(R"test(
 int f() {
   int a = g(x,
             h(R"pb(
                 key: 1  #
                 key: 2
               )pb",
               2),
)test",
   expect_eq(R"test(
 int f() {
   int a = g(R"pb(key: 1)pb", 2);
 })test",
             format(R"test(
 int f() {
   int a = g(R"pb(key:
                  1)pb", 2);
-})test", Style));
+})test",
+                   Style));
 }
 
 TEST_F(FormatTestRawStrings, IndentsLastParamAfterNewline) {
   FormatStyle Style = getRawStringPbStyleWithColumns(60);
   expect_eq(R"test(
 fffffffffffffffffffff("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                       R"pb(
                         b: c

clang/unittests/Format/FormatTestSelective.cpp

EXPECT_EQ("int a; // comment\n"
                    "            // line 2\n"
                    "int b;",
                    28, 0));
   EXPECT_EQ("int   a; // comment\n"
             "// comment 2\n"
             "int b;",
             format("int   a; // comment\n"
                    "// comment 2\n"
-                   "int b;", 28, 0));
+                   "int b;",
+                   28, 0));
   EXPECT_EQ("int aaaaaa; // comment\n"
             "int b;\n"
             "int c; // unrelated comment",
             format("int aaaaaa; // comment\n"
                    "int b;\n"
                    "int   c; // unrelated comment",
                    31, 0));
 
EXPECT_EQ(
              "\n"
              "void g() {\n" // Make sure not to format this.
              "}",
              15, 0));
 }
 
 TEST_F(FormatTestSelective, SelectivelyRequoteJavaScript) {
   Style = getGoogleStyle(FormatStyle::LK_JavaScript);
-  EXPECT_EQ(
-      "var x = \"a\";\n"
+  EXPECT_EQ("var x = \"a\";\n"
             "var x = 'a';\n"
             "var x = \"a\";",
             format("var x = \"a\";\n"
                    "var x = \"a\";\n"
                    "var x = \"a\";",
                    20, 0));
 }
 
 TEST_F(FormatTestSelective, KeepsIndentAfterCommentSectionImport) {
   std::string Code = "#include <a> // line 1\n" // 23 chars long
                      "             // line 2\n" // 23 chars long
                      "\n"                       // this newline is char 47
                      "int i;";                  // this line is not indented
   EXPECT_EQ(Code, format(Code, 47, 1));
 }
 
 } // end namespace
 } // end namespace format
 } // end namespace clang

clang/unittests/Format/FormatTestTextProto.cpp

verifyFormat("msg_field: <\n"
                "  field_c: < fd_d: 2 >\n"
                ">");
 
   verifyFormat("field_a: \"OK\",\n"
                "msg_field: < field_b: 123 >,\n"
                "field_c: {}");
 
   verifyFormat("field_a < field_b: 1 >,\n"
-               "msg_fid: < fiel_b: 123 >,\n" 
+               "msg_fid: < fiel_b: 123 >,\n"
                "field_c <>");
 
   verifyFormat("field_a < field_b: 1 >\n"
                "msg_fied: < field_b: 123 >\n"
                "field_c <>");
 
   verifyFormat("field <\n"
                "  field < field: <> >,\n"
verifyFormat("[longg.long.long.long.long.long.long.long.long.long.long\n"
                "  key: value\n"
                "}");
   verifyFormat("[longg.long.long.long.long.long.long.long.long.long\n"
                "     .long/longg.longlong] { key: value }");
   verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/\n"
                " bbbbbbbbbbbbbb] { key: value }");
   // These go over the column limit intentionally, since the alternative
   // [aa..a\n] is worse.
-  verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] {\n"
-               "  key: value\n"
-               "}");
-  verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] {\n"
-               "  [type.type] {\n"
-               "    keyyyyyyyyyyyyyy: valuuuuuuuuuuuuuuuuuuuuuuuuue\n"
-               "  }\n"
-               "}");
+  verifyFormat(
+      "[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] {\n"
+  verifyFormat(
+      "[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] {\n"
   verifyFormat("[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/\n"
                " bbbbbbb] {\n"
                "  [type.type] {\n"
                "    keyyyyyyyyyyyyyy: valuuuuuuuuuuuuuuuuuuuuuuuuue\n"
                "  }\n"
                "}");
   verifyFormat(
       "aaaaaaaaaaaaaaa {\n"
verifyFormat("key: item\n"
                "    'bala',\n"
                "    'porto',\n"
                "    'kala',\n"
                "    'too',\n"
                "    'long',\n"
                "    'long'\n"
                "  ]\n"
                "}\n"
-               "key: value"
-               );
+               "key: value");
   FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
   Style.ColumnLimit = 60; // To make writing tests easier.
   Style.Cpp11BracedListStyle = true;
   verifyFormat("keys: [1]", Style);
 }
 
 TEST_F(FormatTestTextProto, AcceptsOperatorAsKey) {
   verifyFormat("aaaaaaaaaaa: <\n"
verifyFormat("pppppppppp: {\n"
                "  ppppppp: \"sssss/MMMMMMMMMMMM\"\n"
                "  [ns.sssss.eeeeeeeee.eeeeeeeeeeeeeee] { begin: 24 end: 252 }\n"
                "  [ns.sssss.eeeeeeeee.eeeeeeeeeeeeeee] {\n"
                "    begin: 24\n"
                "    end: 252\n"
                "    key: value\n"
                "    key: value\n"
                "  }\n"
-               "}", Style);
+               "}",
+               Style);
 }
 
 TEST_F(FormatTestTextProto, BreaksAfterBraceFollowedByClosingBraceOnNextLine) {
   FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
   Style.ColumnLimit = 60;
   verifyFormat("keys: [\n"
                "  data: { item: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' }\n"
                "]");
verifyFormat("submessage: {\n"
                "  msg: @base {\n"
                "    yolo: {}\n"
                "    key: value\n"
                "  }\n"
                "  key: value\n"
                "}");
 }
 
-} // end namespace tooling
+} // namespace format
 } // end namespace clang

clang/unittests/Format/NamespaceEndCommentsFixerTest.cpp

EXPECT_EQ("namespace {\n"
                                     "int i;\n"
                                     "int j;\n"
                                     "};;"));
 }
 
 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddEndCommentForShortNamespace) {
   EXPECT_EQ("namespace {}", fixNamespaceEndComments("namespace {}"));
   EXPECT_EQ("namespace A {}", fixNamespaceEndComments("namespace A {}"));
-  EXPECT_EQ("namespace A { a }",
-            fixNamespaceEndComments("namespace A { a }"));
+  EXPECT_EQ("namespace A { a }", fixNamespaceEndComments("namespace A { a }"));
   EXPECT_EQ("namespace A { a };",
             fixNamespaceEndComments("namespace A { a };"));
 }
 
 TEST_F(NamespaceEndCommentsFixerTest, DoesNotAddCommentAfterUnaffectedRBrace) {
   EXPECT_EQ("namespace A {\n"
             "int i;\n"
             "}",

clang/unittests/Format/SortIncludesTest.cpp

std::string sort(StringRef Code, std::vector<tooling::Range> Ranges,
     auto Sorted = applyAllReplacements(Code, Replaces);
     EXPECT_TRUE(static_cast<bool>(Sorted));
     auto Result = applyAllReplacements(
         *Sorted, reformat(FmtStyle, *Sorted, Ranges, FileName));
     EXPECT_TRUE(static_cast<bool>(Result));
     return *Result;
   }
 
-  std::string sort(StringRef Code,
-                   StringRef FileName = "input.cpp",
+  std::string sort(StringRef Code, StringRef FileName = "input.cpp",
                    unsigned ExpectedNumRanges = 1) {
     return sort(Code, GetCodeRange(Code), FileName, ExpectedNumRanges);
   }
 
   unsigned newCursor(llvm::StringRef Code, unsigned Cursor) {
     sortIncludes(FmtStyle, Code, GetCodeRange(Code), "input.cpp", &Cursor);
     return Cursor;
   }
EXPECT_EQ("#include <a>\n"
             "/* clang-format onwards */\n",
             sort("#include <b>\n"
                  "#include <a>\n"
                  "#include <c>\n"
                  "/* clang-format offically */\n"
                  "#include <b>\n"
                  "#include <a>\n"
                  "#include <c>\n"
-                 "/* clang-format onwards */\n", "input.h", 2));
+                 "/* clang-format onwards */\n",
+                 "input.h", 2));
 }
 
 TEST_F(SortIncludesTest, IncludeSortingCanBeDisabled) {
   FmtStyle.SortIncludes = false;
   EXPECT_EQ("#include \"a.h\"\n"
             "#include \"c.h\"\n"
             "#include \"b.h\"\n",
             sort("#include \"a.h\"\n"

 TEST_F(SortIncludesTest, SortsLocallyInEachBlock) {
   EXPECT_EQ("#include \"a.h\"\n"
             "#include \"c.h\"\n"
             "\n"
             "#include \"b.h\"\n",
             sort("#include \"a.h\"\n"
                  "#include \"c.h\"\n"
                  "\n"
-                 "#include \"b.h\"\n", "input.h", 0));
+                 "#include \"b.h\"\n",
+                 "input.h", 0));
 }
 
 TEST_F(SortIncludesTest, SortsAllBlocksWhenMerging) {
   Style.IncludeBlocks = tooling::IncludeStyle::IBS_Merge;
   EXPECT_EQ("#include \"a.h\"\n"
             "#include \"b.h\"\n"
             "#include \"c.h\"\n",
             sort("#include \"a.h\"\n"

 TEST_F(SortIncludesTest, DoNotSortLikelyXml) {
   EXPECT_EQ("<!--;\n"
             "#include <b>\n"
             "#include <a>\n"
             "-->",
             sort("<!--;\n"
                  "#include <b>\n"
                  "#include <a>\n"
-                 "-->", "input.h", 0));
+                 "-->",
+                 "input.h", 0));
 }
 
 TEST_F(SortIncludesTest, DoNotOutputReplacementsForSortedBlocksWithRegrouping) {
   Style.IncludeBlocks = Style.IBS_Regroup;
   std::string Code = R"(
 #include "b.h"
 
 #include <a.h>

clang/unittests/Format/UsingDeclarationsSorterTest.cpp

EXPECT_EQ("using d;\n"
                                   "using b;\n" // starts at offset 19
                                   "using a;\n"
                                   "\n"
                                   "using f;\n"
                                   "using e;",
                                   {tooling::Range(19, 1)}));
 }
 
-TEST_F(UsingDeclarationsSorterTest, SortsUsingDeclarationsWithLeadingkComments) {
+TEST_F(UsingDeclarationsSorterTest,
+       SortsUsingDeclarationsWithLeadingkComments) {
   EXPECT_EQ("/* comment */ using a;\n"
             "/* comment */ using b;",
             sortUsingDeclarations("/* comment */ using b;\n"
                                   "/* comment */ using a;"));
 }
 
 TEST_F(UsingDeclarationsSorterTest, DeduplicatesUsingDeclarations) {
   EXPECT_EQ("using a;\n"
             "using b;\n"
             "using c;\n"
             "\n"
             "using a;\n"
             "using e;",
             sortUsingDeclarations("using c;\n"
                                   "using a;\n"
                                   "using b;\n"
                                   "using a;\n"
                                   "using b;\n"
                                   "\n"
                                   "using e;\n"
                                   "using a;\n"
                                   "using e;"));
-
 }
 
 } // end namespace
 } // end namespace format
 } // end namespace clang