[clang-format][WIP] Run more stability FormatTests

[JakeMerdichAMD]

Summary

I've been seeing a lot of complaints of unstable output in the bug
tracker, and noticed that a good chunk of our tests weren't checking
this. The verifyFormat functions do this, but a lot of tests don't use
these, and they miss out on the stability checks.

This change replaces all instances of EXPECT_EQ(..., format(...)) with a
verifyFormat equivalent (I'll share the regex if you like; it's
horrifying). It also narrows the criteria to rerun a test with
objective-c in verifyFormat, since some of the migrated tests were
(correctly) failing when run with ObjC vs Cpp.

WIP because:

1. Several tests are failing because their expected output is unstable, and the underlying issues there need to be fixed.
2. It's harder to differenciate the expected vs input text than using EXPECT_EQ. Ideas?
3. This only does it for FormatTests.cpp. Needs to be done on the rest.

I wanted to get some feedback and general opinions on this as I debug
the underlying issues, as well as to encourage any new tests to be
written with verifyFormat instead of EXPECT_EQ. Thoughts?

[MyDeveloperDay]

I think this is a noble effort, assuming all the tests pass as far as I'm concerned this LGTM.

How about committing all the ones that pass, then work on the others that don't separately.

[MyDeveloperDay]

@HazardyKnusperkeks, @curdeius, @owenpan I feel we should try and get this committed, people tend to follow the adjacent style of the unit tests, and I sort of feel we keep having to ask people to use verifyFormat. maybe if we got rid of the unnecessary EXPECT_EQ we could reduce that, (I also like the way it messes up the code and checks its stable)

[HazardyKnusperkeks]

It says tests are failing. But generally this seems to be a good idea. So one should take the tests one by one. I would do it, but currently I'm trying to wrap my head around some of the internals, to get my requires clauses correctly formatted. ;)

[MyDeveloperDay]

@JakeMerdichAMD are you still interested in landing this, if not I'm happy to NFC it in over the next couple of weeks, if others agree

clang/unittests/Format/FormatTest.cpp

 using clang::tooling::toReplacements;
 
 namespace clang {
 namespace format {
 namespace {
 
 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
 
+bool canRunCppTestAsObjCTest(llvm::StringRef Expected,
+                             const FormatStyle &Style) {
+  bool foundEdgeCase = false;
+
+  // ObjC doesn't have a concept of namespaces
+  if (Style.FixNamespaceComments) {
+    foundEdgeCase |= Expected.contains("// namespace");
+    for (const auto &macro : Style.NamespaceMacros) {
+      foundEdgeCase |= Expected.contains(macro);
+    }
+  }
+
+  // ObjC doesn't have using statements
+  if (Style.SortUsingDeclarations) {
+    foundEdgeCase |= Expected.contains("using");
+  }
+
+  return !foundEdgeCase;
+}
+
 class FormatTest : public ::testing::Test {
 protected:
   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");
FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
     return getStyleWithColumns(getGoogleStyle(), ColumnLimit);
   }
 
   void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code,
                     const FormatStyle &Style = getLLVMStyle()) {
     EXPECT_EQ(Expected.str(), format(Expected, Style))
         << "Expected code is not stable";
     EXPECT_EQ(Expected.str(), format(Code, Style));
-    if (Style.Language == FormatStyle::LK_Cpp) {
-      // Objective-C++ is a superset of C++, so everything checked for C++
-      // needs to be checked for Objective-C++ as well.
+    if (Style.Language == FormatStyle::LK_Cpp &&
+        canRunCppTestAsObjCTest(Expected, Style)) {
+      // Objective-C++ is generally a superset of C++, so most things checked
+      // for C++ needs to be checked for Objective-C++ as well
       FormatStyle ObjCStyle = Style;
       ObjCStyle.Language = FormatStyle::LK_ObjC;
-      EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
+      EXPECT_EQ(Expected.str(), format(Code, ObjCStyle))
+          << "Expected code works on C++ but fails on ObjC";
     }
   }
 
   void verifyFormat(llvm::StringRef Code,
                     const FormatStyle &Style = getLLVMStyle()) {
     verifyFormat(Code, test::messUp(Code), Style);
   }
 
EXPECT_EQ(FormatStyle::LK_Proto,
             getLLVMStyle(FormatStyle::LK_Proto).Language);
 }
 
 //===----------------------------------------------------------------------===//
 // Basic function tests.
 //===----------------------------------------------------------------------===//
 
 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
-  EXPECT_EQ(";", format(";"));
+  verifyFormat(";", ";");
 }
 
 TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
-  EXPECT_EQ("int i;", format("  int i;"));
-  EXPECT_EQ("\nint i;", format(" \n\t \v \f  int i;"));
-  EXPECT_EQ("int i;\nint j;", format("    int i; int j;"));
-  EXPECT_EQ("int i;\nint j;", format("    int i;\n  int j;"));
+  verifyFormat("int i;", "  int i;");
+  verifyFormat("\nint i;", " \n\t \v \f  int i;");
+  verifyFormat("int i;\nint j;", "    int i; int j;");
+  verifyFormat("int i;\nint j;", "    int i;\n  int j;");
 }
 
 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
-  EXPECT_EQ("int i;", format("int\ni;"));
+  verifyFormat("int i;", "int\ni;");
 }
 
 TEST_F(FormatTest, FormatsNestedBlockStatements) {
-  EXPECT_EQ("{\n  {\n    {}\n  }\n}", format("{{{}}}"));
+  verifyFormat("{\n  {\n    {}\n  }\n}", "{{{}}}");
 }
 
 TEST_F(FormatTest, FormatsNestedCall) {
   verifyFormat("Method(f1, f2(f3));");
   verifyFormat("Method(f1(f2, f3()));");
   verifyFormat("Method(f1(f2, (f3())));");
 }
 
 TEST_F(FormatTest, NestedNameSpecifiers) {
   verifyFormat("vector<::Type> v;");
   verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
   verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
   verifyFormat("bool a = 2 < ::SomeFunction();");
   verifyFormat("ALWAYS_INLINE ::std::string getName();");
   verifyFormat("some::string getName();");
 }
 
 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
-  EXPECT_EQ("if (a) {\n"
+  verifyFormat("if (a) {\n"
                "  f();\n"
                "}",
-            format("if(a){f();}"));
+               "if(a){f();}");
   EXPECT_EQ(4, ReplacementCount);
-  EXPECT_EQ("if (a) {\n"
+  verifyFormat("if (a) {\n"
                "  f();\n"
                "}",
-            format("if (a) {\n"
-                   "  f();\n"
-                   "}"));
+               "if (a) {\n"
+               "}");
   EXPECT_EQ(0, ReplacementCount);
-  EXPECT_EQ("/*\r\n"
+  verifyFormat("/*\r\n"
                "\r\n"
                "*/\r\n",
-            format("/*\r\n"
-                   "\r\n"
-                   "*/\r\n"));
+               "/*\r\n"
+               "*/\r\n");
   EXPECT_EQ(0, ReplacementCount);
 }
 
 TEST_F(FormatTest, RemovesEmptyLines) {
-  EXPECT_EQ("class C {\n"
+  verifyFormat("class C {\n"
                "  int i;\n"
                "};",
-            format("class C {\n"
-                   " int i;\n"
-                   "\n"
-                   "};"));
+               "class C {\n"
+               "};");
 
   // Don't remove empty lines at the start of namespaces or extern "C" blocks.
-  EXPECT_EQ("namespace N {\n"
+  verifyFormat("namespace N {\n"
                "\n"
                "int i;\n"
                "}",
-            format("namespace N {\n"
-                   "\n"
-                   "int    i;\n"
-                   "}",
-                   getGoogleStyle()));
-  EXPECT_EQ("/* something */ namespace N {\n"
+               "namespace N {\n"
+               getGoogleStyle());
+  verifyFormat("/* something */ namespace N {\n"
                "\n"
                "int i;\n"
                "}",
-            format("/* something */ namespace N {\n"
-                   "\n"
-                   "int    i;\n"
-                   "}",
-                   getGoogleStyle()));
-  EXPECT_EQ("inline namespace N {\n"
+               "/* something */ namespace N {\n"
+               getGoogleStyle());
+  verifyFormat("inline namespace N {\n"
                "\n"
                "int i;\n"
                "}",
-            format("inline namespace N {\n"
-                   "\n"
-                   "int    i;\n"
-                   "}",
-                   getGoogleStyle()));
-  EXPECT_EQ("/* something */ inline namespace N {\n"
+               "inline namespace N {\n"
+               getGoogleStyle());
+  verifyFormat("/* something */ inline namespace N {\n"
                "\n"
                "int i;\n"
                "}",
-            format("/* something */ inline namespace N {\n"
-                   "\n"
-                   "int    i;\n"
-                   "}",
-                   getGoogleStyle()));
-  EXPECT_EQ("export namespace N {\n"
+               "/* something */ inline namespace N {\n"
+               getGoogleStyle());
+  verifyFormat("export namespace N {\n"
                "\n"
                "int i;\n"
                "}",
-            format("export namespace N {\n"
-                   "\n"
-                   "int    i;\n"
-                   "}",
-                   getGoogleStyle()));
-  EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
+               "export namespace N {\n"
+               getGoogleStyle());
+  verifyFormat("extern /**/ \"C\" /**/ {\n"
                "\n"
                "int i;\n"
                "}",
-            format("extern /**/ \"C\" /**/ {\n"
-                   "\n"
-                   "int    i;\n"
-                   "}",
-                   getGoogleStyle()));
+               "extern /**/ \"C\" /**/ {\n"
+               getGoogleStyle());
 
   // ...but do keep inlining and removing empty lines for non-block extern "C"
   // functions.
   verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
-  EXPECT_EQ("extern \"C\" int f() {\n"
+  verifyFormat("extern \"C\" int f() {\n"
                "  int i = 42;\n"
                "  return i;\n"
                "}",
-            format("extern \"C\" int f() {\n"
-                   "\n"
-                   "  int i = 42;\n"
-                   "  return i;\n"
-                   "}",
-                   getGoogleStyle()));
+               "extern \"C\" int f() {\n"
+               getGoogleStyle());
 
   // Remove empty lines at the beginning and end of blocks.
-  EXPECT_EQ("void f() {\n"
+  verifyFormat("void f() {\n"
                "\n"
                "  if (a) {\n"
                "\n"
                "    f();\n"
                "  }\n"
                "}",
-            format("void f() {\n"
-                   "\n"
-                   "  if (a) {\n"
-                   "\n"
-                   "    f();\n"
-                   "\n"
-                   "  }\n"
-                   "\n"
-                   "}",
-                   getLLVMStyle()));
-  EXPECT_EQ("void f() {\n"
+               "void f() {\n"
+               getLLVMStyle());
+  verifyFormat("void f() {\n"
                "  if (a) {\n"
                "    f();\n"
                "  }\n"
                "}",
-            format("void f() {\n"
-                   "\n"
-                   "  if (a) {\n"
-                   "\n"
-                   "    f();\n"
-                   "\n"
-                   "  }\n"
-                   "\n"
-                   "}",
-                   getGoogleStyle()));
+               "void f() {\n"
+               getGoogleStyle());
 
   // Don't remove empty lines in more complex control statements.
-  EXPECT_EQ("void f() {\n"
+  verifyFormat("void f() {\n"
                "  if (a) {\n"
                "    f();\n"
                "\n"
                "  } else if (b) {\n"
                "    f();\n"
                "  }\n"
                "}",
-            format("void f() {\n"
-                   "  if (a) {\n"
-                   "    f();\n"
-                   "\n"
-                   "  } else if (b) {\n"
-                   "    f();\n"
-                   "\n"
-                   "  }\n"
-                   "\n"
-                   "}"));
+               "void f() {\n"
+               "}");
 
   // Don't remove empty lines before namespace endings.
   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
-  EXPECT_EQ("namespace {\n"
+  verifyFormat("namespace {\n"
                "int i;\n"
                "\n"
                "}",
-            format("namespace {\n"
-                   "int i;\n"
-                   "\n"
-                   "}",
-                   LLVMWithNoNamespaceFix));
-  EXPECT_EQ("namespace {\n"
+               "namespace {\n"
+               LLVMWithNoNamespaceFix);
+  verifyFormat("namespace {\n"
                "int i;\n"
                "}",
-            format("namespace {\n"
-                   "int i;\n"
-                   "}",
-                   LLVMWithNoNamespaceFix));
-  EXPECT_EQ("namespace {\n"
+               "namespace {\n"
+               LLVMWithNoNamespaceFix);
+  verifyFormat("namespace {\n"
                "int i;\n"
                "\n"
                "};",
-            format("namespace {\n"
-                   "int i;\n"
-                   "\n"
-                   "};",
-                   LLVMWithNoNamespaceFix));
-  EXPECT_EQ("namespace {\n"
+               "namespace {\n"
+               LLVMWithNoNamespaceFix);
+  verifyFormat("namespace {\n"
                "int i;\n"
                "};",
-            format("namespace {\n"
-                   "int i;\n"
-                   "};",
-                   LLVMWithNoNamespaceFix));
-  EXPECT_EQ("namespace {\n"
+               "namespace {\n"
+               LLVMWithNoNamespaceFix);
+  verifyFormat("namespace {\n"
                "int i;\n"
                "\n"
                "}",
-            format("namespace {\n"
-                   "int i;\n"
-                   "\n"
-                   "}"));
-  EXPECT_EQ("namespace {\n"
+               "namespace {\n"
+               "}");
+  verifyFormat("namespace {\n"
                "int i;\n"
                "\n"
                "} // namespace",
-            format("namespace {\n"
-                   "int i;\n"
-                   "\n"
-                   "}  // namespace"));
+               "namespace {\n"
+               "}  // namespace");
 
   FormatStyle Style = getLLVMStyle();
   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
   Style.MaxEmptyLinesToKeep = 2;
   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
   Style.BraceWrapping.AfterClass = true;
   Style.BraceWrapping.AfterFunction = true;
   Style.KeepEmptyLinesAtTheStartOfBlocks = false;
 
-  EXPECT_EQ("class Foo\n"
+  verifyFormat("class Foo\n"
                "{\n"
                "  Foo() {}\n"
                "\n"
                "  void funk() {}\n"
                "};",
-            format("class Foo\n"
-                   "{\n"
-                   "  Foo()\n"
-                   "  {\n"
-                   "  }\n"
-                   "\n"
-                   "  void funk() {}\n"
-                   "};",
-                   Style));
+               "class Foo\n"
+               Style);
 }
 
 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
   verifyFormat("x = (a) and (b);");
   verifyFormat("x = (a) or (b);");
   verifyFormat("x = (a) bitand (b);");
   verifyFormat("x = (a) bitor (b);");
   verifyFormat("x = (a) not_eq (b);");
verifyFormat("for (;;)\n"
                AllowSimpleBracedStatements);
 }
 
 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {
   FormatStyle Style = getLLVMStyleWithColumns(60);
   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
-  EXPECT_EQ("#define A                                                  \\\n"
+  verifyFormat("#define A                                                  \\\n"
                "  if (HANDLEwernufrnuLwrmviferuvnierv)                     \\\n"
                "  { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n"
                "X;",
-            format("#define A \\\n"
-                   "   if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
-                   "      RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
-                   "   }\n"
-                   "X;",
-                   Style));
+               "#define A \\\n"
+               Style);
 }
 
 TEST_F(FormatTest, ParseIfElse) {
   verifyFormat("if (true)\n"
                "  if (true)\n"
                "    if (true)\n"
                "      f();\n"
                "    else\n"
verifyFormat("DEBUG({\n"
                "    f();\n"
                "    break;\n"
                "    // fallthrough\n"
                "  case B:\n"
                "    g();\n"
                "    break;\n"
                "  }\n"
                "});");
-  EXPECT_EQ("DEBUG({\n"
+  verifyFormat("DEBUG({\n"
                "  switch (x) {\n"
                "  case A:\n"
                "    f();\n"
                "    break;\n"
                "  // On B:\n"
                "  case B:\n"
                "    g();\n"
                "    break;\n"
                "  }\n"
                "});",
-            format("DEBUG({\n"
-                   "  switch (x) {\n"
-                   "  case A:\n"
-                   "    f();\n"
-                   "    break;\n"
-                   "  // On B:\n"
-                   "  case B:\n"
-                   "    g();\n"
-                   "    break;\n"
-                   "  }\n"
-                   "});",
-                   getLLVMStyle()));
-  EXPECT_EQ("switch (n) {\n"
+               "DEBUG({\n"
+               getLLVMStyle());
+  verifyFormat("switch (n) {\n"
                "case 0: {\n"
                "  return false;\n"
                "}\n"
                "default: {\n"
                "  return true;\n"
                "}\n"
                "}",
-            format("switch (n)\n"
-                   "{\n"
-                   "case 0: {\n"
-                   "  return false;\n"
-                   "}\n"
-                   "default: {\n"
-                   "  return true;\n"
-                   "}\n"
-                   "}",
-                   getLLVMStyle()));
+               "switch (n)\n"
+               getLLVMStyle());
   verifyFormat("switch (a) {\n"
                "case (b):\n"
                "  return;\n"
                "}");
 
   verifyFormat("switch (a) {\n"
                "case some_namespace::\n"
                "    some_constant:\n"
                "  return;\n"
                "}",
                getLLVMStyleWithColumns(34));
 
   FormatStyle Style = getLLVMStyle();
   Style.IndentCaseLabels = true;
   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
   Style.BraceWrapping.AfterCaseLabel = true;
   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
-  EXPECT_EQ("switch (n)\n"
+  verifyFormat("switch (n)\n"
                "{\n"
                "  case 0:\n"
                "  {\n"
                "    return false;\n"
                "  }\n"
                "  default:\n"
                "  {\n"
                "    return true;\n"
                "  }\n"
                "}",
-            format("switch (n) {\n"
-                   "  case 0: {\n"
-                   "    return false;\n"
-                   "  }\n"
-                   "  default: {\n"
-                   "    return true;\n"
-                   "  }\n"
-                   "}",
-                   Style));
+               "switch (n) {\n"
+               Style);
   Style.BraceWrapping.AfterCaseLabel = false;
-  EXPECT_EQ("switch (n)\n"
+  verifyFormat("switch (n)\n"
                "{\n"
                "  case 0: {\n"
                "    return false;\n"
                "  }\n"
                "  default: {\n"
                "    return true;\n"
                "  }\n"
                "}",
-            format("switch (n) {\n"
-                   "  case 0:\n"
-                   "  {\n"
-                   "    return false;\n"
-                   "  }\n"
-                   "  default:\n"
-                   "  {\n"
-                   "    return true;\n"
-                   "  }\n"
-                   "}",
-                   Style));
+               "switch (n) {\n"
+               Style);
   Style.IndentCaseLabels = false;
   Style.IndentCaseBlocks = true;
-  EXPECT_EQ("switch (n)\n"
+  verifyFormat("switch (n)\n"
                "{\n"
                "case 0:\n"
                "  {\n"
                "    return false;\n"
                "  }\n"
                "case 1:\n"
                "  break;\n"
                "default:\n"
                "  {\n"
                "    return true;\n"
                "  }\n"
                "}",
-            format("switch (n) {\n"
-                   "case 0: {\n"
-                   "  return false;\n"
-                   "}\n"
-                   "case 1:\n"
-                   "  break;\n"
-                   "default: {\n"
-                   "  return true;\n"
-                   "}\n"
-                   "}",
-                   Style));
+               "switch (n) {\n"
+               Style);
   Style.IndentCaseLabels = true;
   Style.IndentCaseBlocks = true;
-  EXPECT_EQ("switch (n)\n"
+  verifyFormat("switch (n)\n"
                "{\n"
                "  case 0:\n"
                "    {\n"
                "      return false;\n"
                "    }\n"
                "  case 1:\n"
                "    break;\n"
                "  default:\n"
                "    {\n"
                "      return true;\n"
                "    }\n"
                "}",
-            format("switch (n) {\n"
-                   "case 0: {\n"
-                   "  return false;\n"
-                   "}\n"
-                   "case 1:\n"
-                   "  break;\n"
-                   "default: {\n"
-                   "  return true;\n"
-                   "}\n"
-                   "}",
-                   Style));
+               "switch (n) {\n"
+               Style);
 }
 
 TEST_F(FormatTest, CaseRanges) {
   verifyFormat("switch (x) {\n"
                "case 'A' ... 'Z':\n"
                "case 1 ... 5:\n"
                "case a ... b:\n"
                "  break;\n"
verifyFormat("switch (a) {\n"
                "case 8:\n"
                "  x = 1; /* comment */\n"
                "  break;\n"
                "case 9:\n"
                "  break; // comment line 1\n"
                "         // comment line 2\n"
                "}",
                Style);
-  EXPECT_EQ("switch (a) {\n"
+  verifyFormat("switch (a) {\n"
                "case 1:\n"
                "  x = 8;\n"
                "  // fall through\n"
                "case 2: x = 8;\n"
                "// comment\n"
                "case 3:\n"
                "  return; /* comment line 1\n"
                "           * comment line 2 */\n"
                "case 4: i = 8;\n"
                "// something else\n"
                "#if FOO\n"
                "case 5: break;\n"
                "#endif\n"
                "}",
-            format("switch (a) {\n"
-                   "case 1: x = 8;\n"
-                   "  // fall through\n"
-                   "case 2:\n"
-                   "  x = 8;\n"
-                   "// comment\n"
-                   "case 3:\n"
-                   "  return; /* comment line 1\n"
-                   "           * comment line 2 */\n"
-                   "case 4:\n"
-                   "  i = 8;\n"
-                   "// something else\n"
-                   "#if FOO\n"
-                   "case 5: break;\n"
-                   "#endif\n"
-                   "}",
-                   Style));
-  EXPECT_EQ("switch (a) {\n"
+               "switch (a) {\n"
+               Style);
+  verifyFormat("switch (a) {\n"
                "case 0:\n"
                "  return; // long long long long long long long long long long "
                "long long comment\n"
                "          // line\n"
                "}",
-            format("switch (a) {\n"
-                   "case 0: return; // long long long long long long long long "
-                   "long long long long comment line\n"
-                   "}",
-                   Style));
-  EXPECT_EQ("switch (a) {\n"
+               "switch (a) {\n"
+               Style);
+  verifyFormat("switch (a) {\n"
                "case 0:\n"
                "  return; /* long long long long long long long long long long "
                "long long comment\n"
                "             line */\n"
                "}",
-            format("switch (a) {\n"
-                   "case 0: return; /* long long long long long long long long "
-                   "long long long long comment line */\n"
-                   "}",
-                   Style));
+               "switch (a) {\n"
+               Style);
   verifyFormat("switch (a) {\n"
                "#if FOO\n"
                "case 0: return 0;\n"
                "#endif\n"
                "}",
                Style);
   verifyFormat("switch (a) {\n"
                "case 1: {\n"
verifyFormat("switch (a) {\n"
                "default:\n"
                "  y = 1;\n"
                "  break;\n"
                "}",
                Style);
   Style.ColumnLimit = 80;
   Style.AllowShortCaseLabelsOnASingleLine = false;
   Style.IndentCaseLabels = true;
-  EXPECT_EQ("switch (n) {\n"
+  verifyFormat("switch (n) {\n"
                "  default /*comments*/:\n"
                "    return true;\n"
                "  case 0:\n"
                "    return false;\n"
                "}",
-            format("switch (n) {\n"
-                   "default/*comments*/:\n"
-                   "  return true;\n"
-                   "case 0:\n"
-                   "  return false;\n"
-                   "}",
-                   Style));
+               "switch (n) {\n"
+               Style);
   Style.AllowShortCaseLabelsOnASingleLine = true;
   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
   Style.BraceWrapping.AfterCaseLabel = true;
   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
-  EXPECT_EQ("switch (n)\n"
+  verifyFormat("switch (n)\n"
                "{\n"
                "  case 0:\n"
                "  {\n"
                "    return false;\n"
                "  }\n"
                "  default:\n"
                "  {\n"
                "    return true;\n"
                "  }\n"
                "}",
-            format("switch (n) {\n"
-                   "  case 0: {\n"
-                   "    return false;\n"
-                   "  }\n"
-                   "  default:\n"
-                   "  {\n"
-                   "    return true;\n"
-                   "  }\n"
-                   "}",
-                   Style));
+               "switch (n) {\n"
+               Style);
 }
 
 TEST_F(FormatTest, FormatsLabels) {
   verifyFormat("void f() {\n"
                "  some_code();\n"
                "test_label:\n"
                "  some_other_code();\n"
                "  {\n"

 }
 
 TEST_F(FormatTest, MultiLineControlStatements) {
   FormatStyle Style = getLLVMStyle();
   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine;
   Style.ColumnLimit = 20;
   // Short lines should keep opening brace on same line.
-  EXPECT_EQ("if (foo) {\n"
+  verifyFormat("if (foo) {\n"
                "  bar();\n"
                "}",
-            format("if(foo){bar();}", Style));
-  EXPECT_EQ("if (foo) {\n"
+               "if(foo){bar();}", Style);
+  verifyFormat("if (foo) {\n"
                "  bar();\n"
                "} else {\n"
                "  baz();\n"
                "}",
-            format("if(foo){bar();}else{baz();}", Style));
-  EXPECT_EQ("if (foo && bar) {\n"
+               "if(foo){bar();}else{baz();}", Style);
+  verifyFormat("if (foo && bar) {\n"
                "  baz();\n"
                "}",
-            format("if(foo&&bar){baz();}", Style));
-  EXPECT_EQ("if (foo) {\n"
+               "if(foo&&bar){baz();}", Style);
+  verifyFormat("if (foo) {\n"
                "  bar();\n"
                "} else if (baz) {\n"
                "  quux();\n"
                "}",
-            format("if(foo){bar();}else if(baz){quux();}", Style));
-  EXPECT_EQ(
-      "if (foo) {\n"
+               "if(foo){bar();}else if(baz){quux();}", Style);
+  verifyFormat("if (foo) {\n"
                "  bar();\n"
                "} else if (baz) {\n"
                "  quux();\n"
                "} else {\n"
                "  foobar();\n"
                "}",
-      format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));
-  EXPECT_EQ("for (;;) {\n"
+               "if(foo){bar();}else if(baz){quux();}else{foobar();}", Style);
+  verifyFormat("for (;;) {\n"
                "  foo();\n"
                "}",
-            format("for(;;){foo();}"));
-  EXPECT_EQ("while (1) {\n"
+               "for(;;){foo();}");
+  verifyFormat("while (1) {\n"
                "  foo();\n"
                "}",
-            format("while(1){foo();}", Style));
-  EXPECT_EQ("switch (foo) {\n"
+               "while(1){foo();}", Style);
+  verifyFormat("switch (foo) {\n"
                "case bar:\n"
                "  return;\n"
                "}",
-            format("switch(foo){case bar:return;}", Style));
-  EXPECT_EQ("try {\n"
+               "switch(foo){case bar:return;}", Style);
+  verifyFormat("try {\n"
                "  foo();\n"
                "} catch (...) {\n"
                "  bar();\n"
                "}",
-            format("try{foo();}catch(...){bar();}", Style));
-  EXPECT_EQ("do {\n"
+               "try{foo();}catch(...){bar();}", Style);
+  verifyFormat("do {\n"
                "  foo();\n"
                "} while (bar &&\n"
                "         baz);",
-            format("do{foo();}while(bar&&baz);", Style));
+               "do{foo();}while(bar&&baz);", Style);
   // Long lines should put opening brace on new line.
-  EXPECT_EQ("if (foo && bar &&\n"
+  verifyFormat("if (foo && bar &&\n"
                "    baz)\n"
                "{\n"
                "  quux();\n"
                "}",
-            format("if(foo&&bar&&baz){quux();}", Style));
-  EXPECT_EQ("if (foo && bar &&\n"
+               "if(foo&&bar&&baz){quux();}", Style);
+  verifyFormat("if (foo && bar &&\n"
                "    baz)\n"
                "{\n"
                "  quux();\n"
                "}",
-            format("if (foo && bar &&\n"
-                   "    baz) {\n"
-                   "  quux();\n"
-                   "}",
-                   Style));
-  EXPECT_EQ("if (foo) {\n"
+               "if (foo && bar &&\n"
+               Style);
+  verifyFormat("if (foo) {\n"
                "  bar();\n"
                "} else if (baz ||\n"
                "           quux)\n"
                "{\n"
                "  foobar();\n"
                "}",
-            format("if(foo){bar();}else if(baz||quux){foobar();}", Style));
-  EXPECT_EQ(
-      "if (foo) {\n"
+               "if(foo){bar();}else if(baz||quux){foobar();}", Style);
+  verifyFormat("if (foo) {\n"
                "  bar();\n"
                "} else if (baz ||\n"
                "           quux)\n"
                "{\n"
                "  foobar();\n"
                "} else {\n"
                "  barbaz();\n"
                "}",
-      format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
-             Style));
-  EXPECT_EQ("for (int i = 0;\n"
+               "if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
+               Style);
+  verifyFormat("for (int i = 0;\n"
                "     i < 10; ++i)\n"
                "{\n"
                "  foo();\n"
                "}",
-            format("for(int i=0;i<10;++i){foo();}", Style));
-  EXPECT_EQ("while (foo || bar ||\n"
+               "for(int i=0;i<10;++i){foo();}", Style);
+  verifyFormat("while (foo || bar ||\n"
                "       baz)\n"
                "{\n"
                "  quux();\n"
                "}",
-            format("while(foo||bar||baz){quux();}", Style));
-  EXPECT_EQ("switch (\n"
+               "while(foo||bar||baz){quux();}", Style);
+  verifyFormat("switch (\n"
                "    foo = barbaz)\n"
                "{\n"
                "case quux:\n"
                "  return;\n"
                "}",
-            format("switch(foo=barbaz){case quux:return;}", Style));
-  EXPECT_EQ("try {\n"
+               "switch(foo=barbaz){case quux:return;}", Style);
+  verifyFormat("try {\n"
                "  foo();\n"
                "} catch (\n"
                "    Exception &bar)\n"
                "{\n"
                "  baz();\n"
                "}",
-            format("try{foo();}catch(Exception&bar){baz();}", Style));
+               "try{foo();}catch(Exception&bar){baz();}", Style);
   Style.ColumnLimit =
       40; // to concentrate at brace wrapping, not line wrap due to column limit
-  EXPECT_EQ("try {\n"
+  verifyFormat("try {\n"
                "  foo();\n"
                "} catch (Exception &bar) {\n"
                "  baz();\n"
                "}",
-            format("try{foo();}catch(Exception&bar){baz();}", Style));
+               "try{foo();}catch(Exception&bar){baz();}", Style);
   Style.ColumnLimit =
       20; // to concentrate at brace wrapping, not line wrap due to column limit
 
   Style.BraceWrapping.BeforeElse = true;
-  EXPECT_EQ(
-      "if (foo) {\n"
+  verifyFormat("if (foo) {\n"
                "  bar();\n"
                "}\n"
                "else if (baz ||\n"
                "         quux)\n"
                "{\n"
                "  foobar();\n"
                "}\n"
                "else {\n"
                "  barbaz();\n"
                "}",
-      format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
-             Style));
+               "if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
+               Style);
 
   Style.BraceWrapping.BeforeCatch = true;
-  EXPECT_EQ("try {\n"
+  verifyFormat("try {\n"
                "  foo();\n"
                "}\n"
                "catch (...) {\n"
                "  baz();\n"
                "}",
-            format("try{foo();}catch(...){baz();}", Style));
+               "try{foo();}catch(...){baz();}", Style);
 }
 
 TEST_F(FormatTest, BeforeWhile) {
   FormatStyle Style = getLLVMStyle();
   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
 
   verifyFormat("do {\n"
                "  foo();\n"
verifyFormat("{\n"
                "}");
   verifyFormat("void f() {\n"
                "label:\n"
                "  signals.baz();\n"
                "}");
 }
 
 TEST_F(FormatTest, SeparatesLogicalBlocks) {
-  EXPECT_EQ("class A {\n"
+  verifyFormat("class A {\n"
                "public:\n"
                "  void f();\n"
                "\n"
                "private:\n"
                "  void g() {}\n"
                "  // test\n"
                "protected:\n"
                "  int h;\n"
                "};",
-            format("class A {\n"
-                   "public:\n"
-                   "void f();\n"
-                   "private:\n"
-                   "void g() {}\n"
-                   "// test\n"
-                   "protected:\n"
-                   "int h;\n"
-                   "};"));
-  EXPECT_EQ("class A {\n"
+               "class A {\n"
+               "};");
+  verifyFormat("class A {\n"
                "protected:\n"
                "public:\n"
                "  void f();\n"
                "};",
-            format("class A {\n"
-                   "protected:\n"
-                   "\n"
-                   "public:\n"
-                   "\n"
-                   "  void f();\n"
-                   "};"));
+               "class A {\n"
+               "};");
 
   // Even ensure proper spacing inside macros.
-  EXPECT_EQ("#define B     \\\n"
+  verifyFormat("#define B     \\\n"
                "  class A {   \\\n"
                "   protected: \\\n"
                "   public:    \\\n"
                "    void f(); \\\n"
                "  };",
-            format("#define B     \\\n"
-                   "  class A {   \\\n"
-                   "   protected: \\\n"
-                   "              \\\n"
-                   "   public:    \\\n"
-                   "              \\\n"
-                   "    void f(); \\\n"
-                   "  };",
-                   getGoogleStyle()));
+               "#define B     \\\n"
+               getGoogleStyle());
   // But don't remove empty lines after macros ending in access specifiers.
-  EXPECT_EQ("#define A private:\n"
+  verifyFormat("#define A private:\n"
                "\n"
                "int i;",
-            format("#define A         private:\n"
-                   "\n"
-                   "int              i;"));
+               "#define A         private:\n"
+               "int              i;");
 }
 
 TEST_F(FormatTest, FormatsClasses) {
   verifyFormat("class A : public B {};");
   verifyFormat("class A : public ::B {};");
 
   verifyFormat(
       "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
TEST_F(FormatTest, FormatsEnum) {
   verifyFormat("enum {\n"
                "  Bar = Foo<int, int>::value\n"
                "};",
                getLLVMStyleWithColumns(30));
 
   verifyFormat("enum ShortEnum { A, B, C };");
   verifyGoogleFormat("enum ShortEnum { A, B, C };");
 
-  EXPECT_EQ("enum KeepEmptyLines {\n"
+  verifyFormat("enum KeepEmptyLines {\n"
                "  ONE,\n"
                "\n"
                "  TWO,\n"
                "\n"
                "  THREE\n"
                "}",
-            format("enum KeepEmptyLines {\n"
-                   "  ONE,\n"
-                   "\n"
-                   "  TWO,\n"
-                   "\n"
-                   "\n"
-                   "  THREE\n"
-                   "}"));
+               "enum KeepEmptyLines {\n"
+               "}");
   verifyFormat("enum E { // comment\n"
                "  ONE,\n"
                "  TWO\n"
                "};\n"
                "int i;");
 
   FormatStyle EightIndent = getLLVMStyle();
   EightIndent.IndentWidth = 8;
verifyFormat("namespace {\n"
                "class A {};\n"
                "};",
                LLVMWithNoNamespaceFix);
 
   verifyFormat("namespace {\n"
                "int SomeVariable = 0; // comment\n"
                "} // namespace",
                LLVMWithNoNamespaceFix);
-  EXPECT_EQ("#ifndef HEADER_GUARD\n"
+  verifyFormat("#ifndef HEADER_GUARD\n"
                "#define HEADER_GUARD\n"
                "namespace my_namespace {\n"
                "int i;\n"
                "} // my_namespace\n"
                "#endif // HEADER_GUARD",
-            format("#ifndef HEADER_GUARD\n"
-                   " #define HEADER_GUARD\n"
-                   "   namespace my_namespace {\n"
-                   "int i;\n"
-                   "}    // my_namespace\n"
-                   "#endif    // HEADER_GUARD",
-                   LLVMWithNoNamespaceFix));
+               "#ifndef HEADER_GUARD\n"
+               LLVMWithNoNamespaceFix);
 
-  EXPECT_EQ("namespace A::B {\n"
+  verifyFormat("namespace A::B {\n"
                "class C {};\n"
                "}",
-            format("namespace A::B {\n"
-                   "class C {};\n"
-                   "}",
-                   LLVMWithNoNamespaceFix));
+               "namespace A::B {\n"
+               LLVMWithNoNamespaceFix);
 
   FormatStyle Style = getLLVMStyle();
   Style.NamespaceIndentation = FormatStyle::NI_All;
-  EXPECT_EQ("namespace out {\n"
+  verifyFormat("namespace out {\n"
                "  int i;\n"
                "  namespace in {\n"
                "    int i;\n"
                "  } // namespace in\n"
                "} // namespace out",
-            format("namespace out {\n"
-                   "int i;\n"
-                   "namespace in {\n"
-                   "int i;\n"
-                   "} // namespace in\n"
-                   "} // namespace out",
-                   Style));
+               "namespace out {\n"
+               Style);
 
   Style.NamespaceIndentation = FormatStyle::NI_Inner;
-  EXPECT_EQ("namespace out {\n"
+  verifyFormat("namespace out {\n"
                "int i;\n"
                "namespace in {\n"
                "  int i;\n"
                "} // namespace in\n"
                "} // namespace out",
-            format("namespace out {\n"
-                   "int i;\n"
-                   "namespace in {\n"
-                   "int i;\n"
-                   "} // namespace in\n"
-                   "} // namespace out",
-                   Style));
+               "namespace out {\n"
+               Style);
 }
 
 TEST_F(FormatTest, NamespaceMacros) {
   FormatStyle Style = getLLVMStyle();
   Style.NamespaceMacros.push_back("TESTSUITE");
 
   verifyFormat("TESTSUITE(A) {\n"
                "int foo();\n"
TEST_F(FormatTest, NamespaceMacros) {
 
   // Properly merge namespace-macros blocks in CompactNamespaces mode
   Style.NamespaceIndentation = FormatStyle::NI_None;
   Style.CompactNamespaces = true;
   verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
                "}} // TESTSUITE(A::B)",
                Style);
 
-  EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
+  verifyFormat("TESTSUITE(out) { TESTSUITE(in) {\n"
                "}} // TESTSUITE(out::in)",
-            format("TESTSUITE(out) {\n"
-                   "TESTSUITE(in) {\n"
-                   "} // TESTSUITE(in)\n"
-                   "} // TESTSUITE(out)",
-                   Style));
+               "TESTSUITE(out) {\n"
+               Style);
 
-  EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
+  verifyFormat("TESTSUITE(out) { TESTSUITE(in) {\n"
                "}} // TESTSUITE(out::in)",
-            format("TESTSUITE(out) {\n"
-                   "TESTSUITE(in) {\n"
-                   "} // TESTSUITE(in)\n"
-                   "} // TESTSUITE(out)",
-                   Style));
+               "TESTSUITE(out) {\n"
+               Style);
 
   // Do not merge different namespaces/macros
-  EXPECT_EQ("namespace out {\n"
+  verifyFormat("namespace out {\n"
                "TESTSUITE(in) {\n"
                "} // TESTSUITE(in)\n"
                "} // namespace out",
-            format("namespace out {\n"
-                   "TESTSUITE(in) {\n"
-                   "} // TESTSUITE(in)\n"
-                   "} // namespace out",
-                   Style));
-  EXPECT_EQ("TESTSUITE(out) {\n"
+               "namespace out {\n"
+               Style);
+  verifyFormat("TESTSUITE(out) {\n"
                "namespace in {\n"
                "} // namespace in\n"
                "} // TESTSUITE(out)",
-            format("TESTSUITE(out) {\n"
-                   "namespace in {\n"
-                   "} // namespace in\n"
-                   "} // TESTSUITE(out)",
-                   Style));
+               "TESTSUITE(out) {\n"
+               Style);
   Style.NamespaceMacros.push_back("FOOBAR");
-  EXPECT_EQ("TESTSUITE(out) {\n"
+  verifyFormat("TESTSUITE(out) {\n"
                "FOOBAR(in) {\n"
                "} // FOOBAR(in)\n"
                "} // TESTSUITE(out)",
-            format("TESTSUITE(out) {\n"
-                   "FOOBAR(in) {\n"
-                   "} // FOOBAR(in)\n"
-                   "} // TESTSUITE(out)",
-                   Style));
+               "TESTSUITE(out) {\n"
+               Style);
 }
 
 TEST_F(FormatTest, FormatsCompactNamespaces) {
   FormatStyle Style = getLLVMStyle();
   Style.CompactNamespaces = true;
   Style.NamespaceMacros.push_back("TESTSUITE");
 
   verifyFormat("namespace A { namespace B {\n"
                "}} // namespace A::B",
                Style);
 
-  EXPECT_EQ("namespace out { namespace in {\n"
+  verifyFormat("namespace out { namespace in {\n"
                "}} // namespace out::in",
-            format("namespace out {\n"
-                   "namespace in {\n"
-                   "} // namespace in\n"
-                   "} // namespace out",
-                   Style));
+               "namespace out {\n"
+               Style);
 
   // Only namespaces which have both consecutive opening and end get compacted
-  EXPECT_EQ("namespace out {\n"
+  verifyFormat("namespace out {\n"
                "namespace in1 {\n"
                "} // namespace in1\n"
                "namespace in2 {\n"
                "} // namespace in2\n"
                "} // namespace out",
-            format("namespace out {\n"
-                   "namespace in1 {\n"
-                   "} // namespace in1\n"
-                   "namespace in2 {\n"
-                   "} // namespace in2\n"
-                   "} // namespace out",
-                   Style));
+               "namespace out {\n"
+               Style);
 
-  EXPECT_EQ("namespace out {\n"
+  verifyFormat("namespace out {\n"
                "int i;\n"
                "namespace in {\n"
                "int j;\n"
                "} // namespace in\n"
                "int k;\n"
                "} // namespace out",
-            format("namespace out { int i;\n"
-                   "namespace in { int j; } // namespace in\n"
-                   "int k; } // namespace out",
-                   Style));
+               "namespace out { int i;\n"
+               Style);
 
-  EXPECT_EQ("namespace A { namespace B { namespace C {\n"
+  verifyFormat("namespace A { namespace B { namespace C {\n"
                "}}} // namespace A::B::C\n",
-            format("namespace A { namespace B {\n"
-                   "namespace C {\n"
-                   "}} // namespace B::C\n"
-                   "} // namespace A\n",
-                   Style));
+               "namespace A { namespace B {\n"
+               Style);
 
   Style.ColumnLimit = 40;
-  EXPECT_EQ("namespace aaaaaaaaaa {\n"
+  verifyFormat("namespace aaaaaaaaaa {\n"
                "namespace bbbbbbbbbb {\n"
                "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
-            format("namespace aaaaaaaaaa {\n"
-                   "namespace bbbbbbbbbb {\n"
-                   "} // namespace bbbbbbbbbb\n"
-                   "} // namespace aaaaaaaaaa",
-                   Style));
+               "namespace aaaaaaaaaa {\n"
+               Style);
 
-  EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
+  verifyFormat("namespace aaaaaa { namespace bbbbbb {\n"
                "namespace cccccc {\n"
                "}}} // namespace aaaaaa::bbbbbb::cccccc",
-            format("namespace aaaaaa {\n"
-                   "namespace bbbbbb {\n"
-                   "namespace cccccc {\n"
-                   "} // namespace cccccc\n"
-                   "} // namespace bbbbbb\n"
-                   "} // namespace aaaaaa",
-                   Style));
+               "namespace aaaaaa {\n"
+               Style);
   Style.ColumnLimit = 80;
 
   // Extra semicolon after 'inner' closing brace prevents merging
-  EXPECT_EQ("namespace out { namespace in {\n"
+  verifyFormat("namespace out { namespace in {\n"
                "}; } // namespace out::in",
-            format("namespace out {\n"
-                   "namespace in {\n"
-                   "}; // namespace in\n"
-                   "} // namespace out",
-                   Style));
+               "namespace out {\n"
+               Style);
 
   // Extra semicolon after 'outer' closing brace is conserved
-  EXPECT_EQ("namespace out { namespace in {\n"
+  verifyFormat("namespace out { namespace in {\n"
                "}}; // namespace out::in",
-            format("namespace out {\n"
-                   "namespace in {\n"
-                   "} // namespace in\n"
-                   "}; // namespace out",
-                   Style));
+               "namespace out {\n"
+               Style);
 
   Style.NamespaceIndentation = FormatStyle::NI_All;
-  EXPECT_EQ("namespace out { namespace in {\n"
+  verifyFormat("namespace out { namespace in {\n"
                "  int i;\n"
                "}} // namespace out::in",
-            format("namespace out {\n"
-                   "namespace in {\n"
-                   "int i;\n"
-                   "} // namespace in\n"
-                   "} // namespace out",
-                   Style));
-  EXPECT_EQ("namespace out { namespace mid {\n"
+               "namespace out {\n"
+               Style);
+  verifyFormat("namespace out { namespace mid {\n"
                "  namespace in {\n"
                "    int j;\n"
                "  } // namespace in\n"
                "  int k;\n"
                "}} // namespace out::mid",
-            format("namespace out { namespace mid {\n"
-                   "namespace in { int j; } // namespace in\n"
-                   "int k; }} // namespace out::mid",
-                   Style));
+               "namespace out { namespace mid {\n"
+               Style);
 
   Style.NamespaceIndentation = FormatStyle::NI_Inner;
-  EXPECT_EQ("namespace out { namespace in {\n"
+  verifyFormat("namespace out { namespace in {\n"
                "  int i;\n"
                "}} // namespace out::in",
-            format("namespace out {\n"
-                   "namespace in {\n"
-                   "int i;\n"
-                   "} // namespace in\n"
-                   "} // namespace out",
-                   Style));
-  EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
+               "namespace out {\n"
+               Style);
+  verifyFormat("namespace out { namespace mid { namespace in {\n"
                "  int i;\n"
                "}}} // namespace out::mid::in",
-            format("namespace out {\n"
-                   "namespace mid {\n"
-                   "namespace in {\n"
-                   "int i;\n"
-                   "} // namespace in\n"
-                   "} // namespace mid\n"
-                   "} // namespace out",
-                   Style));
+               "namespace out {\n"
+               Style);
 }
 
 TEST_F(FormatTest, FormatsExternC) {
   verifyFormat("extern \"C\" {\nint a;");
   verifyFormat("extern \"C\" {}");
   verifyFormat("extern \"C\" {\n"
                "int foo();\n"
                "}");
TEST_F(FormatTest, FormatsInlineASM) {
   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
   verifyFormat("asm(\"nop\" ::: \"memory\");");
   verifyFormat(
       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
       "    \"cpuid\\n\\t\"\n"
       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
       "    : \"a\"(value));");
-  EXPECT_EQ(
+  verifyFormat(
       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
       "  __asm {\n"
       "        mov     edx,[that] // vtable in edx\n"
       "        mov     eax,methodIndex\n"
       "        call    [edx][eax*4] // stdcall\n"
       "  }\n"
       "}",
-      format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
-             "    __asm {\n"
-             "        mov     edx,[that] // vtable in edx\n"
-             "        mov     eax,methodIndex\n"
-             "        call    [edx][eax*4] // stdcall\n"
-             "    }\n"
-             "}"));
-  EXPECT_EQ("_asm {\n"
+      "void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
+      "}");
+  verifyFormat("_asm {\n"
                "  xor eax, eax;\n"
                "  cpuid;\n"
                "}",
-            format("_asm {\n"
-                   "  xor eax, eax;\n"
-                   "  cpuid;\n"
-                   "}"));
+               "_asm {\n"
+               "}");
   verifyFormat("void function() {\n"
                "  // comment\n"
                "  asm(\"\");\n"
                "}");
-  EXPECT_EQ("__asm {\n"
+  verifyFormat("__asm {\n"
                "}\n"
                "int i;",
-            format("__asm   {\n"
-                   "}\n"
-                   "int   i;"));
+               "__asm   {\n"
+               "int   i;");
 }
 
 TEST_F(FormatTest, FormatTryCatch) {
   verifyFormat("try {\n"
                "  throw a * b;\n"
                "} catch (int a) {\n"
                "  // Do nothing.\n"
                "} catch (...) {\n"
TEST_F(FormatTest, StaticInitializers) {
 
   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
                "    100000000, "
                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
 
   // Here, everything other than the "}" would fit on a line.
   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
                "    10000000000000000000000000};");
-  EXPECT_EQ("S s = {a,\n"
+  verifyFormat("S s = {a,\n"
                "\n"
                "       b};",
-            format("S s = {\n"
-                   "  a,\n"
-                   "\n"
-                   "  b\n"
-                   "};"));
+               "S s = {\n"
+               "};");
 
   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
   // line. However, the formatting looks a bit off and this probably doesn't
   // happen often in practice.
   verifyFormat("static int Variable[1] = {\n"
                "    {1000000000000000000000000000000000000}};",
                getLLVMStyleWithColumns(40));
 }
verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
                getLLVMStyleWithColumns(40));
 }
 
 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
                getLLVMStyleWithColumns(40));
   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
                getLLVMStyleWithColumns(40));
-  EXPECT_EQ("#define Q                              \\\n"
+  verifyFormat("#define Q                              \\\n"
                "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
                "  \"aaaaaaaa.cpp\"",
-            format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
-                   getLLVMStyleWithColumns(40)));
+               "#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
+               getLLVMStyleWithColumns(40));
 }
 
 TEST_F(FormatTest, UnderstandsLinePPDirective) {
-  EXPECT_EQ("# 123 \"A string literal\"",
-            format("   #     123    \"A string literal\""));
+  verifyFormat("# 123 \"A string literal\"",
+               "   #     123    \"A string literal\"");
 }
 
 TEST_F(FormatTest, LayoutUnknownPPDirective) {
-  EXPECT_EQ("#;", format("#;"));
+  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)));
+  verifyFormat("#line 42 \"test\"\n",
+               "#  \\\n  line  \\\n  42  \\\n  \"test\"\n");
+  verifyFormat("#define A B\n", "#  \\\n define  \\\n    A  \\\n       B\n",
+               getLLVMStyleWithColumns(12));
 }
 
 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"));
+  verifyFormat("#line 42 \"test\"", "#  \\\n  line  \\\n  42  \\\n  \"test\"");
+  verifyFormat("#define A B", "#  \\\n define  \\\n    A  \\\n       B");
 }
 
 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
   verifyFormat("#define A \\x20");
   verifyFormat("#define A \\ x20");
-  EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
+  verifyFormat("#define A \\ x20", "#define A \\   x20");
   verifyFormat("#define A ''");
   verifyFormat("#define A ''qqq");
   verifyFormat("#define A `qqq");
   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
-  EXPECT_EQ("const char *c = STRINGIFY(\n"
+  verifyFormat("const char *c = STRINGIFY(\n"
                "\\na : b);",
-            format("const char * c = STRINGIFY(\n"
-                   "\\na : b);"));
+               "const char * c = STRINGIFY(\n"
+               "\\na : b);");
 
   verifyFormat("a\r\\");
   verifyFormat("a\v\\");
   verifyFormat("a\f\\");
 }
 
 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
   // FIXME: We never break before the macro name.
   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
 
   verifyFormat("#define A A\n#define A A");
   verifyFormat("#define A(X) A\n#define A A");
 
   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
 }
 
 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
-  EXPECT_EQ("// somecomment\n"
+  verifyFormat("// somecomment\n"
                "#include \"a.h\"\n"
                "#define A(  \\\n"
                "    A, B)\n"
                "#include \"b.h\"\n"
                "// somecomment\n",
-            format("  // somecomment\n"
-                   "  #include \"a.h\"\n"
-                   "#define A(A,\\\n"
-                   "    B)\n"
-                   "    #include \"b.h\"\n"
-                   " // somecomment\n",
-                   getLLVMStyleWithColumns(13)));
+               "  // somecomment\n"
+               getLLVMStyleWithColumns(13));
 }
 
-TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
+TEST_F(FormatTest, LayoutSingleHash) { verifyFormat("#\na;", "#\na;"); }
 
 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
-  EXPECT_EQ("#define A    \\\n"
+  verifyFormat("#define A    \\\n"
                "  c;         \\\n"
                "  e;\n"
                "f;",
-            format("#define A c; e;\n"
-                   "f;",
-                   getLLVMStyleWithColumns(14)));
+               "#define A c; e;\n"
+               getLLVMStyleWithColumns(14));
 }
 
-TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
+TEST_F(FormatTest, LayoutRemainingTokens) { verifyFormat("{}", "{}"); }
 
 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
-  EXPECT_EQ("int x,\n"
+  verifyFormat("int x,\n"
                "#define A\n"
                "    y;",
-            format("int x,\n#define A\ny;"));
+               "int x,\n#define A\ny;");
 }
 
 TEST_F(FormatTest, HashInMacroDefinition) {
-  EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
+  verifyFormat("#define A(c) L#c", "#define A(c) L#c", getLLVMStyle());
   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
   verifyFormat("#define A  \\\n"
                "  {        \\\n"
                "    f(#c); \\\n"
                "  }",
                getLLVMStyleWithColumns(11));
 
   verifyFormat("#define A(X)         \\\n"
                "  void function##X()",
                getLLVMStyleWithColumns(22));
 
   verifyFormat("#define A(a, b, c)   \\\n"
                "  void a##b##c()",
                getLLVMStyleWithColumns(22));
 
   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
 }
 
 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
-  EXPECT_EQ("#define A (x)", format("#define A (x)"));
-  EXPECT_EQ("#define A(x)", format("#define A(x)"));
+  verifyFormat("#define A (x)", "#define A (x)");
+  verifyFormat("#define A(x)", "#define A(x)");
 
   FormatStyle Style = getLLVMStyle();
   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
   verifyFormat("#define true ((foo)1)", Style);
   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
   verifyFormat("#define false((foo)0)", Style);
 }
 
 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
-  EXPECT_EQ("#define A b;", format("#define A \\\n"
-                                   "          \\\n"
-                                   "  b;",
-                                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("#define A \\\n"
+  verifyFormat("#define A b;",
+               "#define A \\\n"
+               getLLVMStyleWithColumns(25));
+  verifyFormat("#define A \\\n"
                "          \\\n"
                "  a;      \\\n"
                "  b;",
-            format("#define A \\\n"
-                   "          \\\n"
-                   "  a;      \\\n"
-                   "  b;",
-                   getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("#define A \\\n"
+               "#define A \\\n"
+               getLLVMStyleWithColumns(11));
+  verifyFormat("#define A \\\n"
                "  a;      \\\n"
                "          \\\n"
                "  b;",
-            format("#define A \\\n"
-                   "  a;      \\\n"
-                   "          \\\n"
-                   "  b;",
-                   getLLVMStyleWithColumns(11)));
+               "#define A \\\n"
+               getLLVMStyleWithColumns(11));
 }
 
 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
   verifyIncompleteFormat("#define A :");
   verifyFormat("#define SOMECASES  \\\n"
                "  case 1:          \\\n"
                "  case 2\n",
                getLLVMStyleWithColumns(20));
TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
 }
 
 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
-  EXPECT_EQ("class A : public QObject {\n"
+  verifyFormat("class A : public QObject {\n"
                "  Q_OBJECT\n"
                "\n"
                "  A() {}\n"
                "};",
-            format("class A  :  public QObject {\n"
-                   "     Q_OBJECT\n"
-                   "\n"
-                   "  A() {\n}\n"
-                   "}  ;"));
-  EXPECT_EQ("MACRO\n"
+               "class A  :  public QObject {\n"
+               "}  ;");
+  verifyFormat("MACRO\n"
                "/*static*/ int i;",
-            format("MACRO\n"
-                   " /*static*/ int   i;"));
-  EXPECT_EQ("SOME_MACRO\n"
+               "MACRO\n"
+               " /*static*/ int   i;");
+  verifyFormat("SOME_MACRO\n"
                "namespace {\n"
                "void f();\n"
                "} // namespace",
-            format("SOME_MACRO\n"
-                   "  namespace    {\n"
-                   "void   f(  );\n"
-                   "} // namespace"));
+               "SOME_MACRO\n"
+               "} // namespace");
   // Only if the identifier contains at least 5 characters.
-  EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
-  EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
+  verifyFormat("HTTP f();", "HTTP\nf();");
+  verifyFormat("MACRO\nf();", "MACRO\nf();");
   // Only if everything is upper case.
-  EXPECT_EQ("class A : public QObject {\n"
+  verifyFormat("class A : public QObject {\n"
                "  Q_Object A() {}\n"
                "};",
-            format("class A  :  public QObject {\n"
-                   "     Q_Object\n"
-                   "  A() {\n}\n"
-                   "}  ;"));
+               "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("SOME_WEIRD_LOG_MACRO << SomeThing;", "SOME_WEIRD_LOG_MACRO\n"
+                                                     "<< SomeThing;");
 
   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
                "(n, buffers))\n",
                getChromiumStyle(FormatStyle::LK_Cpp));
 
   // See PR41483
-  EXPECT_EQ("/**/ FOO(a)\n"
+  verifyFormat("/**/ FOO(a)\n"
                "FOO(b)",
-            format("/**/ FOO(a)\n"
-                   "FOO(b)"));
+               "/**/ FOO(a)\n"
+               "FOO(b)");
 }
 
 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
-  EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
+  verifyFormat("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
                "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
                "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
                "class X {};\n"
                "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
                "int *createScopDetectionPass() { return 0; }",
-            format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
-                   "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
-                   "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
-                   "  class X {};\n"
-                   "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
-                   "  int *createScopDetectionPass() { return 0; }"));
+               "  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
+               "  int *createScopDetectionPass() { return 0; }");
   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
   // braces, so that inner block is indented one level more.
-  EXPECT_EQ("int q() {\n"
+  verifyFormat("int q() {\n"
                "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
                "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
                "  IPC_END_MESSAGE_MAP()\n"
                "}",
-            format("int q() {\n"
-                   "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
-                   "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
-                   "  IPC_END_MESSAGE_MAP()\n"
-                   "}"));
+               "int q() {\n"
+               "}");
 
   // Same inside macros.
-  EXPECT_EQ("#define LIST(L) \\\n"
+  verifyFormat("#define LIST(L) \\\n"
                "  L(A)          \\\n"
                "  L(B)          \\\n"
                "  L(C)",
-            format("#define LIST(L) \\\n"
-                   "  L(A) \\\n"
-                   "  L(B) \\\n"
-                   "  L(C)",
-                   getGoogleStyle()));
+               "#define LIST(L) \\\n"
+               getGoogleStyle());
 
   // These must not be recognized as macros.
-  EXPECT_EQ("int q() {\n"
+  verifyFormat("int q() {\n"
                "  f(x);\n"
                "  f(x) {}\n"
                "  f(x)->g();\n"
                "  f(x)->*g();\n"
                "  f(x).g();\n"
                "  f(x) = x;\n"
                "  f(x) += x;\n"
                "  f(x) -= x;\n"
                "  f(x) *= x;\n"
                "  f(x) /= x;\n"
                "  f(x) %= x;\n"
                "  f(x) &= x;\n"
                "  f(x) |= x;\n"
                "  f(x) ^= x;\n"
                "  f(x) >>= x;\n"
                "  f(x) <<= x;\n"
                "  f(x)[y].z();\n"
                "  LOG(INFO) << x;\n"
                "  ifstream(x) >> x;\n"
                "}\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"
+               "int q() {\n"
+               "}\n");
+  verifyFormat("int q() {\n"
                "  F(x)\n"
                "  if (1) {\n"
                "  }\n"
                "  F(x)\n"
                "  while (1) {\n"
                "  }\n"
                "  F(x)\n"
                "  G(x);\n"
                "  F(x)\n"
                "  try {\n"
                "    Q();\n"
                "  } catch (...) {\n"
                "  }\n"
                "}\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"
+               "int q() {\n"
+               "}\n");
+  verifyFormat("class A {\n"
                "  A() : t(0) {}\n"
                "  A(int i) noexcept() : {}\n"
                "  A(X x)\n" // FIXME: function-level try blocks are broken.
                "  try : t(0) {\n"
                "  } catch (...) {\n"
                "  }\n"
                "};",
-            format("class A {\n"
-                   "  A()\n : t(0) {}\n"
-                   "  A(int i)\n noexcept() : {}\n"
-                   "  A(X x)\n"
-                   "  try : t(0) {} catch (...) {}\n"
-                   "};"));
+               "class A {\n"
+               "};");
   FormatStyle Style = getLLVMStyle();
   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
   Style.BraceWrapping.AfterFunction = true;
-  EXPECT_EQ("void f()\n"
+  verifyFormat("void f()\n"
                "try\n"
                "{\n"
                "}",
-            format("void f() try {\n"
-                   "}",
-                   Style));
-  EXPECT_EQ("class SomeClass {\n"
+               "void f() try {\n"
+               Style);
+  verifyFormat("class SomeClass {\n"
                "public:\n"
                "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
                "};",
-            format("class SomeClass {\n"
-                   "public:\n"
-                   "  SomeClass()\n"
-                   "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
-                   "};"));
-  EXPECT_EQ("class SomeClass {\n"
+               "class SomeClass {\n"
+               "};");
+  verifyFormat("class SomeClass {\n"
                "public:\n"
                "  SomeClass()\n"
                "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
                "};",
-            format("class SomeClass {\n"
-                   "public:\n"
-                   "  SomeClass()\n"
-                   "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
-                   "};",
-                   getLLVMStyleWithColumns(40)));
+               "class SomeClass {\n"
+               getLLVMStyleWithColumns(40));
 
   verifyFormat("MACRO(>)");
 
   // Some macros contain an implicit semicolon.
   Style = getLLVMStyle();
   Style.StatementMacros.push_back("FOO");
   verifyFormat("FOO(a) int b = 0;");
   verifyFormat("FOO(a)\n"
verifyFormat("#if 1\n"
                "#else\n"
                "int z;\n"
                "#endif",
                Style);
   // FIXME: This doesn't handle the case where there's code between the
   // #ifndef and #define but all other conditions hold. This is because when
   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
   // previous code line yet, so we can't detect it.
-  EXPECT_EQ("#ifndef NOT_GUARD\n"
+  verifyFormat("#ifndef NOT_GUARD\n"
                "code();\n"
                "#define NOT_GUARD\n"
                "code();\n"
                "#endif",
-            format("#ifndef NOT_GUARD\n"
-                   "code();\n"
-                   "#  define NOT_GUARD\n"
-                   "code();\n"
-                   "#endif",
-                   Style));
+               "#ifndef NOT_GUARD\n"
+               Style);
   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
   // be outside an include guard. Examples are #pragma once and
   // #pragma GCC diagnostic, or anything else that does not change the meaning
   // of the file if it's included multiple times.
-  EXPECT_EQ("#ifdef WIN32\n"
+  verifyFormat("#ifdef WIN32\n"
                "#  pragma once\n"
                "#endif\n"
                "#ifndef HEADER_H\n"
                "#  define HEADER_H\n"
                "code();\n"
                "#endif",
-            format("#ifdef WIN32\n"
-                   "#  pragma once\n"
-                   "#endif\n"
-                   "#ifndef HEADER_H\n"
-                   "#define HEADER_H\n"
-                   "code();\n"
-                   "#endif",
-                   Style));
+               "#ifdef WIN32\n"
+               Style);
   // FIXME: This does not detect when there is a single non-preprocessor line
   // in front of an include-guard-like structure where other conditions hold
   // because ScopedLineState hides the line.
-  EXPECT_EQ("code();\n"
+  verifyFormat("code();\n"
                "#ifndef HEADER_H\n"
                "#define HEADER_H\n"
                "code();\n"
                "#endif",
-            format("code();\n"
-                   "#ifndef HEADER_H\n"
-                   "#  define HEADER_H\n"
-                   "code();\n"
-                   "#endif",
-                   Style));
+               "code();\n"
+               Style);
   // Keep comments aligned with #, otherwise indent comments normally. These
   // tests cannot use verifyFormat because messUp manipulates leading
   // whitespace.
   {
     const char *Expected = ""
                            "void f() {\n"
                            "#if 1\n"
                            "// Preprocessor aligned.\n"
verifyFormat("// Comment\n"
                Style);
 }
 
 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
   verifyFormat("{\n  { a #c; }\n}");
 }
 
 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
-  EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
-            format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
-            format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
+  verifyFormat("#define A \\\n  {       \\\n    {\nint i;",
+               "#define A { {\nint i;", getLLVMStyleWithColumns(11));
+  verifyFormat("#define A \\\n  }       \\\n  }\nint i;",
+               "#define A } }\nint i;", getLLVMStyleWithColumns(11));
 }
 
 TEST_F(FormatTest, EscapedNewlines) {
   FormatStyle Narrow = getLLVMStyleWithColumns(11);
-  EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
-            format("#define A \\\nint i;\\\n  int j;", Narrow));
-  EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
-  EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
-  EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
-  EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
+  verifyFormat("#define A \\\n  int i;  \\\n  int j;",
+               "#define A \\\nint i;\\\n  int j;", Narrow);
+  verifyFormat("#define A\n\nint i;", "#define A \\\n\n int i;");
+  verifyFormat("template <class T> f();", "\\\ntemplate <class T> f();");
+  verifyFormat("/* \\  \\  \\\n */", "\\\n/* \\  \\  \\\n */");
+  verifyFormat("<a\n\\\\\n>", "<a\n\\\\\n>");
 
   FormatStyle AlignLeft = getLLVMStyle();
   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
-  EXPECT_EQ("#define MACRO(x) \\\n"
+  verifyFormat("#define MACRO(x) \\\n"
                "private:         \\\n"
                "  int x(int a);\n",
-            format("#define MACRO(x) \\\n"
-                   "private:         \\\n"
-                   "  int x(int a);\n",
-                   AlignLeft));
+               "#define MACRO(x) \\\n"
+               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 */"));
-  EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
-  EXPECT_EQ("#define MACRO(x) \\\r\n"
+  verifyFormat("#define A \\\r\n  int i;  \\\r\n  int j;",
+               "#define A \\\r\nint i;\\\r\n  int j;", Narrow);
+  verifyFormat("#define A\r\n\r\nint i;", "#define A \\\r\n\r\n int i;");
+  verifyFormat("template <class T> f();", "\\\ntemplate <class T> f();");
+  verifyFormat("/* \\  \\  \\\r\n */", "\\\r\n/* \\  \\  \\\r\n */");
+  verifyFormat("<a\r\n\\\\\r\n>", "<a\r\n\\\\\r\n>");
+  verifyFormat("#define MACRO(x) \\\r\n"
                "private:         \\\r\n"
                "  int x(int a);\r\n",
-            format("#define MACRO(x) \\\r\n"
-                   "private:         \\\r\n"
-                   "  int x(int a);\r\n",
-                   AlignLeft));
+               "#define MACRO(x) \\\r\n"
+               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"
+  verifyFormat("#define A \\\n"
                "  class Foo { \\\n"
                "    void bar(); \\\n"
                "\\\n"
                "\\\n"
                "\\\n"
                "  public: \\\n"
                "    void baz(); \\\n"
                "  };",
-            format("#define A \\\n"
-                   "  class Foo { \\\n"
-                   "    void bar(); \\\n"
-                   "\\\n"
-                   "\\\n"
-                   "\\\n"
-                   "  public: \\\n"
-                   "    void baz(); \\\n"
-                   "  };",
-                   DontAlign));
+               "#define A \\\n"
+               DontAlign);
 }
 
 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
   verifyFormat("#define A \\\n"
                "  int v(  \\\n"
                "      a); \\\n"
                "  int i;",
                getLLVMStyleWithColumns(11));
 }
 
 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
-  EXPECT_EQ(
-      "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
+  verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
                "                      \\\n"
                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
                "\n"
                "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
                "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
-      format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
+               "  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
                "\\\n"
                "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
                "  \n"
                "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
-             "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
+               "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n");
 }
 
 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
-  EXPECT_EQ("int\n"
+  verifyFormat("int\n"
                "#define A\n"
                "    a;",
-            format("int\n#define A\na;"));
+               "int\n#define A\na;");
   verifyFormat("functionCallTo(\n"
                "    someOtherFunction(\n"
                "        withSomeParameters, whichInSequence,\n"
                "        areLongerThanALine(andAnotherCall,\n"
                "#define A B\n"
                "                           withMoreParamters,\n"
                "                           whichStronglyInfluenceTheLayout),\n"
                "        andMoreParameters),\n"
verifyFormat(
       "                                     ccccccccccccccccc));");
   verifyFormat("DEBUG({\n"
                "  if (a)\n"
                "    f();\n"
                "});");
 }
 
 TEST_F(FormatTest, LayoutBlockInsideStatement) {
-  EXPECT_EQ("SOME_MACRO { int i; }\n"
+  verifyFormat("SOME_MACRO { int i; }\n"
                "int i;",
-            format("  SOME_MACRO  {int i;}  int i;"));
+               "  SOME_MACRO  {int i;}  int i;");
 }
 
 TEST_F(FormatTest, LayoutNestedBlocks) {
   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
                "  struct s {\n"
                "    int i;\n"
                "  };\n"
                "  s kBitsToOs[] = {{10}};\n"
TEST_F(FormatTest, LayoutNestedBlocks) {
   verifyFormat("DEBUG( //\n"
                "    { f(); }, a);");
   verifyFormat("DEBUG( //\n"
                "    {\n"
                "      f(); //\n"
                "    },\n"
                "    a);");
 
-  EXPECT_EQ("call(parameter, {\n"
+  verifyFormat("call(parameter, {\n"
                "  something();\n"
                "  // Comment too\n"
                "  // looooooooooong.\n"
                "  somethingElse();\n"
                "});",
-            format("call(parameter, {\n"
-                   "  something();\n"
-                   "  // Comment too looooooooooong.\n"
-                   "  somethingElse();\n"
-                   "});",
-                   getLLVMStyleWithColumns(29)));
-  EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
-  EXPECT_EQ("DEBUG({ // comment\n"
+               "call(parameter, {\n"
+               getLLVMStyleWithColumns(29));
+  verifyFormat("DEBUG({ int i; });", "DEBUG({ int   i; });");
+  verifyFormat("DEBUG({ // comment\n"
                "  int i;\n"
                "});",
-            format("DEBUG({ // comment\n"
-                   "int  i;\n"
-                   "});"));
-  EXPECT_EQ("DEBUG({\n"
+               "DEBUG({ // comment\n"
+               "});");
+  verifyFormat("DEBUG({\n"
                "  int i;\n"
                "\n"
                "  // comment\n"
                "  int j;\n"
                "});",
-            format("DEBUG({\n"
-                   "  int  i;\n"
-                   "\n"
-                   "  // comment\n"
-                   "  int  j;\n"
-                   "});"));
+               "DEBUG({\n"
+               "});");
 
   verifyFormat("DEBUG({\n"
                "  if (a)\n"
                "    return;\n"
                "});");
   verifyGoogleFormat("DEBUG({\n"
                      "  if (a) return;\n"
                      "});");
   FormatStyle Style = getGoogleStyle();
   Style.ColumnLimit = 45;
   verifyFormat("Debug(\n"
                "    aaaaa,\n"
                "    {\n"
                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
                "    },\n"
                "    a);",
                Style);
 
   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
 
   verifyNoCrash("^{v^{a}}");
 }
 
 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
-  EXPECT_EQ("#define MACRO()                     \\\n"
+  verifyFormat("#define MACRO()                     \\\n"
                "  Debug(aaa, /* force line break */ \\\n"
                "        {                           \\\n"
                "          int i;                    \\\n"
                "          int j;                    \\\n"
                "        })",
-            format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
-                   "          {  int   i;  int  j;   })",
-                   getGoogleStyle()));
+               "#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
+               getGoogleStyle());
 
-  EXPECT_EQ("#define A                                       \\\n"
+  verifyFormat("#define A                                       \\\n"
                "  [] {                                          \\\n"
                "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
                "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
                "  }",
-            format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
-                   "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
-                   getGoogleStyle()));
+               "#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
+               getGoogleStyle());
 }
 
 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
-  EXPECT_EQ("{}", format("{}"));
+  verifyFormat("{}", "{}");
   verifyFormat("enum E {};");
   verifyFormat("enum E {}");
   FormatStyle Style = getLLVMStyle();
   Style.SpaceInEmptyBlock = true;
-  EXPECT_EQ("void f() { }", format("void f() {}", Style));
+  verifyFormat("void f() { }", "void f() {}", Style);
   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
-  EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
+  verifyFormat("while (true) { }", "while (true) {}", Style);
 }
 
 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
   FormatStyle Style = getLLVMStyle();
   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
   Style.MacroBlockEnd = "^[A-Z_]+_END$";
   verifyFormat("FOO_BEGIN\n"
                "  FOO_ENTRY\n"
verifyFormat("zzzzzzzzzz\n"
                Style);
 
   Style.ColumnLimit = 80;
   Style.IndentWidth = 4;
   Style.TabWidth = 4;
   Style.UseTab = FormatStyle::UT_Always;
   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
   Style.AlignOperands = FormatStyle::OAS_DontAlign;
-  EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
+  verifyFormat("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
                "\t&& (someOtherLongishConditionPart1\n"
                "\t\t|| someOtherEvenLongerNestedConditionPart2);",
-            format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
-                   "(someOtherLongishConditionPart1 || "
-                   "someOtherEvenLongerNestedConditionPart2);",
-                   Style));
+               "return someVeryVeryLongConditionThatBarelyFitsOnALine && "
+               Style);
 }
 
 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
   FormatStyle Style = getLLVMStyle();
   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
 
   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
verifyFormat(
       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
       OnePerLine);
   OnePerLine.ColumnLimit = 60;
   verifyFormat("Constructor()\n"
                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
                OnePerLine);
 
-  EXPECT_EQ("Constructor()\n"
+  verifyFormat("Constructor()\n"
                "    : // Comment forcing unwanted break.\n"
                "      aaaa(aaaa) {}",
-            format("Constructor() :\n"
-                   "    // Comment forcing unwanted break.\n"
-                   "    aaaa(aaaa) {}"));
+               "Constructor() :\n"
+               "    aaaa(aaaa) {}");
 }
 
 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
   FormatStyle Style = getLLVMStyle();
   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
   Style.ColumnLimit = 60;
   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
   Style.AllowAllConstructorInitializersOnNextLine = true;
verifyFormat("Constructor() :\n"
                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
                OnePerLine);
   OnePerLine.ColumnLimit = 60;
   verifyFormat("Constructor() :\n"
                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
                OnePerLine);
 
-  EXPECT_EQ("Constructor() :\n"
+  verifyFormat("Constructor() :\n"
                "    // Comment forcing unwanted break.\n"
                "    aaaa(aaaa) {}",
-            format("Constructor() :\n"
-                   "    // Comment forcing unwanted break.\n"
-                   "    aaaa(aaaa) {}",
-                   Style));
+               "Constructor() :\n"
+               Style);
 
   Style.ColumnLimit = 0;
   verifyFormat("SomeClass::Constructor() :\n"
                "    a(a) {}",
                Style);
   verifyFormat("SomeClass::Constructor() noexcept :\n"
                "    a(a) {}",
                Style);
TEST_F(FormatTest, BreaksFunctionDeclarations) {
   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
                Style);
 }
 
 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
   // Prefer keeping `::` followed by `operator` together.
-  EXPECT_EQ("const aaaa::bbbbbbb &\n"
+  verifyFormat("const aaaa::bbbbbbb &\n"
                "ccccccccc::operator++() {\n"
                "  stuff();\n"
                "}",
-            format("const aaaa::bbbbbbb\n"
-                   "&ccccccccc::operator++() { stuff(); }",
-                   getLLVMStyleWithColumns(40)));
+               "const aaaa::bbbbbbb\n"
+               getLLVMStyleWithColumns(40));
 }
 
 TEST_F(FormatTest, TrailingReturnType) {
   verifyFormat("auto foo() -> int;\n");
   // correct trailing return type spacing
   verifyFormat("auto operator->() -> int;\n");
   verifyFormat("auto operator++(int) -> int;\n");
 
TEST_F(FormatTest, BreaksDesireably) {
 
   verifyFormat("{\n  {\n    {\n"
                "      Annotation.SpaceRequiredBefore =\n"
                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
                "    }\n  }\n}");
 
   // Break on an outer level if there was a break on an inner level.
-  EXPECT_EQ("f(g(h(a, // comment\n"
+  verifyFormat("f(g(h(a, // comment\n"
                "      b, c),\n"
                "    d, e),\n"
                "  x, y);",
-            format("f(g(h(a, // comment\n"
-                   "    b, c), d, e), x, y);"));
+               "f(g(h(a, // comment\n"
+               "    b, c), d, e), x, y);");
 
   // Prefer breaking similar line breaks.
   verifyFormat(
       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
       "                             NSTrackingMouseEnteredAndExited |\n"
       "                             NSTrackingActiveAlways;");
 }
 
verifyFormat(
       "template <class SomeType, class SomeOtherType>\n"
       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
       NoBinPacking);
 }
 
 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
   FormatStyle Style = getLLVMStyleWithColumns(15);
   Style.ExperimentalAutoDetectBinPacking = true;
-  EXPECT_EQ("aaa(aaaa,\n"
+  verifyFormat("aaa(aaaa,\n"
                "    aaaa,\n"
                "    aaaa);\n"
                "aaa(aaaa,\n"
                "    aaaa,\n"
                "    aaaa);",
-            format("aaa(aaaa,\n" // one-per-line
-                   "  aaaa,\n"
-                   "    aaaa  );\n"
-                   "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
-                   Style));
-  EXPECT_EQ("aaa(aaaa, aaaa,\n"
+               "aaa(aaaa,\n" // one-per-line
+               Style);
+  verifyFormat("aaa(aaaa, aaaa,\n"
                "    aaaa);\n"
                "aaa(aaaa, aaaa,\n"
                "    aaaa);",
-            format("aaa(aaaa,  aaaa,\n" // bin-packed
-                   "    aaaa  );\n"
-                   "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
-                   Style));
+               "aaa(aaaa,  aaaa,\n" // bin-packed
+               Style);
 }
 
 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"
verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
                "                                      \"short literal\");");
   verifyFormat(
       "looooooooooooooooooooooooongFunction(\n"
       "    \"short literal\"\n"
       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
   verifyFormat("someFunction(\"Always break between multi-line\"\n"
                "             \" string literals\",\n"
                "             and, other, parameters);");
-  EXPECT_EQ("fun + \"1243\" /* comment */\n"
+  verifyFormat("fun + \"1243\" /* comment */\n"
                "      \"5678\";",
-            format("fun + \"1243\" /* comment */\n"
-                   "    \"5678\";",
-                   getLLVMStyleWithColumns(28)));
-  EXPECT_EQ(
+               "fun + \"1243\" /* comment */\n"
+               getLLVMStyleWithColumns(28));
+  verifyFormat(
       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
       "         \"aaaaaaaaaaaaaaaa\";",
-      format("aaaaaa ="
-             "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
-             "aaaaaaaaaaaaaaaaaaaaa\" "
-             "\"aaaaaaaaaaaaaaaa\";"));
+      "aaaaaa ="
+      "\"aaaaaaaaaaaaaaaa\";");
   verifyFormat("a = a + \"a\"\n"
                "        \"a\"\n"
                "        \"a\";");
   verifyFormat("f(\"a\", \"b\"\n"
                "       \"c\");");
 
   verifyFormat(
       "#define LL_FORMAT \"ll\"\n"
verifyFormat("string foo = abc ? \"x\"\n"
                Break);
 
   // Don't break if there is no column gain.
   verifyFormat("f(\"aaaa\"\n"
                "  \"bbbb\");",
                Break);
 
   // Treat literals with escaped newlines like multi-line string literals.
-  EXPECT_EQ("x = \"a\\\n"
+  verifyFormat("x = \"a\\\n"
                "b\\\n"
                "c\";",
-            format("x = \"a\\\n"
-                   "b\\\n"
-                   "c\";",
-                   NoBreak));
-  EXPECT_EQ("xxxx =\n"
+               "x = \"a\\\n"
+               NoBreak);
+  verifyFormat("xxxx =\n"
                "    \"a\\\n"
                "b\\\n"
                "c\";",
-            format("xxxx = \"a\\\n"
-                   "b\\\n"
-                   "c\";",
-                   Break));
+               "xxxx = \"a\\\n"
+               Break);
 
-  EXPECT_EQ("NSString *const kString =\n"
+  verifyFormat("NSString *const kString =\n"
                "    @\"aaaa\"\n"
                "    @\"bbbb\";",
-            format("NSString *const kString = @\"aaaa\"\n"
-                   "@\"bbbb\";",
-                   Break));
+               "NSString *const kString = @\"aaaa\"\n"
+               Break);
 
   Break.ColumnLimit = 0;
   verifyFormat("const char *hello = \"hello llvm\";", Break);
 }
 
 TEST_F(FormatTest, AlignsPipes) {
   verifyFormat(
       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
                "    << aaa;");
 
   verifyFormat(
       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
 
   // Incomplete string literal.
-  EXPECT_EQ("llvm::errs() << \"\n"
+  verifyFormat("llvm::errs() << \"\n"
                "             << a;",
-            format("llvm::errs() << \"\n<<a;"));
+               "llvm::errs() << \"\n<<a;");
 
   verifyFormat("void f() {\n"
                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
                "}");
 
   // Handle 'endl'.
   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
verifyFormat(
       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
       getLLVMStyleWithColumns(72));
-  EXPECT_EQ("static_cast<A< //\n"
+  verifyFormat("static_cast<A< //\n"
                "    B> *>(\n"
                "\n"
                ");",
-            format("static_cast<A<//\n"
-                   "    B>*>(\n"
-                   "\n"
-                   "    );"));
+               "static_cast<A<//\n"
+               "    );");
   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
 
   FormatStyle AlwaysBreak = getLLVMStyle();
   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
TEST_F(FormatTest, WrapsTemplateDeclarations) {
   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
                "bbbbbbbbbbbbbbbbbbbb) {}",
                NeverBreak);
 }
 
 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
   Style.ColumnLimit = 60;
-  EXPECT_EQ("// Baseline - no comments.\n"
+  verifyFormat("// Baseline - no comments.\n"
                "template <\n"
                "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
                "void f() {}",
-            format("// Baseline - no comments.\n"
-                   "template <\n"
-                   "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
-                   "void f() {}",
-                   Style));
+               "// Baseline - no comments.\n"
+               Style);
 
-  EXPECT_EQ("template <\n"
+  verifyFormat("template <\n"
                "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
                "void f() {}",
-            format("template <\n"
-                   "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
-                   "void f() {}",
-                   Style));
+               "template <\n"
+               Style);
 
-  EXPECT_EQ(
+  verifyFormat(
       "template <\n"
       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
       "void f() {}",
-      format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
-             "void f() {}",
-             Style));
+      "template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
+      Style);
 
-  EXPECT_EQ(
-      "template <\n"
+  verifyFormat("template <\n"
                "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
                "                                               // multiline\n"
                "void f() {}",
-      format("template <\n"
+               "template <\n"
                "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
                "                                              // multiline\n"
                "void f() {}",
-             Style));
+               Style);
 
-  EXPECT_EQ(
+  verifyFormat(
       "template <typename aaaaaaaaaa<\n"
       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
       "void f() {}",
-      format(
-          "template <\n"
-          "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
-          "void f() {}",
-          Style));
+
+      Style);
 }
 
 TEST_F(FormatTest, WrapsTemplateParameters) {
   FormatStyle Style = getLLVMStyle();
   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
   verifyFormat(
       "template <typename... a> struct q {};\n"
TEST_F(FormatTest, UnderstandsTemplateParameters) {
   verifyGoogleFormat("A<A<A<A<int>>>> a;");
   verifyGoogleFormat("A<A<int> > a;");
   verifyGoogleFormat("A<A<A<int> > > a;");
   verifyGoogleFormat("A<A<A<A<int> > > > a;");
   verifyGoogleFormat("A<::A<int>> a;");
   verifyGoogleFormat("A<::A> a;");
   verifyGoogleFormat("A< ::A> a;");
   verifyGoogleFormat("A< ::A<int> > a;");
-  EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
-  EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
-  EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
-  EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
-  EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
-            format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
+  verifyFormat("A<A<A<A>>> a;", "A<A<A<A> >> a;", getGoogleStyle());
+  verifyFormat("A<A<A<A>>> a;", "A<A<A<A>> > a;", getGoogleStyle());
+  verifyFormat("A<::A<int>> a;", "A< ::A<int>> a;", getGoogleStyle());
+  verifyFormat("A<::A<int>> a;", "A<::A<int> > a;", getGoogleStyle());
+  verifyFormat("auto x = [] { A<A<A<A>>> a; };", "auto x=[]{A<A<A<A> >> a;};",
+               getGoogleStyle());
 
   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
 
   // template closer followed by a token that starts with > or =
   verifyFormat("bool b = a<1> > 1;");
   verifyFormat("bool b = a<1> >= 1;");
   verifyFormat("int i = a<1> >> 1;");
   FormatStyle Style = getLLVMStyle();
verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
                getLLVMStyleWithColumns(60));
   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
 }
 
 TEST_F(FormatTest, BitshiftOperatorWidth) {
-  EXPECT_EQ("int a = 1 << 2; /* foo\n"
+  verifyFormat("int a = 1 << 2; /* foo\n"
                "                   bar */",
-            format("int    a=1<<2;  /* foo\n"
-                   "                   bar */"));
+               "int    a=1<<2;  /* foo\n"
+               "                   bar */");
 
-  EXPECT_EQ("int b = 256 >> 1; /* foo\n"
+  verifyFormat("int b = 256 >> 1; /* foo\n"
                "                     bar */",
-            format("int  b  =256>>1 ;  /* foo\n"
-                   "                      bar */"));
+               "int  b  =256>>1 ;  /* foo\n"
+               "                      bar */");
 }
 
 TEST_F(FormatTest, UnderstandsBinaryOperators) {
   verifyFormat("COMPARE(a, ==, b);");
   verifyFormat("auto s = sizeof...(Ts) - 1;");
 }
 
 TEST_F(FormatTest, UnderstandsPointersToMembers) {
TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
   verifyFormat("void f() { f(float{1}, a * a); }");
   // FIXME: Is there a way to make this work?
   // verifyIndependentOfContext("MACRO(A *a);");
 
   verifyFormat("DatumHandle const *operator->() const { return input_; }");
   verifyFormat("return options != nullptr && operator==(*options);");
 
-  EXPECT_EQ("#define OP(x)                                    \\\n"
+  verifyFormat("#define OP(x)                                    \\\n"
                "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
                "    return s << a.DebugString();                 \\\n"
                "  }",
-            format("#define OP(x) \\\n"
-                   "  ostream &operator<<(ostream &s, const A &a) { \\\n"
-                   "    return s << a.DebugString(); \\\n"
-                   "  }",
-                   getLLVMStyleWithColumns(50)));
+               "#define OP(x) \\\n"
+               getLLVMStyleWithColumns(50));
 
   // FIXME: We cannot handle this case yet; we might be able to figure out that
   // foo<x> d > v; doesn't make sense.
   verifyFormat("foo<a<b && c> d> v;");
 
   FormatStyle PointerMiddle = getLLVMStyle();
   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
   verifyFormat("delete *x;", PointerMiddle);
verifyFormat("MACRO;\n"
                "  //...\n"
                "}");
 
   verifyFormat("MACRO;\n"
                "[[nodiscard]] int foo() {\n"
                "  //...\n"
                "}");
 
-  EXPECT_EQ("MACRO\n\n"
+  verifyFormat("MACRO\n\n"
                "__attribute__((maybe_unused)) int foo() {\n"
                "  //...\n"
                "}",
-            format("MACRO\n\n"
-                   "__attribute__((maybe_unused)) int foo() {\n"
-                   "  //...\n"
-                   "}"));
+               "MACRO\n\n"
+               "}");
 
-  EXPECT_EQ("MACRO\n\n"
+  verifyFormat("MACRO\n\n"
                "[[nodiscard]] int foo() {\n"
                "  //...\n"
                "}",
-            format("MACRO\n\n"
-                   "[[nodiscard]] int foo() {\n"
-                   "  //...\n"
-                   "}"));
+               "MACRO\n\n"
+               "}");
 }
 
 TEST_F(FormatTest, AttributePenaltyBreaking) {
   FormatStyle Style = getLLVMStyle();
   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
                Style);
   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
TEST_F(FormatTest, UnderstandsEllipsis) {
   verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
 
   FormatStyle PointersLeft = getLLVMStyle();
   PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
 }
 
 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
-  EXPECT_EQ("int *a;\n"
+  verifyFormat("int *a;\n"
                "int *a;\n"
                "int *a;",
-            format("int *a;\n"
-                   "int* a;\n"
-                   "int *a;",
-                   getGoogleStyle()));
-  EXPECT_EQ("int* a;\n"
+               "int *a;\n"
+               getGoogleStyle());
+  verifyFormat("int* a;\n"
                "int* a;\n"
                "int* a;",
-            format("int* a;\n"
-                   "int* a;\n"
-                   "int *a;",
-                   getGoogleStyle()));
-  EXPECT_EQ("int *a;\n"
+               "int* a;\n"
+               getGoogleStyle());
+  verifyFormat("int *a;\n"
                "int *a;\n"
                "int *a;",
-            format("int *a;\n"
-                   "int * a;\n"
-                   "int *  a;",
-                   getGoogleStyle()));
-  EXPECT_EQ("auto x = [] {\n"
+               "int *a;\n"
+               getGoogleStyle());
+  verifyFormat("auto x = [] {\n"
                "  int *a;\n"
                "  int *a;\n"
                "  int *a;\n"
                "};",
-            format("auto x=[]{int *a;\n"
-                   "int * a;\n"
-                   "int *  a;};",
-                   getGoogleStyle()));
+               "auto x=[]{int *a;\n"
+               getGoogleStyle());
 }
 
 TEST_F(FormatTest, UnderstandsRvalueReferences) {
   verifyFormat("int f(int &&a) {}");
   verifyFormat("int f(int a, char &&b) {}");
   verifyFormat("void f() { int &&a = b; }");
   verifyGoogleFormat("int f(int a, char&& b) {}");
   verifyGoogleFormat("void f() { int&& a = b; }");
verifyFormat("#include <string>\n"
                "#include <a-a>\n"
                "#include < path with space >\n"
                "#include_next <test.h>"
                "#include \"abc.h\" // this is included for ABC\n"
                "#include \"some long include\" // with a comment\n"
                "#include \"some very long include path\"\n"
                "#include <some/very/long/include/path>\n",
                getLLVMStyleWithColumns(35));
-  EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
-  EXPECT_EQ("#include <a>", format("#include<a>"));
+  verifyFormat("#include \"a.h\"", "#include  \"a.h\"");
+  verifyFormat("#include <a>", "#include<a>");
 
   verifyFormat("#import <string>");
   verifyFormat("#import <a/b/c.h>");
   verifyFormat("#import \"a/b/string\"");
   verifyFormat("#import \"string.h\"");
   verifyFormat("#import \"string.h\"");
   verifyFormat("#if __has_include(<strstream>)\n"
                "#include <strstream>\n"
TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
   verifyFormat("void f() {\n"
                "  if (0)\n"
                "    return\n"
                "}\n"
                "42");
 }
 
 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
-  EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
-  EXPECT_EQ("void f() {\n"
+  verifyFormat("void f() { return }", "void  f ( )  {  return  }");
+  verifyFormat("void f() {\n"
                "  if (a)\n"
                "    return\n"
                "}",
-            format("void  f  (  )  {  if  ( a )  return  }"));
-  EXPECT_EQ("namespace N {\n"
+               "void  f  (  )  {  if  ( a )  return  }");
+  verifyFormat("namespace N {\n"
                "void f()\n"
                "}",
-            format("namespace  N  {  void f()  }"));
-  EXPECT_EQ("namespace N {\n"
+               "namespace  N  {  void f()  }");
+  verifyFormat("namespace N {\n"
                "void f() {}\n"
                "void g()\n"
                "} // namespace N",
-            format("namespace N  { void f( ) { } void g( ) }"));
+               "namespace N  { void f( ) { } void g( ) }");
 }
 
 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
   verifyFormat("int aaaaaaaa =\n"
                "    // Overlylongcomment\n"
                "    b;",
                getLLVMStyleWithColumns(20));
   verifyFormat("function(\n"

 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"));
+  verifyFormat("{\n  {}\n", "{\n{\n}\n");
+  verifyFormat("{\n  {}\n", "{\n  {\n}\n");
+  verifyFormat("{\n  {}\n", "{\n  {\n  }\n");
+  verifyFormat("{\n  {}\n}\n}\n", "{\n  {\n    }\n  }\n}\n");
 
-  EXPECT_EQ("{\n"
+  verifyFormat("{\n"
                "  {\n"
                "    breakme(\n"
                "        qwe);\n"
                "  }\n",
-            format("{\n"
-                   "    {\n"
-                   " breakme(qwe);\n"
-                   "}\n",
-                   getLLVMStyleWithColumns(10)));
+               "{\n"
+               getLLVMStyleWithColumns(10));
 }
 
 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
   verifyFormat("int x = {\n"
                "    avariable,\n"
                "    b(alongervariable)};",
                getLLVMStyleWithColumns(25));
 }
verifyFormat(
       "const Aaaaaa aaaaa = {\n"
       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
       "};",
       NoBinPacking);
 
   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
-  EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
+  verifyFormat("static uint8 CddDp83848Reg[] = {\n"
                "    CDDDP83848_BMCR_REGISTER,\n"
                "    CDDDP83848_BMSR_REGISTER,\n"
                "    CDDDP83848_RBR_REGISTER};",
-            format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
-                   "                                CDDDP83848_BMSR_REGISTER,\n"
-                   "                                CDDDP83848_RBR_REGISTER};",
-                   NoBinPacking));
+               "static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
+               NoBinPacking);
 
   // FIXME: The alignment of these trailing comments might be bad. Then again,
   // this might be utterly useless in real code.
   verifyFormat("Constructor::Constructor()\n"
                "    : some_value{         //\n"
                "                 aaaaaaa, //\n"
                "                 bbbbbbb} {}");
 
   // In braced lists, the first comment is always assumed to belong to the
   // first element. Thus, it can be moved to the next or previous line as
   // appropriate.
-  EXPECT_EQ("function({// First element:\n"
+  verifyFormat("function({// First element:\n"
                "          1,\n"
                "          // Second element:\n"
                "          2});",
-            format("function({\n"
-                   "    // First element:\n"
-                   "    1,\n"
-                   "    // Second element:\n"
-                   "    2});"));
-  EXPECT_EQ("std::vector<int> MyNumbers{\n"
+               "function({\n"
+               "    2});");
+  verifyFormat("std::vector<int> MyNumbers{\n"
                "    // First element:\n"
                "    1,\n"
                "    // Second element:\n"
                "    2};",
-            format("std::vector<int> MyNumbers{// First element:\n"
-                   "                           1,\n"
-                   "                           // Second element:\n"
-                   "                           2};",
-                   getLLVMStyleWithColumns(30)));
+               "std::vector<int> MyNumbers{// First element:\n"
+               getLLVMStyleWithColumns(30));
   // A trailing comma should still lead to an enforced line break and no
   // binpacking.
-  EXPECT_EQ("vector<int> SomeVector = {\n"
+  verifyFormat("vector<int> SomeVector = {\n"
                "    // aaa\n"
                "    1,\n"
                "    2,\n"
                "};",
-            format("vector<int> SomeVector = { // aaa\n"
-                   "    1, 2, };"));
+               "vector<int> SomeVector = { // aaa\n"
+               "    1, 2, };");
 
   // C++11 brace initializer list l-braces should not be treated any differently
   // when breaking before lambda bodies is enabled
   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
   verifyFormat(
TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
   SpaceBetweenBraces.SpacesInParentheses = true;
   SpaceBetweenBraces.SpacesInSquareBrackets = true;
   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
   verifyFormat("vector< int > x{ // comment 1\n"
                "                 1, 2, 3, 4 };",
                SpaceBetweenBraces);
   SpaceBetweenBraces.ColumnLimit = 20;
-  EXPECT_EQ("vector< int > x{\n"
+  verifyFormat("vector< int > x{\n"
                "    1, 2, 3, 4 };",
-            format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
+               "vector<int>x{1,2,3,4};", SpaceBetweenBraces);
   SpaceBetweenBraces.ColumnLimit = 24;
-  EXPECT_EQ("vector< int > x{ 1, 2,\n"
+  verifyFormat("vector< int > x{ 1, 2,\n"
                "                 3, 4 };",
-            format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
-  EXPECT_EQ("vector< int > x{\n"
+               "vector<int>x{1,2,3,4};", SpaceBetweenBraces);
+  verifyFormat("vector< int > x{\n"
                "    1,\n"
                "    2,\n"
                "    3,\n"
                "    4,\n"
                "};",
-            format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
+               "vector<int>x{1,2,3,4,};", SpaceBetweenBraces);
   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
 }
 
 TEST_F(FormatTest, FormatSpacesInAngles) {
   FormatStyle SpaceInAngles = getLLVMStyle();
   SpaceInAngles.SpacesInAngles = true;
verifyFormat("class C {\n"
                "        kkkkkkk(nullptr),\n"
                "        mmmmmmm(nullptr),\n"
                "        nnnnnnn(nullptr) {}\n"
                "};",
                getGoogleStyle());
 
   FormatStyle NoColumnLimit = getLLVMStyle();
   NoColumnLimit.ColumnLimit = 0;
-  EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
-  EXPECT_EQ("class C {\n"
+  verifyFormat("A() : b(0) {}", "A():b(0){}", NoColumnLimit);
+  verifyFormat("class C {\n"
                "  A() : b(0) {}\n"
                "};",
-            format("class C{A():b(0){}};", NoColumnLimit));
-  EXPECT_EQ("A()\n"
+               "class C{A():b(0){}};", NoColumnLimit);
+  verifyFormat("A()\n"
                "    : b(0) {\n"
                "}",
-            format("A()\n:b(0)\n{\n}", NoColumnLimit));
+               "A()\n:b(0)\n{\n}", NoColumnLimit);
 
   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
       FormatStyle::SFS_None;
-  EXPECT_EQ("A()\n"
+  verifyFormat("A()\n"
                "    : b(0) {\n"
                "}",
-            format("A():b(0){}", DoNotMergeNoColumnLimit));
-  EXPECT_EQ("A()\n"
+               "A():b(0){}", DoNotMergeNoColumnLimit);
+  verifyFormat("A()\n"
                "    : b(0) {\n"
                "}",
-            format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
+               "A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit);
 
   verifyFormat("#define A          \\\n"
                "  void f() {       \\\n"
                "    int i;         \\\n"
                "  }",
                getLLVMStyleWithColumns(20));
   verifyFormat("#define A           \\\n"
                "  void f() { int i; }",
verifyFormat("if (true)\n"
                "else\n"
                "  f();\n");
 
   // This is simply incomplete. Formatting is not important, but must not crash.
   verifyFormat("class A:");
 }
 
 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
-  EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
-            format("#error Leave     all         white!!!!! space* alone!\n"));
-  EXPECT_EQ(
-      "#warning Leave     all         white!!!!! space* alone!\n",
-      format("#warning Leave     all         white!!!!! space* alone!\n"));
-  EXPECT_EQ("#error 1", format("  #  error   1"));
-  EXPECT_EQ("#warning 1", format("  #  warning 1"));
+  verifyFormat("#error Leave     all         white!!!!! space* alone!\n",
+               "#error Leave     all         white!!!!! space* alone!\n");
+  verifyFormat("#warning Leave     all         white!!!!! space* alone!\n",
+               "#warning Leave     all         white!!!!! space* alone!\n");
+  verifyFormat("#error 1", "  #  error   1");
+  verifyFormat("#warning 1", "  #  warning 1");
 }
 
 TEST_F(FormatTest, FormatHashIfExpressions) {
   verifyFormat("#if AAAA && BBBB");
   verifyFormat("#if (AAAA && BBBB)");
   verifyFormat("#elif (AAAA && BBBB)");
   // FIXME: Come up with a better indentation for #elif.
   verifyFormat(
       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
       "    defined(BBBBBBBB)\n"
       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
       "    defined(BBBBBBBB)\n"
       "#endif",
       getLLVMStyleWithColumns(65));
 }
 
 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
   FormatStyle AllowsMergedIf = getGoogleStyle();
   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
       FormatStyle::SIS_WithoutElse;
   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
-  EXPECT_EQ("if (true) return 42;",
-            format("if (true)\nreturn 42;", AllowsMergedIf));
+  verifyFormat("if (true) return 42;", "if (true)\nreturn 42;", AllowsMergedIf);
   FormatStyle ShortMergedIf = AllowsMergedIf;
   ShortMergedIf.ColumnLimit = 25;
   verifyFormat("#define A \\\n"
                "  if (true) return 42;",
                ShortMergedIf);
   verifyFormat("#define A \\\n"
                "  f();    \\\n"
                "  if (true)\n"

 }
 
 //===----------------------------------------------------------------------===//
 // Objective-C tests.
 //===----------------------------------------------------------------------===//
 
 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
-  EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
-            format("-(NSUInteger)indexOfObject:(id)anObject;"));
-  EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
-  EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
-  EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
-            format("-(NSInteger)Method3:(id)anObject;"));
-  EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
-            format("-(NSInteger)Method4:(id)anObject;"));
-  EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
-            format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
-  EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
-            format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
-  EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
+  verifyFormat("- (NSUInteger)indexOfObject:(id)anObject;",
+               "-(NSUInteger)indexOfObject:(id)anObject;");
+  verifyFormat("- (NSInteger)Mthod1;", "-(NSInteger)Mthod1;");
+  verifyFormat("+ (id)Mthod2;", "+(id)Mthod2;");
+  verifyFormat("- (NSInteger)Method3:(id)anObject;",
+               "-(NSInteger)Method3:(id)anObject;");
+  verifyFormat("- (NSInteger)Method4:(id)anObject;",
+               "-(NSInteger)Method4:(id)anObject;");
+  verifyFormat("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
+               "-(NSInteger)Method5:(id)anObject:(id)AnotherObject;");
+  verifyFormat("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
+               "- (id)Method6:(id)A:(id)B:(id)C:(id)D;");
+  verifyFormat("- (void)sendAction:(SEL)aSelector to:(id)anObject "
                "forAllCells:(BOOL)flag;",
-            format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
-                   "forAllCells:(BOOL)flag;"));
+               "- (void)sendAction:(SEL)aSelector to:(id)anObject "
+               "forAllCells:(BOOL)flag;");
 
   // Very long objectiveC method declaration.
   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
                "                    inRange:(NSRange)range\n"
                "                   outRange:(NSRange)out_range\n"
                "                  outRange1:(NSRange)out_range1\n"
TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
   // If there's no return type (very rare in practice!), LLVM and Google style
   // agree.
   verifyFormat("- foo;");
   verifyFormat("- foo:(int)f;");
   verifyGoogleFormat("- foo:(int)foo;");
 }
 
 TEST_F(FormatTest, BreaksStringLiterals) {
-  EXPECT_EQ("\"some text \"\n"
+  verifyFormat("\"some text \"\n"
                "\"other\";",
-            format("\"some text other\";", getLLVMStyleWithColumns(12)));
-  EXPECT_EQ("\"some text \"\n"
+               "\"some text other\";", getLLVMStyleWithColumns(12));
+  verifyFormat("\"some text \"\n"
                "\"other\";",
-            format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
-  EXPECT_EQ(
-      "#define A  \\\n"
+               "\\\n\"some text other\";", getLLVMStyleWithColumns(12));
+  verifyFormat("#define A  \\\n"
                "  \"some \"  \\\n"
                "  \"text \"  \\\n"
                "  \"other\";",
-      format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
-  EXPECT_EQ(
-      "#define A  \\\n"
+               "#define A \"some text other\";", getLLVMStyleWithColumns(12));
+  verifyFormat("#define A  \\\n"
                "  \"so \"    \\\n"
                "  \"text \"  \\\n"
                "  \"other\";",
-      format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
+               "#define A \"so text other\";", getLLVMStyleWithColumns(12));
 
-  EXPECT_EQ("\"some text\"",
-            format("\"some text\"", getLLVMStyleWithColumns(1)));
-  EXPECT_EQ("\"some text\"",
-            format("\"some text\"", getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("\"some \"\n"
+  verifyFormat("\"some text\"", "\"some text\"", getLLVMStyleWithColumns(1));
+  verifyFormat("\"some text\"", "\"some text\"", getLLVMStyleWithColumns(11));
+  verifyFormat("\"some \"\n"
                "\"text\"",
-            format("\"some text\"", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("\"some \"\n"
+               "\"some text\"", getLLVMStyleWithColumns(10));
+  verifyFormat("\"some \"\n"
                "\"text\"",
-            format("\"some text\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"some\"\n"
+               "\"some text\"", getLLVMStyleWithColumns(7));
+  verifyFormat("\"some\"\n"
                "\" tex\"\n"
                "\"t\"",
-            format("\"some text\"", getLLVMStyleWithColumns(6)));
-  EXPECT_EQ("\"some\"\n"
+               "\"some text\"", getLLVMStyleWithColumns(6));
+  verifyFormat("\"some\"\n"
                "\" tex\"\n"
                "\" and\"",
-            format("\"some tex and\"", getLLVMStyleWithColumns(6)));
-  EXPECT_EQ("\"some\"\n"
+               "\"some tex and\"", getLLVMStyleWithColumns(6));
+  verifyFormat("\"some\"\n"
                "\"/tex\"\n"
                "\"/and\"",
-            format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
+               "\"some/tex/and\"", getLLVMStyleWithColumns(6));
 
-  EXPECT_EQ("variable =\n"
+  verifyFormat("variable =\n"
                "    \"long string \"\n"
                "    \"literal\";",
-            format("variable = \"long string literal\";",
-                   getLLVMStyleWithColumns(20)));
+               "variable = \"long string literal\";",
+               getLLVMStyleWithColumns(20));
 
-  EXPECT_EQ("variable = f(\n"
+  verifyFormat("variable = f(\n"
                "    \"long string \"\n"
                "    \"literal\",\n"
                "    short,\n"
                "    loooooooooooooooooooong);",
-            format("variable = f(\"long string literal\", short, "
-                   "loooooooooooooooooooong);",
-                   getLLVMStyleWithColumns(20)));
+               "variable = f(\"long string literal\", short, "
+               getLLVMStyleWithColumns(20));
 
-  EXPECT_EQ(
-      "f(g(\"long string \"\n"
+  verifyFormat("f(g(\"long string \"\n"
                "    \"literal\"),\n"
                "  b);",
-      format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
-  EXPECT_EQ("f(g(\"long string \"\n"
+               "f(g(\"long string literal\"), b);",
+               getLLVMStyleWithColumns(20));
+  verifyFormat("f(g(\"long string \"\n"
                "    \"literal\",\n"
                "    a),\n"
                "  b);",
-            format("f(g(\"long string literal\", a), b);",
-                   getLLVMStyleWithColumns(20)));
-  EXPECT_EQ(
-      "f(\"one two\".split(\n"
+               "f(g(\"long string literal\", a), b);",
+               getLLVMStyleWithColumns(20));
+  verifyFormat("f(\"one two\".split(\n"
                "    variable));",
-      format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
-  EXPECT_EQ("f(\"one two three four five six \"\n"
+               "f(\"one two\".split(variable));", getLLVMStyleWithColumns(20));
+  verifyFormat("f(\"one two three four five six \"\n"
                "  \"seven\".split(\n"
                "      really_looooong_variable));",
-            format("f(\"one two three four five six seven\"."
-                   "split(really_looooong_variable));",
-                   getLLVMStyleWithColumns(33)));
+               "f(\"one two three four five six seven\"."
+               getLLVMStyleWithColumns(33));
 
-  EXPECT_EQ("f(\"some \"\n"
+  verifyFormat("f(\"some \"\n"
                "  \"text\",\n"
                "  other);",
-            format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
+               "f(\"some text\", other);", getLLVMStyleWithColumns(10));
 
   // Only break as a last resort.
   verifyFormat(
       "aaaaaaaaaaaaaaaaaaaa(\n"
       "    aaaaaaaaaaaaaaaaaaaa,\n"
       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
 
-  EXPECT_EQ("\"splitmea\"\n"
+  verifyFormat("\"splitmea\"\n"
                "\"trandomp\"\n"
                "\"oint\"",
-            format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
+               "\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10));
 
-  EXPECT_EQ("\"split/\"\n"
+  verifyFormat("\"split/\"\n"
                "\"pathat/\"\n"
                "\"slashes\"",
-            format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
+               "\"split/pathat/slashes\"", getLLVMStyleWithColumns(10));
 
-  EXPECT_EQ("\"split/\"\n"
+  verifyFormat("\"split/\"\n"
                "\"pathat/\"\n"
                "\"slashes\"",
-            format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("\"split at \"\n"
+               "\"split/pathat/slashes\"", getLLVMStyleWithColumns(10));
+  verifyFormat("\"split at \"\n"
                "\"spaces/at/\"\n"
                "\"slashes.at.any$\"\n"
                "\"non-alphanumeric%\"\n"
                "\"1111111111characte\"\n"
                "\"rs\"",
-            format("\"split at "
-                   "spaces/at/"
-                   "slashes.at."
-                   "any$non-"
-                   "alphanumeric%"
-                   "1111111111characte"
-                   "rs\"",
-                   getLLVMStyleWithColumns(20)));
+               "\"split at "
+               getLLVMStyleWithColumns(20));
 
   // Verify that splitting the strings understands
   // Style::AlwaysBreakBeforeMultilineStrings.
-  EXPECT_EQ("aaaaaaaaaaaa(\n"
+  verifyFormat("aaaaaaaaaaaa(\n"
                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
-            format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
-                   "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
-                   "aaaaaaaaaaaaaaaaaaaaaa\");",
-                   getGoogleStyle()));
-  EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
+               "aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
+               getGoogleStyle());
+  verifyFormat("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
                "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
-            format("return \"aaaaaaaaaaaaaaaaaaaaaa "
-                   "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
-                   "aaaaaaaaaaaaaaaaaaaaaa\";",
-                   getGoogleStyle()));
-  EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
+               "return \"aaaaaaaaaaaaaaaaaaaaaa "
+               getGoogleStyle());
+  verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
                "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
-            format("llvm::outs() << "
-                   "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
-                   "aaaaaaaaaaaaaaaaaaa\";"));
-  EXPECT_EQ("ffff(\n"
+               "llvm::outs() << "
+               "aaaaaaaaaaaaaaaaaaa\";");
+  verifyFormat("ffff(\n"
                "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
                "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
-            format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
-                   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
-                   getGoogleStyle()));
+               "ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
+               getGoogleStyle());
 
   FormatStyle Style = getLLVMStyleWithColumns(12);
   Style.BreakStringLiterals = false;
-  EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
+  verifyFormat("\"some text other\";", "\"some text other\";", Style);
 
   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
-  EXPECT_EQ("#define A \\\n"
+  verifyFormat("#define A \\\n"
                "  \"some \" \\\n"
                "  \"text \" \\\n"
                "  \"other\";",
-            format("#define A \"some text other\";", AlignLeft));
+               "#define A \"some text other\";", AlignLeft);
 }
 
 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
-  EXPECT_EQ("C a = \"some more \"\n"
+  verifyFormat("C a = \"some more \"\n"
                "      \"text\";",
-            format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
+               "C a = \"some more text\";", getLLVMStyleWithColumns(18));
 }
 
 TEST_F(FormatTest, FullyRemoveEmptyLines) {
   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
   NoEmptyLines.MaxEmptyLinesToKeep = 0;
-  EXPECT_EQ("int i = a(b());",
-            format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
+  verifyFormat("int i = a(b());", "int i=a(\n\n b(\n\n\n )\n\n);",
+               NoEmptyLines);
 }
 
 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
-  EXPECT_EQ(
+  verifyFormat(
       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
       "(\n"
       "    \"x\t\");",
-      format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-             "aaaaaaa("
-             "\"x\t\");"));
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+      "\"x\t\");");
 }
 
 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
-  EXPECT_EQ(
-      "u8\"utf8 string \"\n"
+  verifyFormat("u8\"utf8 string \"\n"
                "u8\"literal\";",
-      format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
-  EXPECT_EQ(
-      "u\"utf16 string \"\n"
+               "u8\"utf8 string literal\";", getGoogleStyleWithColumns(16));
+  verifyFormat("u\"utf16 string \"\n"
                "u\"literal\";",
-      format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
-  EXPECT_EQ(
-      "U\"utf32 string \"\n"
+               "u\"utf16 string literal\";", getGoogleStyleWithColumns(16));
+  verifyFormat("U\"utf32 string \"\n"
                "U\"literal\";",
-      format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
-  EXPECT_EQ("L\"wide string \"\n"
+               "U\"utf32 string literal\";", getGoogleStyleWithColumns(16));
+  verifyFormat("L\"wide string \"\n"
                "L\"literal\";",
-            format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
-  EXPECT_EQ("@\"NSString \"\n"
+               "L\"wide string literal\";", getGoogleStyleWithColumns(16));
+  verifyFormat("@\"NSString \"\n"
                "@\"literal\";",
-            format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
+               "@\"NSString literal\";", getGoogleStyleWithColumns(19));
   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
 
   // This input makes clang-format try to split the incomplete unicode escape
   // sequence, which used to lead to a crasher.
   verifyNoCrash(
       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       getLLVMStyleWithColumns(60));
 }
 
 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
   FormatStyle Style = getGoogleStyleWithColumns(15);
-  EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
-  EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
-  EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
-  EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
-  EXPECT_EQ("u8R\"x(raw literal)x\";",
-            format("u8R\"x(raw literal)x\";", Style));
+  verifyFormat("R\"x(raw literal)x\";", "R\"x(raw literal)x\";", Style);
+  verifyFormat("uR\"x(raw literal)x\";", "uR\"x(raw literal)x\";", Style);
+  verifyFormat("LR\"x(raw literal)x\";", "LR\"x(raw literal)x\";", Style);
+  verifyFormat("UR\"x(raw literal)x\";", "UR\"x(raw literal)x\";", Style);
+  verifyFormat("u8R\"x(raw literal)x\";", "u8R\"x(raw literal)x\";", Style);
 }
 
 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
   FormatStyle Style = getLLVMStyleWithColumns(20);
-  EXPECT_EQ(
-      "_T(\"aaaaaaaaaaaaaa\")\n"
+  verifyFormat("_T(\"aaaaaaaaaaaaaa\")\n"
                "_T(\"aaaaaaaaaaaaaa\")\n"
                "_T(\"aaaaaaaaaaaa\")",
-      format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
-  EXPECT_EQ("f(x,\n"
+               "  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style);
+  verifyFormat("f(x,\n"
                "  _T(\"aaaaaaaaaaaa\")\n"
                "  _T(\"aaa\"),\n"
                "  z);",
-            format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
+               "f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style);
 
   // FIXME: Handle embedded spaces in one iteration.
-  //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
+  //  verifyFormat("_T(\"aaaaaaaaaaaaa\")\n"
   //            "_T(\"aaaaaaaaaaaaa\")\n"
   //            "_T(\"aaaaaaaaaaaaa\")\n"
   //            "_T(\"a\")",
-  //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
-  //                   getLLVMStyleWithColumns(20)));
-  EXPECT_EQ(
-      "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
-      format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
-  EXPECT_EQ("f(\n"
+  //            "  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
+  //                   getLLVMStyleWithColumns(20));
+  verifyFormat("_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
+               "  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style);
+  verifyFormat("f(\n"
                "#if !TEST\n"
                "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
                "#endif\n"
                ");",
-            format("f(\n"
-                   "#if !TEST\n"
-                   "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
-                   "#endif\n"
-                   ");"));
-  EXPECT_EQ("f(\n"
+               "f(\n"
+               ");");
+  verifyFormat("f(\n"
                "\n"
                "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
-            format("f(\n"
-                   "\n"
-                   "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
+               "f(\n"
+               "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));");
 }
 
 TEST_F(FormatTest, BreaksStringLiteralOperands) {
   // In a function call with two operands, the second can be broken with no line
   // break before it.
-  EXPECT_EQ(
-      "func(a, \"long long \"\n"
+  verifyFormat("func(a, \"long long \"\n"
                "        \"long long\");",
-      format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
+               "func(a, \"long long long long\");",
+               getLLVMStyleWithColumns(24));
   // In a function call with three operands, the second must be broken with a
   // line break before it.
-  EXPECT_EQ("func(a,\n"
+  verifyFormat("func(a,\n"
                "     \"long long long \"\n"
                "     \"long\",\n"
                "     c);",
-            format("func(a, \"long long long long\", c);",
-                   getLLVMStyleWithColumns(24)));
+               "func(a, \"long long long long\", c);",
+               getLLVMStyleWithColumns(24));
   // In a function call with three operands, the third must be broken with a
   // line break before it.
-  EXPECT_EQ("func(a, b,\n"
+  verifyFormat("func(a, b,\n"
                "     \"long long long \"\n"
                "     \"long\");",
-            format("func(a, b, \"long long long long\");",
-                   getLLVMStyleWithColumns(24)));
+               "func(a, b, \"long long long long\");",
+               getLLVMStyleWithColumns(24));
   // In a function call with three operands, both the second and the third must
   // be broken with a line break before them.
-  EXPECT_EQ("func(a,\n"
+  verifyFormat("func(a,\n"
                "     \"long long long \"\n"
                "     \"long\",\n"
                "     \"long long long \"\n"
                "     \"long\");",
-            format("func(a, \"long long long long\", \"long long long long\");",
-                   getLLVMStyleWithColumns(24)));
+               "func(a, \"long long long long\", \"long long long long\");",
+               getLLVMStyleWithColumns(24));
   // In a chain of << with two operands, the second can be broken with no line
   // break before it.
-  EXPECT_EQ("a << \"line line \"\n"
+  verifyFormat("a << \"line line \"\n"
                "     \"line\";",
-            format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
+               "a << \"line line line\";", getLLVMStyleWithColumns(20));
   // In a chain of << with three operands, the second can be broken with no line
   // break before it.
-  EXPECT_EQ(
-      "abcde << \"line \"\n"
+  verifyFormat("abcde << \"line \"\n"
                "         \"line line\"\n"
                "      << c;",
-      format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
+               "abcde << \"line line line\" << c;",
+               getLLVMStyleWithColumns(20));
   // In a chain of << with three operands, the third must be broken with a line
   // break before it.
-  EXPECT_EQ(
-      "a << b\n"
+  verifyFormat("a << b\n"
                "  << \"line line \"\n"
                "     \"line\";",
-      format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
+               "a << b << \"line line line\";", getLLVMStyleWithColumns(20));
   // In a chain of << with three operands, the second can be broken with no line
   // break before it and the third must be broken with a line break before it.
-  EXPECT_EQ("abcd << \"line line \"\n"
+  verifyFormat("abcd << \"line line \"\n"
                "        \"line\"\n"
                "     << \"line line \"\n"
                "        \"line\";",
-            format("abcd << \"line line line\" << \"line line line\";",
-                   getLLVMStyleWithColumns(20)));
+               "abcd << \"line line line\" << \"line line line\";",
+               getLLVMStyleWithColumns(20));
   // In a chain of binary operators with two operands, the second can be broken
   // with no line break before it.
-  EXPECT_EQ(
-      "abcd + \"line line \"\n"
+  verifyFormat("abcd + \"line line \"\n"
                "       \"line line\";",
-      format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
+               "abcd + \"line line line line\";", getLLVMStyleWithColumns(20));
   // In a chain of binary operators with three operands, the second must be
   // broken with a line break before it.
-  EXPECT_EQ("abcd +\n"
+  verifyFormat("abcd +\n"
                "    \"line line \"\n"
                "    \"line line\" +\n"
                "    e;",
-            format("abcd + \"line line line line\" + e;",
-                   getLLVMStyleWithColumns(20)));
+               "abcd + \"line line line line\" + e;",
+               getLLVMStyleWithColumns(20));
   // In a function call with two operands, with AlignAfterOpenBracket enabled,
   // the first must be broken with a line break before it.
   FormatStyle Style = getLLVMStyleWithColumns(25);
   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
-  EXPECT_EQ("someFunction(\n"
+  verifyFormat("someFunction(\n"
                "    \"long long long \"\n"
                "    \"long\",\n"
                "    a);",
-            format("someFunction(\"long long long long\", a);", Style));
+               "someFunction(\"long long long long\", a);", Style);
 }
 
 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
-  EXPECT_EQ(
-      "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
+  verifyFormat("aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
-      format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
+               "aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
-             "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
+               "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";");
 }
 
 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
-  EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
-            format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
-  EXPECT_EQ("fffffffffff(g(R\"x(\n"
+  verifyFormat("f(g(R\"x(raw literal)x\", a), b);",
+               "f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle());
+  verifyFormat("fffffffffff(g(R\"x(\n"
                "multiline raw string literal xxxxxxxxxxxxxx\n"
                ")x\",\n"
                "              a),\n"
                "            b);",
-            format("fffffffffff(g(R\"x(\n"
-                   "multiline raw string literal xxxxxxxxxxxxxx\n"
-                   ")x\", a), b);",
-                   getGoogleStyleWithColumns(20)));
-  EXPECT_EQ("fffffffffff(\n"
+               "fffffffffff(g(R\"x(\n"
+               getGoogleStyleWithColumns(20));
+  verifyFormat("fffffffffff(\n"
                "    g(R\"x(qqq\n"
                "multiline raw string literal xxxxxxxxxxxxxx\n"
                ")x\",\n"
                "      a),\n"
                "    b);",
-            format("fffffffffff(g(R\"x(qqq\n"
-                   "multiline raw string literal xxxxxxxxxxxxxx\n"
-                   ")x\", a), b);",
-                   getGoogleStyleWithColumns(20)));
+               "fffffffffff(g(R\"x(qqq\n"
+               getGoogleStyleWithColumns(20));
 
-  EXPECT_EQ("fffffffffff(R\"x(\n"
+  verifyFormat("fffffffffff(R\"x(\n"
                "multiline raw string literal xxxxxxxxxxxxxx\n"
                ")x\");",
-            format("fffffffffff(R\"x(\n"
-                   "multiline raw string literal xxxxxxxxxxxxxx\n"
-                   ")x\");",
-                   getGoogleStyleWithColumns(20)));
-  EXPECT_EQ("fffffffffff(R\"x(\n"
+               "fffffffffff(R\"x(\n"
+               getGoogleStyleWithColumns(20));
+  verifyFormat("fffffffffff(R\"x(\n"
                "multiline raw string literal xxxxxxxxxxxxxx\n"
                ")x\" + bbbbbb);",
-            format("fffffffffff(R\"x(\n"
-                   "multiline raw string literal xxxxxxxxxxxxxx\n"
-                   ")x\" +   bbbbbb);",
-                   getGoogleStyleWithColumns(20)));
-  EXPECT_EQ("fffffffffff(\n"
+               "fffffffffff(R\"x(\n"
+               getGoogleStyleWithColumns(20));
+  verifyFormat("fffffffffff(\n"
                "    R\"x(\n"
                "multiline raw string literal xxxxxxxxxxxxxx\n"
                ")x\" +\n"
                "    bbbbbb);",
-            format("fffffffffff(\n"
-                   " R\"x(\n"
-                   "multiline raw string literal xxxxxxxxxxxxxx\n"
-                   ")x\" + bbbbbb);",
-                   getGoogleStyleWithColumns(20)));
-  EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
-            format("fffffffffff(\n"
-                   " R\"(single line raw string)\" + bbbbbb);"));
+               "fffffffffff(\n"
+               getGoogleStyleWithColumns(20));
+  verifyFormat("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
+               "fffffffffff(\n"
+               " R\"(single line raw string)\" + bbbbbb);");
 }
 
 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
   verifyFormat("string a = \"unterminated;");
-  EXPECT_EQ("function(\"unterminated,\n"
+  verifyFormat("function(\"unterminated,\n"
                "         OtherParameter);",
-            format("function(  \"unterminated,\n"
-                   "    OtherParameter);"));
+               "function(  \"unterminated,\n"
+               "    OtherParameter);");
 }
 
 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
   FormatStyle Style = getLLVMStyle();
   Style.Standard = FormatStyle::LS_Cpp03;
-  EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
-            format("#define x(_a) printf(\"foo\"_a);", Style));
+  verifyFormat("#define x(_a) printf(\"foo\" _a);",
+               "#define x(_a) printf(\"foo\"_a);", Style);
 }
 
 TEST_F(FormatTest, CppLexVersion) {
   FormatStyle Style = getLLVMStyle();
   // Formatting of x * y differs if x is a type.
   verifyFormat("void foo() { MACRO(a * b); }", Style);
   verifyFormat("void foo() { MACRO(int *b); }", Style);
 
   // LLVM style uses latest lexer.
   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
   Style.Standard = FormatStyle::LS_Cpp17;
   // But in c++17, char8_t isn't a keyword.
   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
 }
 
 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
 
 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
-  EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
+  verifyFormat("someFunction(\"aaabbbcccd\"\n"
                "             \"ddeeefff\");",
-            format("someFunction(\"aaabbbcccdddeeefff\");",
-                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("someFunction1234567890(\n"
+               "someFunction(\"aaabbbcccdddeeefff\");",
+               getLLVMStyleWithColumns(25));
+  verifyFormat("someFunction1234567890(\n"
                "    \"aaabbbcccdddeeefff\");",
-            format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
-                   getLLVMStyleWithColumns(26)));
-  EXPECT_EQ("someFunction1234567890(\n"
+               "someFunction1234567890(\"aaabbbcccdddeeefff\");",
+               getLLVMStyleWithColumns(26));
+  verifyFormat("someFunction1234567890(\n"
                "    \"aaabbbcccdddeeeff\"\n"
                "    \"f\");",
-            format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
-                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("someFunction1234567890(\n"
+               "someFunction1234567890(\"aaabbbcccdddeeefff\");",
+               getLLVMStyleWithColumns(25));
+  verifyFormat("someFunction1234567890(\n"
                "    \"aaabbbcccdddeeeff\"\n"
                "    \"f\");",
-            format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
-                   getLLVMStyleWithColumns(24)));
-  EXPECT_EQ("someFunction(\n"
+               "someFunction1234567890(\"aaabbbcccdddeeefff\");",
+               getLLVMStyleWithColumns(24));
+  verifyFormat("someFunction(\n"
                "    \"aaabbbcc ddde \"\n"
                "    \"efff\");",
-            format("someFunction(\"aaabbbcc ddde efff\");",
-                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
+               "someFunction(\"aaabbbcc ddde efff\");",
+               getLLVMStyleWithColumns(25));
+  verifyFormat("someFunction(\"aaabbbccc \"\n"
                "             \"ddeeefff\");",
-            format("someFunction(\"aaabbbccc ddeeefff\");",
-                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("someFunction1234567890(\n"
+               "someFunction(\"aaabbbccc ddeeefff\");",
+               getLLVMStyleWithColumns(25));
+  verifyFormat("someFunction1234567890(\n"
                "    \"aaabb \"\n"
                "    \"cccdddeeefff\");",
-            format("someFunction1234567890(\"aaabb cccdddeeefff\");",
-                   getLLVMStyleWithColumns(25)));
-  EXPECT_EQ("#define A          \\\n"
+               "someFunction1234567890(\"aaabb cccdddeeefff\");",
+               getLLVMStyleWithColumns(25));
+  verifyFormat("#define A          \\\n"
                "  string s =       \\\n"
                "      \"123456789\"  \\\n"
                "      \"0\";         \\\n"
                "  int i;",
-            format("#define A string s = \"1234567890\"; int i;",
-                   getLLVMStyleWithColumns(20)));
-  EXPECT_EQ("someFunction(\n"
+               "#define A string s = \"1234567890\"; int i;",
+               getLLVMStyleWithColumns(20));
+  verifyFormat("someFunction(\n"
                "    \"aaabbbcc \"\n"
                "    \"dddeeefff\");",
-            format("someFunction(\"aaabbbcc dddeeefff\");",
-                   getLLVMStyleWithColumns(25)));
+               "someFunction(\"aaabbbcc dddeeefff\");",
+               getLLVMStyleWithColumns(25));
 }
 
 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
-  EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
-  EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
-  EXPECT_EQ("\"test\"\n"
+  verifyFormat("\"\\a\"", "\"\\a\"", getLLVMStyleWithColumns(3));
+  verifyFormat("\"\\\"", "\"\\\"", getLLVMStyleWithColumns(2));
+  verifyFormat("\"test\"\n"
                "\"\\n\"",
-            format("\"test\\n\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"tes\\\\\"\n"
+               "\"test\\n\"", getLLVMStyleWithColumns(7));
+  verifyFormat("\"tes\\\\\"\n"
                "\"n\"",
-            format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"\\\\\\\\\"\n"
+               "\"tes\\\\n\"", getLLVMStyleWithColumns(7));
+  verifyFormat("\"\\\\\\\\\"\n"
                "\"\\n\"",
-            format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"\\uff01\"\n"
+               "\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7));
+  verifyFormat("\"\\uff01\"", "\"\\uff01\"", getLLVMStyleWithColumns(7));
+  verifyFormat("\"\\uff01\"\n"
                "\"test\"",
-            format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
-  EXPECT_EQ("\"\\Uff01ff02\"",
-            format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("\"\\x000000000001\"\n"
+               "\"\\uff01test\"", getLLVMStyleWithColumns(8));
+  verifyFormat("\"\\Uff01ff02\"", "\"\\Uff01ff02\"",
+               getLLVMStyleWithColumns(11));
+  verifyFormat("\"\\x000000000001\"\n"
                "\"next\"",
-            format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
-  EXPECT_EQ("\"\\x000000000001next\"",
-            format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
-  EXPECT_EQ("\"\\x000000000001\"",
-            format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"test\"\n"
+               "\"\\x000000000001next\"", getLLVMStyleWithColumns(16));
+  verifyFormat("\"\\x000000000001next\"", "\"\\x000000000001next\"",
+               getLLVMStyleWithColumns(15));
+  verifyFormat("\"\\x000000000001\"", "\"\\x000000000001\"",
+               getLLVMStyleWithColumns(7));
+  verifyFormat("\"test\"\n"
                "\"\\000000\"\n"
                "\"000001\"",
-            format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
-  EXPECT_EQ("\"test\\000\"\n"
+               "\"test\\000000000001\"", getLLVMStyleWithColumns(9));
+  verifyFormat("\"test\\000\"\n"
                "\"00000000\"\n"
                "\"1\"",
-            format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
+               "\"test\\000000000001\"", getLLVMStyleWithColumns(10));
 }
 
 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
   verifyFormat("void f() {\n"
                "  return g() {}\n"
                "  void h() {}");
   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
                "g();\n"

 }
 
 TEST_F(FormatTest, ConfigurableUseOfTab) {
   FormatStyle Tab = getLLVMStyleWithColumns(42);
   Tab.IndentWidth = 8;
   Tab.UseTab = FormatStyle::UT_Always;
   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
 
-  EXPECT_EQ("if (aaaaaaaa && // q\n"
+  verifyFormat("if (aaaaaaaa && // q\n"
                "    bb)\t\t// w\n"
                "\t;",
-            format("if (aaaaaaaa &&// q\n"
-                   "bb)// w\n"
-                   ";",
-                   Tab));
-  EXPECT_EQ("if (aaa && bbb) // w\n"
+               "if (aaaaaaaa &&// q\n"
+               Tab);
+  verifyFormat("if (aaa && bbb) // w\n"
                "\t;",
-            format("if(aaa&&bbb)// w\n"
-                   ";",
-                   Tab));
+               "if(aaa&&bbb)// w\n"
+               Tab);
 
   verifyFormat("class X {\n"
                "\tvoid f() {\n"
                "\t\tsomeFunction(parameter1,\n"
                "\t\t\t     parameter2);\n"
                "\t}\n"
                "};",
                Tab);
verifyFormat("class TabWidth8Indent4 {\n"
                "\tsomeFunction(parameter1,\n"
                "\t\t     parameter2);\n"
                "    }\n"
                "};",
                Tab);
 
   Tab.TabWidth = 8;
   Tab.IndentWidth = 8;
-  EXPECT_EQ("/*\n"
+  verifyFormat("/*\n"
                "\t      a\t\tcomment\n"
                "\t      in multiple lines\n"
                "       */",
-            format("   /*\t \t \n"
-                   " \t \t a\t\tcomment\t \t\n"
-                   " \t \t in multiple lines\t\n"
-                   " \t  */",
-                   Tab));
+               "   /*\t \t \n"
+               Tab);
 
   Tab.UseTab = FormatStyle::UT_ForIndentation;
   verifyFormat("{\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "};",
                Tab);
   verifyFormat("enum AA {\n"
                "\ta1, // Force multiple lines\n"
                "\ta2,\n"
                "\ta3\n"
                "};",
                Tab);
-  EXPECT_EQ("if (aaaaaaaa && // q\n"
+  verifyFormat("if (aaaaaaaa && // q\n"
                "    bb)         // w\n"
                "\t;",
-            format("if (aaaaaaaa &&// q\n"
-                   "bb)// w\n"
-                   ";",
-                   Tab));
+               "if (aaaaaaaa &&// q\n"
+               Tab);
   verifyFormat("class X {\n"
                "\tvoid f() {\n"
                "\t\tsomeFunction(parameter1,\n"
                "\t\t             parameter2);\n"
                "\t}\n"
                "};",
                Tab);
   verifyFormat("{\n"
                "\tQ(\n"
                "\t    {\n"
                "\t\t    int a;\n"
                "\t\t    someFunction(aaaaaaaa,\n"
                "\t\t                 bbbbbbb);\n"
                "\t    },\n"
                "\t    p);\n"
                "}",
                Tab);
-  EXPECT_EQ("{\n"
+  verifyFormat("{\n"
                "\t/* aaaa\n"
                "\t   bbbb */\n"
                "}",
-            format("{\n"
-                   "/* aaaa\n"
-                   "   bbbb */\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t  bbbbbbbbbbbbb\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "/*\n"
-                   "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t// bbbbbbbbbbbbb\n"
                "}",
-            format("{\n"
-                   "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t  bbbbbbbbbbbbb\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                " asdf\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   " asdf\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
+               "{\n"
+               Tab);
 
   Tab.UseTab = FormatStyle::UT_Never;
-  EXPECT_EQ("/*\n"
+  verifyFormat("/*\n"
                "              a\t\tcomment\n"
                "              in multiple lines\n"
                "       */",
-            format("   /*\t \t \n"
-                   " \t \t a\t\tcomment\t \t\n"
-                   " \t \t in multiple lines\t\n"
-                   " \t  */",
-                   Tab));
-  EXPECT_EQ("/* some\n"
+               "   /*\t \t \n"
+               Tab);
+  verifyFormat("/* some\n"
                "   comment */",
-            format(" \t \t /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("int a; /* some\n"
+               " \t \t /* some\n"
+               Tab);
+  verifyFormat("int a; /* some\n"
                "   comment */",
-            format(" \t \t int a; /* some\n"
-                   " \t \t    comment */",
-                   Tab));
+               " \t \t int a; /* some\n"
+               Tab);
 
-  EXPECT_EQ("int a; /* some\n"
+  verifyFormat("int a; /* some\n"
                "comment */",
-            format(" \t \t int\ta; /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("f(\"\t\t\"); /* some\n"
+               " \t \t int\ta; /* some\n"
+               Tab);
+  verifyFormat("f(\"\t\t\"); /* some\n"
                "    comment */",
-            format(" \t \t f(\"\t\t\"); /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("{\n"
+               " \t \t f(\"\t\t\"); /* some\n"
+               Tab);
+  verifyFormat("{\n"
                "        /*\n"
                "         * Comment\n"
                "         */\n"
                "        int i;\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\t * Comment\n"
-                   "\t */\n"
-                   "\t int i;\n"
-                   "}",
-                   Tab));
+               "{\n"
+               Tab);
 
   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
   Tab.TabWidth = 8;
   Tab.IndentWidth = 8;
-  EXPECT_EQ("if (aaaaaaaa && // q\n"
+  verifyFormat("if (aaaaaaaa && // q\n"
                "    bb)         // w\n"
                "\t;",
-            format("if (aaaaaaaa &&// q\n"
-                   "bb)// w\n"
-                   ";",
-                   Tab));
-  EXPECT_EQ("if (aaa && bbb) // w\n"
+               "if (aaaaaaaa &&// q\n"
+               Tab);
+  verifyFormat("if (aaa && bbb) // w\n"
                "\t;",
-            format("if(aaa&&bbb)// w\n"
-                   ";",
-                   Tab));
+               "if(aaa&&bbb)// w\n"
+               Tab);
   verifyFormat("class X {\n"
                "\tvoid f() {\n"
                "\t\tsomeFunction(parameter1,\n"
                "\t\t\t     parameter2);\n"
                "\t}\n"
                "};",
                Tab);
   verifyFormat("#define A                        \\\n"
verifyFormat("class TabWidth8Indent4 {\n"
                "    void f() {\n"
                "\tsomeFunction(parameter1,\n"
                "\t\t     parameter2);\n"
                "    }\n"
                "};",
                Tab);
   Tab.TabWidth = 8;
   Tab.IndentWidth = 8;
-  EXPECT_EQ("/*\n"
+  verifyFormat("/*\n"
                "\t      a\t\tcomment\n"
                "\t      in multiple lines\n"
                "       */",
-            format("   /*\t \t \n"
-                   " \t \t a\t\tcomment\t \t\n"
-                   " \t \t in multiple lines\t\n"
-                   " \t  */",
-                   Tab));
+               "   /*\t \t \n"
+               Tab);
   verifyFormat("{\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "};",
                Tab);
   verifyFormat("enum AA {\n"
                "\ta1, // Force multiple lines\n"
                "\ta2,\n"
                "\ta3\n"
                "};",
                Tab);
-  EXPECT_EQ("if (aaaaaaaa && // q\n"
+  verifyFormat("if (aaaaaaaa && // q\n"
                "    bb)         // w\n"
                "\t;",
-            format("if (aaaaaaaa &&// q\n"
-                   "bb)// w\n"
-                   ";",
-                   Tab));
+               "if (aaaaaaaa &&// q\n"
+               Tab);
   verifyFormat("class X {\n"
                "\tvoid f() {\n"
                "\t\tsomeFunction(parameter1,\n"
                "\t\t\t     parameter2);\n"
                "\t}\n"
                "};",
                Tab);
   verifyFormat("{\n"
                "\tQ(\n"
                "\t    {\n"
                "\t\t    int a;\n"
                "\t\t    someFunction(aaaaaaaa,\n"
                "\t\t\t\t bbbbbbb);\n"
                "\t    },\n"
                "\t    p);\n"
                "}",
                Tab);
-  EXPECT_EQ("{\n"
+  verifyFormat("{\n"
                "\t/* aaaa\n"
                "\t   bbbb */\n"
                "}",
-            format("{\n"
-                   "/* aaaa\n"
-                   "   bbbb */\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t  bbbbbbbbbbbbb\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "/*\n"
-                   "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t// bbbbbbbbbbbbb\n"
                "}",
-            format("{\n"
-                   "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t  bbbbbbbbbbbbb\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                " asdf\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   " asdf\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("/* some\n"
+               "{\n"
+               Tab);
+  verifyFormat("/* some\n"
                "   comment */",
-            format(" \t \t /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("int a; /* some\n"
+               " \t \t /* some\n"
+               Tab);
+  verifyFormat("int a; /* some\n"
                "   comment */",
-            format(" \t \t int a; /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("int a; /* some\n"
+               " \t \t int a; /* some\n"
+               Tab);
+  verifyFormat("int a; /* some\n"
                "comment */",
-            format(" \t \t int\ta; /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("f(\"\t\t\"); /* some\n"
+               " \t \t int\ta; /* some\n"
+               Tab);
+  verifyFormat("f(\"\t\t\"); /* some\n"
                "    comment */",
-            format(" \t \t f(\"\t\t\"); /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("{\n"
+               " \t \t f(\"\t\t\"); /* some\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\t * Comment\n"
                "\t */\n"
                "\tint i;\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\t * Comment\n"
-                   "\t */\n"
-                   "\t int i;\n"
-                   "}",
-                   Tab));
+               "{\n"
+               Tab);
   Tab.TabWidth = 2;
   Tab.IndentWidth = 2;
-  EXPECT_EQ("{\n"
+  verifyFormat("{\n"
                "\t/* aaaa\n"
                "\t\t bbbb */\n"
                "}",
-            format("{\n"
-                   "/* aaaa\n"
-                   "\t bbbb */\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t\tbbbbbbbbbbbbb\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "/*\n"
-                   "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "*/\n"
-                   "}",
-                   Tab));
+               "{\n"
+               Tab);
   Tab.AlignConsecutiveAssignments = true;
   Tab.AlignConsecutiveDeclarations = true;
   Tab.TabWidth = 4;
   Tab.IndentWidth = 4;
   verifyFormat("class Assign {\n"
                "\tvoid f() {\n"
                "\t\tint         x      = 123;\n"
                "\t\tint         random = 4;\n"
                "\t\tstd::string alphabet =\n"
                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
                "\t}\n"
                "};",
                Tab);
 
   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
   Tab.TabWidth = 8;
   Tab.IndentWidth = 8;
-  EXPECT_EQ("if (aaaaaaaa && // q\n"
+  verifyFormat("if (aaaaaaaa && // q\n"
                "    bb)         // w\n"
                "\t;",
-            format("if (aaaaaaaa &&// q\n"
-                   "bb)// w\n"
-                   ";",
-                   Tab));
-  EXPECT_EQ("if (aaa && bbb) // w\n"
+               "if (aaaaaaaa &&// q\n"
+               Tab);
+  verifyFormat("if (aaa && bbb) // w\n"
                "\t;",
-            format("if(aaa&&bbb)// w\n"
-                   ";",
-                   Tab));
+               "if(aaa&&bbb)// w\n"
+               Tab);
   verifyFormat("class X {\n"
                "\tvoid f() {\n"
                "\t\tsomeFunction(parameter1,\n"
                "\t\t             parameter2);\n"
                "\t}\n"
                "};",
                Tab);
   verifyFormat("#define A                        \\\n"
verifyFormat("class TabWidth8Indent4 {\n"
                "    void f() {\n"
                "\tsomeFunction(parameter1,\n"
                "\t             parameter2);\n"
                "    }\n"
                "};",
                Tab);
   Tab.TabWidth = 8;
   Tab.IndentWidth = 8;
-  EXPECT_EQ("/*\n"
+  verifyFormat("/*\n"
                "              a\t\tcomment\n"
                "              in multiple lines\n"
                "       */",
-            format("   /*\t \t \n"
-                   " \t \t a\t\tcomment\t \t\n"
-                   " \t \t in multiple lines\t\n"
-                   " \t  */",
-                   Tab));
+               "   /*\t \t \n"
+               Tab);
   verifyFormat("{\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
                "};",
                Tab);
   verifyFormat("enum AA {\n"
                "\ta1, // Force multiple lines\n"
                "\ta2,\n"
                "\ta3\n"
                "};",
                Tab);
-  EXPECT_EQ("if (aaaaaaaa && // q\n"
+  verifyFormat("if (aaaaaaaa && // q\n"
                "    bb)         // w\n"
                "\t;",
-            format("if (aaaaaaaa &&// q\n"
-                   "bb)// w\n"
-                   ";",
-                   Tab));
+               "if (aaaaaaaa &&// q\n"
+               Tab);
   verifyFormat("class X {\n"
                "\tvoid f() {\n"
                "\t\tsomeFunction(parameter1,\n"
                "\t\t             parameter2);\n"
                "\t}\n"
                "};",
                Tab);
   verifyFormat("{\n"
                "\tQ(\n"
                "\t    {\n"
                "\t\t    int a;\n"
                "\t\t    someFunction(aaaaaaaa,\n"
                "\t\t                 bbbbbbb);\n"
                "\t    },\n"
                "\t    p);\n"
                "}",
                Tab);
-  EXPECT_EQ("{\n"
+  verifyFormat("{\n"
                "\t/* aaaa\n"
                "\t   bbbb */\n"
                "}",
-            format("{\n"
-                   "/* aaaa\n"
-                   "   bbbb */\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t  bbbbbbbbbbbbb\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "/*\n"
-                   "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t// bbbbbbbbbbbbb\n"
                "}",
-            format("{\n"
-                   "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t  bbbbbbbbbbbbb\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                " asdf\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   " asdf\n"
-                   "\t*/\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("/* some\n"
+               "{\n"
+               Tab);
+  verifyFormat("/* some\n"
                "   comment */",
-            format(" \t \t /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("int a; /* some\n"
+               " \t \t /* some\n"
+               Tab);
+  verifyFormat("int a; /* some\n"
                "   comment */",
-            format(" \t \t int a; /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("int a; /* some\n"
+               " \t \t int a; /* some\n"
+               Tab);
+  verifyFormat("int a; /* some\n"
                "comment */",
-            format(" \t \t int\ta; /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("f(\"\t\t\"); /* some\n"
+               " \t \t int\ta; /* some\n"
+               Tab);
+  verifyFormat("f(\"\t\t\"); /* some\n"
                "    comment */",
-            format(" \t \t f(\"\t\t\"); /* some\n"
-                   " \t \t    comment */",
-                   Tab));
-  EXPECT_EQ("{\n"
+               " \t \t f(\"\t\t\"); /* some\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\t * Comment\n"
                "\t */\n"
                "\tint i;\n"
                "}",
-            format("{\n"
-                   "\t/*\n"
-                   "\t * Comment\n"
-                   "\t */\n"
-                   "\t int i;\n"
-                   "}",
-                   Tab));
+               "{\n"
+               Tab);
   Tab.TabWidth = 2;
   Tab.IndentWidth = 2;
-  EXPECT_EQ("{\n"
+  verifyFormat("{\n"
                "\t/* aaaa\n"
                "\t   bbbb */\n"
                "}",
-            format("{\n"
-                   "/* aaaa\n"
-                   "   bbbb */\n"
-                   "}",
-                   Tab));
-  EXPECT_EQ("{\n"
+               "{\n"
+               Tab);
+  verifyFormat("{\n"
                "\t/*\n"
                "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
                "\t  bbbbbbbbbbbbb\n"
                "\t*/\n"
                "}",
-            format("{\n"
-                   "/*\n"
-                   "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
-                   "*/\n"
-                   "}",
-                   Tab));
+               "{\n"
+               Tab);
   Tab.AlignConsecutiveAssignments = true;
   Tab.AlignConsecutiveDeclarations = true;
   Tab.TabWidth = 4;
   Tab.IndentWidth = 4;
   verifyFormat("class Assign {\n"
                "\tvoid f() {\n"
                "\t\tint         x      = 123;\n"
                "\t\tint         random = 4;\n"
                "\t\tstd::string alphabet =\n"
                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
                "\t}\n"
                "};",
                Tab);
 }
 
 TEST_F(FormatTest, ZeroTabWidth) {
   FormatStyle Tab = getLLVMStyleWithColumns(42);
   Tab.IndentWidth = 8;
   Tab.UseTab = FormatStyle::UT_Never;
   Tab.TabWidth = 0;
-  EXPECT_EQ("void a(){\n"
+  verifyFormat("void a(){\n"
                "    // line starts with '\t'\n"
                "};",
-            format("void a(){\n"
-                   "\t// line starts with '\t'\n"
-                   "};",
-                   Tab));
+               "void a(){\n"
+               Tab);
 
-  EXPECT_EQ("void a(){\n"
+  verifyFormat("void a(){\n"
                "    // line starts with '\t'\n"
                "};",
-            format("void a(){\n"
-                   "\t\t// line starts with '\t'\n"
-                   "};",
-                   Tab));
+               "void a(){\n"
+               Tab);
 
   Tab.UseTab = FormatStyle::UT_ForIndentation;
-  EXPECT_EQ("void a(){\n"
+  verifyFormat("void a(){\n"
                "    // line starts with '\t'\n"
                "};",
-            format("void a(){\n"
-                   "\t// line starts with '\t'\n"
-                   "};",
-                   Tab));
+               "void a(){\n"
+               Tab);
 
-  EXPECT_EQ("void a(){\n"
+  verifyFormat("void a(){\n"
                "    // line starts with '\t'\n"
                "};",
-            format("void a(){\n"
-                   "\t\t// line starts with '\t'\n"
-                   "};",
-                   Tab));
+               "void a(){\n"
+               Tab);
 
   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
-  EXPECT_EQ("void a(){\n"
+  verifyFormat("void a(){\n"
                "    // line starts with '\t'\n"
                "};",
-            format("void a(){\n"
-                   "\t// line starts with '\t'\n"
-                   "};",
-                   Tab));
+               "void a(){\n"
+               Tab);
 
-  EXPECT_EQ("void a(){\n"
+  verifyFormat("void a(){\n"
                "    // line starts with '\t'\n"
                "};",
-            format("void a(){\n"
-                   "\t\t// line starts with '\t'\n"
-                   "};",
-                   Tab));
+               "void a(){\n"
+               Tab);
 
   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
-  EXPECT_EQ("void a(){\n"
+  verifyFormat("void a(){\n"
                "    // line starts with '\t'\n"
                "};",
-            format("void a(){\n"
-                   "\t// line starts with '\t'\n"
-                   "};",
-                   Tab));
+               "void a(){\n"
+               Tab);
 
-  EXPECT_EQ("void a(){\n"
+  verifyFormat("void a(){\n"
                "    // line starts with '\t'\n"
                "};",
-            format("void a(){\n"
-                   "\t\t// line starts with '\t'\n"
-                   "};",
-                   Tab));
+               "void a(){\n"
+               Tab);
 
   Tab.UseTab = FormatStyle::UT_Always;
-  EXPECT_EQ("void a(){\n"
+  verifyFormat("void a(){\n"
                "// line starts with '\t'\n"
                "};",
-            format("void a(){\n"
-                   "\t// line starts with '\t'\n"
-                   "};",
-                   Tab));
+               "void a(){\n"
+               Tab);
 
-  EXPECT_EQ("void a(){\n"
+  verifyFormat("void a(){\n"
                "// line starts with '\t'\n"
                "};",
-            format("void a(){\n"
-                   "\t\t// line starts with '\t'\n"
-                   "};",
-                   Tab));
+               "void a(){\n"
+               Tab);
 }
 
 TEST_F(FormatTest, CalculatesOriginalColumn) {
-  EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+  verifyFormat("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
                "q\"; /* some\n"
                "       comment */",
-            format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
-                   "q\"; /* some\n"
-                   "       comment */",
-                   getLLVMStyle()));
-  EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
+               "  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+               getLLVMStyle());
+  verifyFormat("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
                "/* some\n"
                "   comment */",
-            format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
-                   " /* some\n"
-                   "    comment */",
-                   getLLVMStyle()));
-  EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+               "// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
+               getLLVMStyle());
+  verifyFormat("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
                "qqq\n"
                "/* some\n"
                "   comment */",
-            format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
-                   "qqq\n"
-                   " /* some\n"
-                   "    comment */",
-                   getLLVMStyle()));
-  EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+               "// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+               getLLVMStyle());
+  verifyFormat("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
                "wwww; /* some\n"
                "         comment */",
-            format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
-                   "wwww; /* some\n"
-                   "         comment */",
-                   getLLVMStyle()));
+               "  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
+               getLLVMStyle());
 }
 
 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
   FormatStyle NoSpace = getLLVMStyle();
   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
 
   verifyFormat("while(true)\n"
                "  continue;",
verifyFormat("enum foo {\n"
                "#endif\n"
                "#if B\n"
                "#else\n"
                "  a = 12;\n"
                "#endif\n"
                "};\n",
                Alignment);
 
-  EXPECT_EQ("int a = 5;\n"
+  verifyFormat("int a = 5;\n"
                "\n"
                "int oneTwoThree = 123;",
-            format("int a       = 5;\n"
-                   "\n"
-                   "int oneTwoThree= 123;",
-                   Alignment));
-  EXPECT_EQ("int a   = 5;\n"
+               "int a       = 5;\n"
+               Alignment);
+  verifyFormat("int a   = 5;\n"
                "int one = 1;\n"
                "\n"
                "int oneTwoThree = 123;",
-            format("int a = 5;\n"
-                   "int one = 1;\n"
-                   "\n"
-                   "int oneTwoThree = 123;",
-                   Alignment));
-  EXPECT_EQ("int a   = 5;\n"
+               "int a = 5;\n"
+               Alignment);
+  verifyFormat("int a   = 5;\n"
                "int one = 1;\n"
                "\n"
                "int oneTwoThree = 123;\n"
                "int oneTwo      = 12;",
-            format("int a = 5;\n"
-                   "int one = 1;\n"
-                   "\n"
-                   "int oneTwoThree = 123;\n"
-                   "int oneTwo = 12;",
-                   Alignment));
+               "int a = 5;\n"
+               Alignment);
   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
   verifyFormat("#define A \\\n"
                "  int aaaa       = 12; \\\n"
                "  int b          = 23; \\\n"
                "  int ccc        = 234; \\\n"
                "  int dddddddddd = 2345;",
                Alignment);
   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
verifyFormat("for (int i = 0; i < 1; i++)\n"
                Alignment);
   verifyFormat("for (i = 0; i < 1; i++)\n"
                "  x = 1;\n"
                "y = 1;\n",
                Alignment);
 
   Alignment.ReflowComments = true;
   Alignment.ColumnLimit = 50;
-  EXPECT_EQ("int x   = 0;\n"
+  verifyFormat("int x   = 0;\n"
                "int yy  = 1; /// specificlennospace\n"
                "int zzz = 2;\n",
-            format("int x   = 0;\n"
-                   "int yy  = 1; ///specificlennospace\n"
-                   "int zzz = 2;\n",
-                   Alignment));
+               "int x   = 0;\n"
+               Alignment);
 }
 
 TEST_F(FormatTest, AlignConsecutiveBitFields) {
   FormatStyle Alignment = getLLVMStyle();
   Alignment.AlignConsecutiveBitFields = true;
   verifyFormat("int const a     : 5;\n"
                "int oneTwoThree : 23;",
                Alignment);
verifyFormat("float a = 5;\n"
                "int   one = 1;\n"
                "method();\n"
                "const double       oneTwoThree = 123;\n"
                "const unsigned int oneTwo = 12;",
                Alignment);
   verifyFormat("int      oneTwoThree{0}; // comment\n"
                "unsigned oneTwo;         // comment",
                Alignment);
-  EXPECT_EQ("float const a = 5;\n"
+  verifyFormat("float const a = 5;\n"
                "\n"
                "int oneTwoThree = 123;",
-            format("float const   a = 5;\n"
-                   "\n"
-                   "int           oneTwoThree= 123;",
-                   Alignment));
-  EXPECT_EQ("float a = 5;\n"
+               "float const   a = 5;\n"
+               Alignment);
+  verifyFormat("float a = 5;\n"
                "int   one = 1;\n"
                "\n"
                "unsigned oneTwoThree = 123;",
-            format("float    a = 5;\n"
-                   "int      one = 1;\n"
-                   "\n"
-                   "unsigned oneTwoThree = 123;",
-                   Alignment));
-  EXPECT_EQ("float a = 5;\n"
+               "float    a = 5;\n"
+               Alignment);
+  verifyFormat("float a = 5;\n"
                "int   one = 1;\n"
                "\n"
                "unsigned oneTwoThree = 123;\n"
                "int      oneTwo = 12;",
-            format("float    a = 5;\n"
-                   "int one = 1;\n"
-                   "\n"
-                   "unsigned oneTwoThree = 123;\n"
-                   "int oneTwo = 12;",
-                   Alignment));
+               "float    a = 5;\n"
+               Alignment);
   // Function prototype alignment
   verifyFormat("int    a();\n"
                "double b();",
                Alignment);
   verifyFormat("int    a(int x);\n"
                "double b();",
                Alignment);
   unsigned OldColumnLimit = Alignment.ColumnLimit;
   // We need to set ColumnLimit to zero, in order to stress nested alignments,
   // otherwise the function parameters will be re-flowed onto a single line.
   Alignment.ColumnLimit = 0;
-  EXPECT_EQ("int    a(int   x,\n"
+  verifyFormat("int    a(int   x,\n"
                "         float y);\n"
                "double b(int    x,\n"
                "         double y);",
-            format("int a(int x,\n"
-                   " float y);\n"
-                   "double b(int x,\n"
-                   " double y);",
-                   Alignment));
+               "int a(int x,\n"
+               Alignment);
   // This ensures that function parameters of function declarations are
   // correctly indented when their owning functions are indented.
   // The failure case here is for 'double y' to not be indented enough.
-  EXPECT_EQ("double a(int x);\n"
+  verifyFormat("double a(int x);\n"
                "int    b(int    y,\n"
                "         double z);",
-            format("double a(int x);\n"
-                   "int b(int y,\n"
-                   " double z);",
-                   Alignment));
+               "double a(int x);\n"
+               Alignment);
   // Set ColumnLimit low so that we induce wrapping immediately after
   // the function name and opening paren.
   Alignment.ColumnLimit = 13;
   verifyFormat("int function(\n"
                "    int  x,\n"
                "    bool y);",
                Alignment);
   Alignment.ColumnLimit = OldColumnLimit;
verifyFormat("struct test {\n"
                "};\n",
                Alignment);
   verifyFormat("struct test {\n"
                "  long long int foo();\n"
                "  int           operator()(int a);\n"
                "  double        bar();\n"
                "};\n",
                Alignment);
-  EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
+  verifyFormat("void SomeFunction(int parameter = 0) {\n"
                "  int const i   = 1;\n"
                "  int *     j   = 2;\n"
                "  int       big = 10000;\n"
                "\n"
                "  unsigned oneTwoThree = 123;\n"
                "  int      oneTwo      = 12;\n"
                "  method();\n"
                "  float k  = 2;\n"
                "  int   ll = 10000;\n"
                "}",
-            format("void SomeFunction(int parameter= 0) {\n"
-                   " int const  i= 1;\n"
-                   "  int *j=2;\n"
-                   " int big  =  10000;\n"
-                   "\n"
-                   "unsigned oneTwoThree  =123;\n"
-                   "int oneTwo = 12;\n"
-                   "  method();\n"
-                   "float k= 2;\n"
-                   "int ll=10000;\n"
-                   "}",
-                   Alignment));
+               "void SomeFunction(int parameter= 0) {\n"
+               Alignment);
   Alignment.AlignConsecutiveAssignments = false;
   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
   verifyFormat("#define A \\\n"
                "  int       aaaa = 12; \\\n"
                "  float     b = 23; \\\n"
                "  const int ccc = 234; \\\n"
                "  unsigned  dddddddddd = 2345;",
                Alignment);
verifyFormat("int func() { //\n"
                "  int      b;\n"
                "  unsigned c;\n"
                "}",
                Alignment);
 
   // See PR37175
   FormatStyle Style = getMozillaStyle();
   Style.AlignConsecutiveDeclarations = true;
-  EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
+  verifyFormat("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
                "foo(int a);",
-            format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
+               "DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style);
 }
 
 TEST_F(FormatTest, LinuxBraceBreaking) {
   FormatStyle LinuxBraceStyle = getLLVMStyle();
   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
   verifyFormat("namespace a\n"
                "{\n"
                "class A\n"
verifyFormat("void foobar() { int i = 5; }\n"
                "#endif",
                StroustrupBraceStyle);
 }
 
 TEST_F(FormatTest, AllmanBraceBreaking) {
   FormatStyle AllmanBraceStyle = getLLVMStyle();
   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
 
-  EXPECT_EQ("namespace a\n"
+  verifyFormat("namespace a\n"
                "{\n"
                "void f();\n"
                "void g();\n"
                "} // namespace a\n",
-            format("namespace a\n"
-                   "{\n"
-                   "void f();\n"
-                   "void g();\n"
-                   "}\n",
-                   AllmanBraceStyle));
+               "namespace a\n"
+               AllmanBraceStyle);
 
   verifyFormat("namespace a\n"
                "{\n"
                "class A\n"
                "{\n"
                "  void f()\n"
                "  {\n"
                "    if (true)\n"
verifyFormat("void f() {\n"
                "}\n",
                getLLVMStyle());
 }
 
 TEST_F(FormatTest, UnderstandsPragmas) {
   verifyFormat("#pragma omp reduction(| : var)");
   verifyFormat("#pragma omp reduction(+ : var)");
 
-  EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
+  verifyFormat("#pragma mark Any non-hyphenated or hyphenated string "
                "(including parentheses).",
-            format("#pragma    mark   Any non-hyphenated or hyphenated string "
-                   "(including parentheses)."));
+               "#pragma    mark   Any non-hyphenated or hyphenated string "
+               "(including parentheses).");
 }
 
 TEST_F(FormatTest, UnderstandPragmaOption) {
   verifyFormat("#pragma option -C -A");
 
-  EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
+  verifyFormat("#pragma option -C -A", "#pragma    option   -C   -A");
 }
 
 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
   FormatStyle Style = getLLVMStyle();
   Style.ColumnLimit = 20;
 
   // See PR41213
-  EXPECT_EQ("/*\n"
+  verifyFormat("/*\n"
                " *\t9012345\n"
                " * /8901\n"
                " */",
-            format("/*\n"
-                   " *\t9012345 /8901\n"
-                   " */",
-                   Style));
-  EXPECT_EQ("/*\n"
+               "/*\n"
+               Style);
+  verifyFormat("/*\n"
                " *345678\n"
                " *\t/8901\n"
                " */",
-            format("/*\n"
-                   " *345678\t/8901\n"
-                   " */",
-                   Style));
+               "/*\n"
+               Style);
 
   verifyFormat("int a; // the\n"
                "       // comment",
                Style);
-  EXPECT_EQ("int a; /* first line\n"
+  verifyFormat("int a; /* first line\n"
                "        * second\n"
                "        * line third\n"
                "        * line\n"
                "        */",
-            format("int a; /* first line\n"
-                   "        * second\n"
-                   "        * line third\n"
-                   "        * line\n"
-                   "        */",
-                   Style));
-  EXPECT_EQ("int a; // first line\n"
+               "int a; /* first line\n"
+               Style);
+  verifyFormat("int a; // first line\n"
                "       // second\n"
                "       // line third\n"
                "       // line",
-            format("int a; // first line\n"
-                   "       // second line\n"
-                   "       // third line",
-                   Style));
+               "int a; // first line\n"
+               Style);
 
   Style.PenaltyExcessCharacter = 90;
   verifyFormat("int a; // the comment", Style);
-  EXPECT_EQ("int a; // the comment\n"
+  verifyFormat("int a; // the comment\n"
                "       // aaa",
-            format("int a; // the comment aaa", Style));
-  EXPECT_EQ("int a; /* first line\n"
+               "int a; // the comment aaa", Style);
+  verifyFormat("int a; /* first line\n"
                "        * second line\n"
                "        * third line\n"
                "        */",
-            format("int a; /* first line\n"
-                   "        * second line\n"
-                   "        * third line\n"
-                   "        */",
-                   Style));
-  EXPECT_EQ("int a; // first line\n"
+               "int a; /* first line\n"
+               Style);
+  verifyFormat("int a; // first line\n"
                "       // second line\n"
                "       // third line",
-            format("int a; // first line\n"
-                   "       // second line\n"
-                   "       // third line",
-                   Style));
+               "int a; // first line\n"
+               Style);
   // FIXME: Investigate why this is not getting the same layout as the test
   // above.
-  EXPECT_EQ("int a; /* first line\n"
+  verifyFormat("int a; /* first line\n"
                "        * second line\n"
                "        * third line\n"
                "        */",
-            format("int a; /* first line second line third line"
-                   "\n*/",
-                   Style));
+               "int a; /* first line second line third line"
+               Style);
 
-  EXPECT_EQ("// foo bar baz bazfoo\n"
+  verifyFormat("// foo bar baz bazfoo\n"
                "// foo bar foo bar\n",
-            format("// foo bar baz bazfoo\n"
-                   "// foo bar foo           bar\n",
-                   Style));
-  EXPECT_EQ("// foo bar baz bazfoo\n"
+               "// foo bar baz bazfoo\n"
+               Style);
+  verifyFormat("// foo bar baz bazfoo\n"
                "// foo bar foo bar\n",
-            format("// foo bar baz      bazfoo\n"
-                   "// foo            bar foo bar\n",
-                   Style));
+               "// foo bar baz      bazfoo\n"
+               Style);
 
   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
   // next one.
-  EXPECT_EQ("// foo bar baz bazfoo\n"
+  verifyFormat("// foo bar baz bazfoo\n"
                "// bar foo bar\n",
-            format("// foo bar baz      bazfoo bar\n"
-                   "// foo            bar\n",
-                   Style));
+               "// foo bar baz      bazfoo bar\n"
+               Style);
 
-  EXPECT_EQ("// foo bar baz bazfoo\n"
+  verifyFormat("// foo bar baz bazfoo\n"
                "// foo bar baz bazfoo\n"
                "// bar foo bar\n",
-            format("// foo bar baz      bazfoo\n"
-                   "// foo bar baz      bazfoo bar\n"
-                   "// foo bar\n",
-                   Style));
+               "// foo bar baz      bazfoo\n"
+               Style);
 
-  EXPECT_EQ("// foo bar baz bazfoo\n"
+  verifyFormat("// foo bar baz bazfoo\n"
                "// foo bar baz bazfoo\n"
                "// bar foo bar\n",
-            format("// foo bar baz      bazfoo\n"
-                   "// foo bar baz      bazfoo bar\n"
-                   "// foo           bar\n",
-                   Style));
+               "// foo bar baz      bazfoo\n"
+               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"
+  verifyFormat("// 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 foo foo foo foo foo foo foo foo\n", Style);
 
-  EXPECT_EQ("int a = /* long block\n"
+  verifyFormat("int a = /* long block\n"
                "           comment */\n"
                "    42;",
-            format("int a = /* long block comment */ 42;", Style));
+               "int a = /* long block comment */ 42;", Style);
 }
 
 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
   for (size_t i = 1; i < Styles.size(); ++i)                                   \
   EXPECT_EQ(Styles[0], Styles[i])                                              \
       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
 
 TEST_F(FormatTest, GetsPredefinedStyleByName) {
TEST_F(FormatTest, ConfigurationRoundTripTest) {
   std::string YAML = configurationAsText(Style);
   FormatStyle ParsedStyle = {};
   ParsedStyle.Language = FormatStyle::LK_Cpp;
   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
   EXPECT_EQ(Style, ParsedStyle);
 }
 
 TEST_F(FormatTest, WorksFor8bitEncodings) {
-  EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
+  verifyFormat("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
                "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
                "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
                "\"\xef\xee\xf0\xf3...\"",
-            format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
-                   "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
-                   "\xef\xee\xf0\xf3...\"",
-                   getLLVMStyleWithColumns(12)));
+               "\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
+               getLLVMStyleWithColumns(12));
 }
 
 TEST_F(FormatTest, HandlesUTF8BOM) {
-  EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
-  EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
-            format("\xef\xbb\xbf#include <iostream>"));
-  EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
-            format("\xef\xbb\xbf\n#include <iostream>"));
+  verifyFormat("\xef\xbb\xbf", "\xef\xbb\xbf");
+  verifyFormat("\xef\xbb\xbf#include <iostream>",
+               "\xef\xbb\xbf#include <iostream>");
+  verifyFormat("\xef\xbb\xbf\n#include <iostream>",
+               "\xef\xbb\xbf\n#include <iostream>");
 }
 
 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
 #if !defined(_MSC_VER)
 
 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
                getLLVMStyleWithColumns(35));
   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
                getLLVMStyleWithColumns(31));
   verifyFormat("// Однажды в студёную зимнюю пору...",
                getLLVMStyleWithColumns(36));
   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
   verifyFormat("/* Однажды в студёную зимнюю пору... */",
                getLLVMStyleWithColumns(39));
   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
                getLLVMStyleWithColumns(35));
 }
 
 TEST_F(FormatTest, SplitsUTF8Strings) {
   // Non-printable characters' width is currently considered to be the length in
   // bytes in UTF8. The characters can be displayed in very different manner
   // (zero-width, single width with a substitution glyph, expanded to their code
   // (e.g. "<8d>"), so there's no single correct way to handle them.
-  EXPECT_EQ("\"aaaaÄ\"\n"
+  verifyFormat("\"aaaaÄ\"\n"
                "\"\xc2\x8d\";",
-            format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("\"aaaaaaaÄ\"\n"
+               "\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10));
+  verifyFormat("\"aaaaaaaÄ\"\n"
                "\"\xc2\x8d\";",
-            format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("\"Однажды, в \"\n"
+               "\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10));
+  verifyFormat("\"Однажды, в \"\n"
                "\"студёную \"\n"
                "\"зимнюю \"\n"
                "\"пору,\"",
-            format("\"Однажды, в студёную зимнюю пору,\"",
-                   getLLVMStyleWithColumns(13)));
-  EXPECT_EQ(
-      "\"一 二 三 \"\n"
+               "\"Однажды, в студёную зимнюю пору,\"",
+               getLLVMStyleWithColumns(13));
+  verifyFormat("\"一 二 三 \"\n"
                "\"四 五六 \"\n"
                "\"七 八 九 \"\n"
                "\"十\"",
-      format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
-  EXPECT_EQ("\"一\t\"\n"
+               "\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11));
+  verifyFormat("\"一\t\"\n"
                "\"二 \t\"\n"
                "\"三 四 \"\n"
                "\"五\t\"\n"
                "\"六 \t\"\n"
                "\"七 \"\n"
                "\"八九十\tqq\"",
-            format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
-                   getLLVMStyleWithColumns(11)));
+               "\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
+               getLLVMStyleWithColumns(11));
 
   // UTF8 character in an escape sequence.
-  EXPECT_EQ("\"aaaaaa\"\n"
+  verifyFormat("\"aaaaaa\"\n"
                "\"\\\xC2\x8D\"",
-            format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
+               "\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10));
 }
 
 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
-  EXPECT_EQ("const char *sssss =\n"
+  verifyFormat("const char *sssss =\n"
                "    \"一二三四五六七八\\\n"
                " 九 十\";",
-            format("const char *sssss = \"一二三四五六七八\\\n"
-                   " 九 十\";",
-                   getLLVMStyleWithColumns(30)));
+               "const char *sssss = \"一二三四五六七八\\\n"
+               getLLVMStyleWithColumns(30));
 }
 
 TEST_F(FormatTest, SplitsUTF8LineComments) {
-  EXPECT_EQ("// aaaaÄ\xc2\x8d",
-            format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("// Я из лесу\n"
+  verifyFormat("// aaaaÄ\xc2\x8d", "// aaaaÄ\xc2\x8d",
+               getLLVMStyleWithColumns(10));
+  verifyFormat("// Я из лесу\n"
                "// вышел; был\n"
                "// сильный\n"
                "// мороз.",
-            format("// Я из лесу вышел; был сильный мороз.",
-                   getLLVMStyleWithColumns(13)));
-  EXPECT_EQ("// 一二三\n"
+               "// Я из лесу вышел; был сильный мороз.",
+               getLLVMStyleWithColumns(13));
+  verifyFormat("// 一二三\n"
                "// 四五六七\n"
                "// 八  九\n"
                "// 十",
-            format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
+               "// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9));
 }
 
 TEST_F(FormatTest, SplitsUTF8BlockComments) {
-  EXPECT_EQ("/* Гляжу,\n"
+  verifyFormat("/* Гляжу,\n"
                " * поднимается\n"
                " * медленно в\n"
                " * гору\n"
                " * Лошадка,\n"
                " * везущая\n"
                " * хворосту\n"
                " * воз. */",
-            format("/* Гляжу, поднимается медленно в гору\n"
-                   " * Лошадка, везущая хворосту воз. */",
-                   getLLVMStyleWithColumns(13)));
-  EXPECT_EQ(
-      "/* 一二三\n"
+               "/* Гляжу, поднимается медленно в гору\n"
+               getLLVMStyleWithColumns(13));
+  verifyFormat("/* 一二三\n"
                " * 四五六七\n"
                " * 八  九\n"
                " * 十  */",
-      format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
-  EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
+               "/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9));
+  verifyFormat("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
                " * 𝕓𝕪𝕥𝕖\n"
                " * 𝖀𝕿𝕱-𝟠 */",
-            format("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12)));
+               "/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯 𝕓𝕪𝕥𝕖 𝖀𝕿𝕱-𝟠 */", getLLVMStyleWithColumns(12));
 }
 
 #endif // _MSC_VER
 
 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
   FormatStyle Style = getLLVMStyle();
 
   Style.ConstructorInitializerIndentWidth = 4;
verifyFormat("switch (variable) {\n"
                "    doSomething();\n"
                "    break;\n"
                "default:\n"
                "    ++variable;\n"
                "}",
                Style);
 
   // Wrap before binary operators.
-  EXPECT_EQ("void f()\n"
-            "{\n"
-            "    if (aaaaaaaaaaaaaaaa\n"
-            "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
-            "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
-            "        return;\n"
-            "}",
-            format("void f() {\n"
-                   "if (aaaaaaaaaaaaaaaa\n"
-                   "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
-                   "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
-                   "return;\n"
-                   "}",
-                   Style));
+  verifyFormat(
+      "void f()\n"
+      "void f() {\n"
+      Style);
 
   // Allow functions on a single line.
   verifyFormat("void f() { return; }", Style);
 
   // Allow empty blocks on a single line and insert a space in empty blocks.
-  EXPECT_EQ("void f() { }", format("void f() {}", Style));
-  EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
+  verifyFormat("void f() { }", "void f() {}", Style);
+  verifyFormat("while (true) { }", "while (true) {}", Style);
   // However, don't merge non-empty short loops.
-  EXPECT_EQ("while (true) {\n"
+  verifyFormat("while (true) {\n"
                "    continue;\n"
                "}",
-            format("while (true) { continue; }", Style));
+               "while (true) { continue; }", Style);
 
   // Constructor initializers are formatted one per line with the "," on the
   // new line.
   verifyFormat("Constructor()\n"
                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
                "          aaaaaaaaaaaaaa)\n"
                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
                "{\n"
                "}",
                Style);
   verifyFormat("SomeClass::Constructor()\n"
                "    : a(a)\n"
                "{\n"
                "}",
                Style);
-  EXPECT_EQ("SomeClass::Constructor()\n"
+  verifyFormat("SomeClass::Constructor()\n"
                "    : a(a)\n"
                "{\n"
                "}",
-            format("SomeClass::Constructor():a(a){}", Style));
+               "SomeClass::Constructor():a(a){}", Style);
   verifyFormat("SomeClass::Constructor()\n"
                "    : a(a)\n"
                "    , b(b)\n"
                "    , c(c)\n"
                "{\n"
                "}",
                Style);
   verifyFormat("SomeClass::Constructor()\n"
verifyFormat("class C {\n"
                Style);
 
   // Do not align comments.
   verifyFormat("int a; // Do not\n"
                "double b; // align comments.",
                Style);
 
   // Do not align operands.
-  EXPECT_EQ("ASSERT(aaaa\n"
+  verifyFormat("ASSERT(aaaa\n"
                "    || bbbb);",
-            format("ASSERT ( aaaa\n||bbbb);", Style));
+               "ASSERT ( aaaa\n||bbbb);", Style);
 
   // Accept input's line breaks.
-  EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
+  verifyFormat("if (aaaaaaaaaaaaaaa\n"
                "    || bbbbbbbbbbbbbbb) {\n"
                "    i++;\n"
                "}",
-            format("if (aaaaaaaaaaaaaaa\n"
-                   "|| bbbbbbbbbbbbbbb) { i++; }",
-                   Style));
-  EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
+               "if (aaaaaaaaaaaaaaa\n"
+               Style);
+  verifyFormat("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
                "    i++;\n"
                "}",
-            format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
+               "if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style);
 
   // Don't automatically break all macro definitions (llvm.org/PR17842).
   verifyFormat("#define aNumber 10", Style);
   // However, generally keep the line breaks that the user authored.
-  EXPECT_EQ("#define aNumber \\\n"
+  verifyFormat("#define aNumber \\\n"
                "    10",
-            format("#define aNumber \\\n"
-                   " 10",
-                   Style));
+               "#define aNumber \\\n"
+               Style);
 
   // Keep empty and one-element array literals on a single line.
-  EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
+  verifyFormat("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
                "                                  copyItems:YES];",
-            format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
-                   "copyItems:YES];",
-                   Style));
-  EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
+               "NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
+               Style);
+  verifyFormat("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
                "                                  copyItems:YES];",
-            format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
-                   "             copyItems:YES];",
-                   Style));
+               "NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
+               Style);
   // FIXME: This does not seem right, there should be more indentation before
   // the array literal's entries. Nested blocks have the same problem.
-  EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
+  verifyFormat("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
                "    @\"a\",\n"
                "    @\"a\"\n"
                "]\n"
                "                                  copyItems:YES];",
-            format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
-                   "     @\"a\",\n"
-                   "     @\"a\"\n"
-                   "     ]\n"
-                   "       copyItems:YES];",
-                   Style));
-  EXPECT_EQ(
+               "NSArray* a = [[NSArray alloc] initWithArray:@[\n"
+               Style);
+  verifyFormat(
       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
       "                                  copyItems:YES];",
-      format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
-             "   copyItems:YES];",
-             Style));
+      "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
+      Style);
 
   verifyFormat("[self.a b:c c:d];", Style);
-  EXPECT_EQ("[self.a b:c\n"
+  verifyFormat("[self.a b:c\n"
                "        c:d];",
-            format("[self.a b:c\n"
-                   "c:d];",
-                   Style));
+               "[self.a b:c\n"
+               Style);
 }
 
 TEST_F(FormatTest, FormatsLambdas) {
   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
   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(
       "      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"
+  verifyFormat("SomeFunction([]() {\n"
                "#define A a\n"
                "  return 43;\n"
                "});",
-            format("SomeFunction([](){\n"
-                   "#define A a\n"
-                   "return 43;\n"
-                   "});"));
+               "SomeFunction([](){\n"
+               "});");
   verifyFormat("void f() {\n"
                "  SomeFunction([](decltype(x), A *a) {});\n"
                "}");
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
                "    [](const aaaaaaaaaa &a) { return a; });");
   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
                "});");
verifyFormat("[[SessionService sharedService] "
                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
                "  if (window) {\n"
                "    [self windowDidLoad:window];\n"
                "  } else {\n"
                "    [self errorLoadingWindow];\n"
                "  }\n"
                "}];",
                ZeroColumn);
-  EXPECT_EQ("[[SessionService sharedService]\n"
+  verifyFormat("[[SessionService sharedService]\n"
                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
                "      if (window) {\n"
                "        [self windowDidLoad:window];\n"
                "      } else {\n"
                "        [self errorLoadingWindow];\n"
                "      }\n"
                "    }];",
-            format("[[SessionService sharedService]\n"
-                   "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
-                   "                if (window) {\n"
-                   "    [self windowDidLoad:window];\n"
-                   "  } else {\n"
-                   "    [self errorLoadingWindow];\n"
-                   "  }\n"
-                   "}];",
-                   ZeroColumn));
+               "[[SessionService sharedService]\n"
+               ZeroColumn);
   verifyFormat("[myObject doSomethingWith:arg1\n"
                "    firstBlock:^(Foo *a) {\n"
                "      // ...\n"
                "      int i;\n"
                "    }\n"
                "    secondBlock:^(Bar *b) {\n"
                "      // ...\n"
                "      int i;\n"
verifyFormat("f(^{\n"
                "});",
                ZeroColumn);
   verifyFormat("void (^largeBlock)(void) = ^{\n"
                "  // ...\n"
                "};",
                ZeroColumn);
 
   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
-  EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
-            format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
+  verifyFormat("void (^largeBlock)(void) = ^{ int i; };",
+               "void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn);
   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
-  EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
+  verifyFormat("void (^largeBlock)(void) = ^{\n"
                "  int i;\n"
                "};",
-            format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
+               "void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn);
 }
 
 TEST_F(FormatTest, SupportsCRLF) {
-  EXPECT_EQ("int a;\r\n"
+  verifyFormat("int a;\r\n"
                "int b;\r\n"
                "int c;\r\n",
-            format("int a;\r\n"
-                   "  int b;\r\n"
-                   "    int c;\r\n",
-                   getLLVMStyle()));
-  EXPECT_EQ("int a;\r\n"
+               "int a;\r\n"
+               getLLVMStyle());
+  verifyFormat("int a;\r\n"
                "int b;\r\n"
                "int c;\r\n",
-            format("int a;\r\n"
-                   "  int b;\n"
-                   "    int c;\r\n",
-                   getLLVMStyle()));
-  EXPECT_EQ("int a;\n"
+               "int a;\r\n"
+               getLLVMStyle());
+  verifyFormat("int a;\n"
                "int b;\n"
                "int c;\n",
-            format("int a;\r\n"
-                   "  int b;\n"
-                   "    int c;\n",
-                   getLLVMStyle()));
-  EXPECT_EQ("\"aaaaaaa \"\r\n"
+               "int a;\r\n"
+               getLLVMStyle());
+  verifyFormat("\"aaaaaaa \"\r\n"
                "\"bbbbbbb\";\r\n",
-            format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
-  EXPECT_EQ("#define A \\\r\n"
+               "\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10));
+  verifyFormat("#define A \\\r\n"
                "  b;      \\\r\n"
                "  c;      \\\r\n"
                "  d;\r\n",
-            format("#define A \\\r\n"
-                   "  b; \\\r\n"
-                   "  c; d; \r\n",
-                   getGoogleStyle()));
+               "#define A \\\r\n"
+               getGoogleStyle());
 
-  EXPECT_EQ("/*\r\n"
+  verifyFormat("/*\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"
+               "*/\r\n");
+  verifyFormat("/*\r\n"
                "\r\n"
                "*/",
-            format("/*\r\n"
-                   "    \r\r\r\n"
-                   "*/"));
+               "/*\r\n"
+               "*/");
 
   FormatStyle style = getLLVMStyle();
 
   style.DeriveLineEnding = true;
   style.UseCRLF = false;
-  EXPECT_EQ("union FooBarBazQux {\n"
+  verifyFormat("union FooBarBazQux {\n"
                "  int foo;\n"
                "  int bar;\n"
                "  int baz;\n"
                "};",
-            format("union FooBarBazQux {\r\n"
-                   "  int foo;\n"
-                   "  int bar;\r\n"
-                   "  int baz;\n"
-                   "};",
-                   style));
+               "union FooBarBazQux {\r\n"
+               style);
   style.UseCRLF = true;
-  EXPECT_EQ("union FooBarBazQux {\r\n"
+  verifyFormat("union FooBarBazQux {\r\n"
                "  int foo;\r\n"
                "  int bar;\r\n"
                "  int baz;\r\n"
                "};",
-            format("union FooBarBazQux {\r\n"
-                   "  int foo;\n"
-                   "  int bar;\r\n"
-                   "  int baz;\n"
-                   "};",
-                   style));
+               "union FooBarBazQux {\r\n"
+               style);
 
   style.DeriveLineEnding = false;
   style.UseCRLF = false;
-  EXPECT_EQ("union FooBarBazQux {\n"
+  verifyFormat("union FooBarBazQux {\n"
                "  int foo;\n"
                "  int bar;\n"
                "  int baz;\n"
                "  int qux;\n"
                "};",
-            format("union FooBarBazQux {\r\n"
-                   "  int foo;\n"
-                   "  int bar;\r\n"
-                   "  int baz;\n"
-                   "  int qux;\r\n"
-                   "};",
-                   style));
+               "union FooBarBazQux {\r\n"
+               style);
   style.UseCRLF = true;
-  EXPECT_EQ("union FooBarBazQux {\r\n"
+  verifyFormat("union FooBarBazQux {\r\n"
                "  int foo;\r\n"
                "  int bar;\r\n"
                "  int baz;\r\n"
                "  int qux;\r\n"
                "};",
-            format("union FooBarBazQux {\r\n"
-                   "  int foo;\n"
-                   "  int bar;\r\n"
-                   "  int baz;\n"
-                   "  int qux;\n"
-                   "};",
-                   style));
+               "union FooBarBazQux {\r\n"
+               style);
 
   style.DeriveLineEnding = true;
   style.UseCRLF = false;
-  EXPECT_EQ("union FooBarBazQux {\r\n"
+  verifyFormat("union FooBarBazQux {\r\n"
                "  int foo;\r\n"
                "  int bar;\r\n"
                "  int baz;\r\n"
                "  int qux;\r\n"
                "};",
-            format("union FooBarBazQux {\r\n"
-                   "  int foo;\n"
-                   "  int bar;\r\n"
-                   "  int baz;\n"
-                   "  int qux;\r\n"
-                   "};",
-                   style));
+               "union FooBarBazQux {\r\n"
+               style);
   style.UseCRLF = true;
-  EXPECT_EQ("union FooBarBazQux {\n"
+  verifyFormat("union FooBarBazQux {\n"
                "  int foo;\n"
                "  int bar;\n"
                "  int baz;\n"
                "  int qux;\n"
                "};",
-            format("union FooBarBazQux {\r\n"
-                   "  int foo;\n"
-                   "  int bar;\r\n"
-                   "  int baz;\n"
-                   "  int qux;\n"
-                   "};",
-                   style));
+               "union FooBarBazQux {\r\n"
+               style);
 }
 
 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
   verifyFormat("MY_CLASS(C) {\n"
                "  int i;\n"
                "  int j;\n"
                "};");
 }
 
 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
   TwoIndent.ContinuationIndentWidth = 2;
 
-  EXPECT_EQ("int i =\n"
+  verifyFormat("int i =\n"
                "  longFunction(\n"
                "    arg);",
-            format("int i = longFunction(arg);", TwoIndent));
+               "int i = longFunction(arg);", TwoIndent);
 
   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
   SixIndent.ContinuationIndentWidth = 6;
 
-  EXPECT_EQ("int i =\n"
+  verifyFormat("int i =\n"
                "      longFunction(\n"
                "            arg);",
-            format("int i = longFunction(arg);", SixIndent));
+               "int i = longFunction(arg);", SixIndent);
 }
 
 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
   FormatStyle Style = getLLVMStyle();
   verifyFormat("int Foo::getter(\n"
                "    //\n"
                ") const {\n"
                "  return foo;\n"
TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
   Style.SpaceAfterTemplateKeyword = false;
   verifyFormat("template<int> void foo();", Style);
 }
 
 TEST_F(FormatTest, TripleAngleBrackets) {
   verifyFormat("f<<<1, 1>>>();");
   verifyFormat("f<<<1, 1, 1, s>>>();");
   verifyFormat("f<<<a, b, c, d>>>();");
-  EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
+  verifyFormat("f<<<1, 1>>>();", "f <<< 1, 1 >>> ();");
   verifyFormat("f<param><<<1, 1>>>();");
   verifyFormat("f<1><<<1, 1>>>();");
-  EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
+  verifyFormat("f<param><<<1, 1>>>();", "f< param > <<< 1, 1 >>> ();");
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                "aaaaaaaaaaa<<<\n    1, 1>>>();");
   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
 }
 
 TEST_F(FormatTest, MergeLessLessAtEnd) {
   verifyFormat("<<");
-  EXPECT_EQ("< < <", format("\\\n<<<"));
+  verifyFormat("< < <", "\\\n<<<");
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                "aaallvm::outs() <<");
   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                "aaaallvm::outs()\n    <<");
 }
 
 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
   std::string code = "#if A\n"
                      "#if B\n"
                      "a.\n"
                      "#endif\n"
                      "    a = 1;\n"
                      "#else\n"
                      "#endif\n"
                      "#if C\n"
                      "#else\n"
                      "#endif\n";
   EXPECT_EQ(code, format(code));
 }
 
 TEST_F(FormatTest, HandleConflictMarkers) {
   // Git/SVN conflict markers.
-  EXPECT_EQ("int a;\n"
+  verifyFormat("int a;\n"
                "void f() {\n"
                "  callme(some(parameter1,\n"
                "<<<<<<< text by the vcs\n"
                "              parameter2),\n"
                "||||||| text by the vcs\n"
                "              parameter2),\n"
                "         parameter3,\n"
                "======= text by the vcs\n"
                "              parameter2, parameter3),\n"
                ">>>>>>> text by the vcs\n"
                "         otherparameter);\n",
-            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"));
+               "int a;\n"
+               "  otherparameter);\n");
 
   // Perforce markers.
-  EXPECT_EQ("void f() {\n"
+  verifyFormat("void f() {\n"
                "  function(\n"
                ">>>> text by the vcs\n"
                "      parameter,\n"
                "==== text by the vcs\n"
                "      parameter,\n"
                "==== text by the vcs\n"
                "      parameter,\n"
                "<<<< text by the vcs\n"
                "      parameter);\n",
-            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"));
+               "void f() {\n"
+               "  parameter);\n");
 
-  EXPECT_EQ("<<<<<<<\n"
+  verifyFormat("<<<<<<<\n"
                "|||||||\n"
                "=======\n"
                ">>>>>>>",
-            format("<<<<<<<\n"
-                   "|||||||\n"
-                   "=======\n"
-                   ">>>>>>>"));
+               "<<<<<<<\n"
+               ">>>>>>>");
 
-  EXPECT_EQ("<<<<<<<\n"
+  verifyFormat("<<<<<<<\n"
                "|||||||\n"
                "int i;\n"
                "=======\n"
                ">>>>>>>",
-            format("<<<<<<<\n"
-                   "|||||||\n"
-                   "int i;\n"
-                   "=======\n"
-                   ">>>>>>>"));
+               "<<<<<<<\n"
+               ">>>>>>>");
 
   // FIXME: Handle parsing of macros around conflict markers correctly:
-  EXPECT_EQ("#define Macro \\\n"
+  verifyFormat("#define Macro \\\n"
                "<<<<<<<\n"
                "Something \\\n"
                "|||||||\n"
                "Else \\\n"
                "=======\n"
                "Other \\\n"
                ">>>>>>>\n"
                "    End int i;\n",
-            format("#define Macro \\\n"
-                   "<<<<<<<\n"
-                   "  Something \\\n"
-                   "|||||||\n"
-                   "  Else \\\n"
-                   "=======\n"
-                   "  Other \\\n"
-                   ">>>>>>>\n"
-                   "  End\n"
-                   "int i;\n"));
+               "#define Macro \\\n"
+               "int i;\n");
 }
 
 TEST_F(FormatTest, DisableRegions) {
-  EXPECT_EQ("int i;\n"
+  verifyFormat("int i;\n"
                "// clang-format off\n"
                "  int j;\n"
                "// clang-format on\n"
                "int k;",
-            format(" int  i;\n"
-                   "   // clang-format off\n"
-                   "  int j;\n"
-                   " // clang-format on\n"
-                   "   int   k;"));
-  EXPECT_EQ("int i;\n"
+               " int  i;\n"
+               "   int   k;");
+  verifyFormat("int i;\n"
                "/* clang-format off */\n"
                "  int j;\n"
                "/* clang-format on */\n"
                "int k;",
-            format(" int  i;\n"
-                   "   /* clang-format off */\n"
-                   "  int j;\n"
-                   " /* clang-format on */\n"
-                   "   int   k;"));
+               " int  i;\n"
+               "   int   k;");
 
   // Don't reflow comments within disabled regions.
-  EXPECT_EQ("// clang-format off\n"
+  verifyFormat("// clang-format off\n"
                "// long long long long long long line\n"
                "/* clang-format on */\n"
                "/* long long long\n"
                " * long long long\n"
                " * line */\n"
                "int i;\n"
                "/* clang-format off */\n"
                "/* long long long long long long line */\n",
-            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",
-                   getLLVMStyleWithColumns(20)));
+               "// clang-format off\n"
+               getLLVMStyleWithColumns(20));
 }
 
 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
   format("? ) =");
   verifyNoCrash("#define a\\\n /**/}");
 }
 
 TEST_F(FormatTest, FormatsTableGenCode) {
   FormatStyle Style = getLLVMStyle();
   Style.Language = FormatStyle::LK_TableGen;
   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
 }
 
 TEST_F(FormatTest, ArrayOfTemplates) {
-  EXPECT_EQ("auto a = new unique_ptr<int>[10];",
-            format("auto a = new unique_ptr<int > [ 10];"));
+  verifyFormat("auto a = new unique_ptr<int>[10];",
+               "auto a = new unique_ptr<int > [ 10];");
 
   FormatStyle Spaces = getLLVMStyle();
   Spaces.SpacesInSquareBrackets = true;
-  EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
-            format("auto a = new unique_ptr<int > [10];", Spaces));
+  verifyFormat("auto a = new unique_ptr<int>[ 10 ];",
+               "auto a = new unique_ptr<int > [10];", Spaces);
 }
 
 TEST_F(FormatTest, ArrayAsTemplateType) {
-  EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
-            format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
+  verifyFormat("auto a = unique_ptr<Foo<Bar>[10]>;",
+               "auto a = unique_ptr < Foo < Bar>[ 10]> ;");
 
   FormatStyle Spaces = getLLVMStyle();
   Spaces.SpacesInSquareBrackets = true;
-  EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
-            format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
+  verifyFormat("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
+               "auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces);
 }
 
 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
 
 TEST(FormatStyle, GetStyleWithEmptyFileName) {
   llvm::vfs::InMemoryFileSystem FS;
   auto Style1 = getStyle("file", "", "Google", "", &FS);
   ASSERT_TRUE((bool)Style1);
TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
       << llvm::toString(FormattedReplaces.takeError()) << "\n";
   auto Result = applyAllReplacements(Code, *FormattedReplaces);
   EXPECT_TRUE(static_cast<bool>(Result));
   EXPECT_EQ(Expected, *Result);
 }
 
 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
-  EXPECT_EQ("using std::cin;\n"
+  verifyFormat("using std::cin;\n"
                "using std::cout;",
-            format("using std::cout;\n"
-                   "using std::cin;",
-                   getGoogleStyle()));
+               "using std::cout;\n"
+               getGoogleStyle());
 }
 
 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
   format::FormatStyle Style = format::getLLVMStyle();
   Style.Standard = FormatStyle::LS_Cpp03;
   // cpp03 recognize this string as identifier u8 and literal character 'a'
-  EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
+  verifyFormat("auto c = u8 'a';", "auto c = u8'a';", Style);
 }
 
 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
   // all modes, including C++11, C++14 and C++17
-  EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
+  verifyFormat("auto c = u8'a';", "auto c = u8'a';");
 }
 
 TEST_F(FormatTest, DoNotFormatLikelyXml) {
-  EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
-  EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
+  verifyFormat("<!-- ;> -->", "<!-- ;> -->", getGoogleStyle());
+  verifyFormat(" <!-- >; -->", " <!-- >; -->", getGoogleStyle());
 }
 
 TEST_F(FormatTest, StructuredBindings) {
   // Structured bindings is a C++17 feature.
   // all modes, including C++11, C++14 and C++17
   verifyFormat("auto [a, b] = f();");
-  EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
-  EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
-  EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
-  EXPECT_EQ("auto const volatile [a, b] = f();",
-            format("auto  const   volatile[a, b] = f();"));
-  EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
-  EXPECT_EQ("auto &[a, b, c] = f();",
-            format("auto   &[  a  ,  b,c   ] = f();"));
-  EXPECT_EQ("auto &&[a, b, c] = f();",
-            format("auto   &&[  a  ,  b,c   ] = f();"));
-  EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
-  EXPECT_EQ("auto const volatile &&[a, b] = f();",
-            format("auto  const  volatile  &&[a, b] = f();"));
-  EXPECT_EQ("auto const &&[a, b] = f();",
-            format("auto  const   &&  [a, b] = f();"));
-  EXPECT_EQ("const auto &[a, b] = f();",
-            format("const  auto  &  [a, b] = f();"));
-  EXPECT_EQ("const auto volatile &&[a, b] = f();",
-            format("const  auto   volatile  &&[a, b] = f();"));
-  EXPECT_EQ("volatile const auto &&[a, b] = f();",
-            format("volatile  const  auto   &&[a, b] = f();"));
-  EXPECT_EQ("const auto &&[a, b] = f();",
-            format("const  auto  &&  [a, b] = f();"));
+  verifyFormat("auto [a, b] = f();", "auto[a, b] = f();");
+  verifyFormat("const auto [a, b] = f();", "const   auto[a, b] = f();");
+  verifyFormat("auto const [a, b] = f();", "auto  const[a, b] = f();");
+  verifyFormat("auto const volatile [a, b] = f();",
+               "auto  const   volatile[a, b] = f();");
+  verifyFormat("auto [a, b, c] = f();", "auto   [  a  ,  b,c   ] = f();");
+  verifyFormat("auto &[a, b, c] = f();", "auto   &[  a  ,  b,c   ] = f();");
+  verifyFormat("auto &&[a, b, c] = f();", "auto   &&[  a  ,  b,c   ] = f();");
+  verifyFormat("auto const &[a, b] = f();", "auto  const&[a, b] = f();");
+  verifyFormat("auto const volatile &&[a, b] = f();",
+               "auto  const  volatile  &&[a, b] = f();");
+  verifyFormat("auto const &&[a, b] = f();", "auto  const   &&  [a, b] = f();");
+  verifyFormat("const auto &[a, b] = f();", "const  auto  &  [a, b] = f();");
+  verifyFormat("const auto volatile &&[a, b] = f();",
+               "const  auto   volatile  &&[a, b] = f();");
+  verifyFormat("volatile const auto &&[a, b] = f();",
+               "volatile  const  auto   &&[a, b] = f();");
+  verifyFormat("const auto &&[a, b] = f();", "const  auto  &&  [a, b] = f();");
 
   // Make sure we don't mistake structured bindings for lambdas.
   FormatStyle PointerMiddle = getLLVMStyle();
   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
 
-  EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
-            format("for (const auto   &&   [a, b] : some_range) {\n}"));
-  EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
-            format("for (const auto   &   [a, b] : some_range) {\n}"));
-  EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
-            format("for (const auto[a, b] : some_range) {\n}"));
-  EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
-  EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
-  EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
-  EXPECT_EQ("auto const &[x, y](expr);",
-            format("auto  const  &  [x,y]  (expr);"));
-  EXPECT_EQ("auto const &&[x, y](expr);",
-            format("auto  const  &&  [x,y]  (expr);"));
-  EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
-  EXPECT_EQ("auto const &[x, y]{expr};",
-            format("auto  const  &  [x,y]  {expr};"));
-  EXPECT_EQ("auto const &&[x, y]{expr};",
-            format("auto  const  &&  [x,y]  {expr};"));
+  verifyFormat("for (const auto &&[a, b] : some_range) {\n}",
+               "for (const auto   &&   [a, b] : some_range) {\n}");
+  verifyFormat("for (const auto &[a, b] : some_range) {\n}",
+               "for (const auto   &   [a, b] : some_range) {\n}");
+  verifyFormat("for (const auto [a, b] : some_range) {\n}",
+               "for (const auto[a, b] : some_range) {\n}");
+  verifyFormat("auto [x, y](expr);", "auto[x,y]  (expr);");
+  verifyFormat("auto &[x, y](expr);", "auto  &  [x,y]  (expr);");
+  verifyFormat("auto &&[x, y](expr);", "auto  &&  [x,y]  (expr);");
+  verifyFormat("auto const &[x, y](expr);", "auto  const  &  [x,y]  (expr);");
+  verifyFormat("auto const &&[x, y](expr);", "auto  const  &&  [x,y]  (expr);");
+  verifyFormat("auto [x, y]{expr};", "auto[x,y]     {expr};");
+  verifyFormat("auto const &[x, y]{expr};", "auto  const  &  [x,y]  {expr};");
+  verifyFormat("auto const &&[x, y]{expr};", "auto  const  &&  [x,y]  {expr};");
 
   format::FormatStyle Spaces = format::getLLVMStyle();
   Spaces.SpacesInSquareBrackets = true;
   verifyFormat("auto [ a, b ] = f();", Spaces);
   verifyFormat("auto &&[ a, b ] = f();", Spaces);
   verifyFormat("auto &[ a, b ] = f();", Spaces);
   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
   verifyFormat("auto const &[ a, b ] = f();", Spaces);
verifyFormat("namespace {\n"
                Style);
 
   verifyFormat("namespace AAA {\n"
                "int i;\n"
                "int j;\n"
                "} // namespace AAA",
                Style);
 
-  EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
+  verifyFormat("namespace Averyveryveryverylongnamespace {\n"
                "int i;\n"
                "int j;\n"
                "} // namespace Averyveryveryverylongnamespace",
-            format("namespace Averyveryveryverylongnamespace {\n"
-                   "int i;\n"
-                   "int j;\n"
-                   "}",
-                   Style));
+               "namespace Averyveryveryverylongnamespace {\n"
+               Style);
 
-  EXPECT_EQ(
+  verifyFormat(
       "namespace "
       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
       "    went::mad::now {\n"
       "int i;\n"
       "int j;\n"
       "} // namespace\n"
       "  // "
       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
       "went::mad::now",
-      format("namespace "
-             "would::it::save::you::a::lot::of::time::if_::i::"
-             "just::gave::up::and_::went::mad::now {\n"
-             "int i;\n"
-             "int j;\n"
-             "}",
-             Style));
+      "namespace "
+      Style);
 
   // This used to duplicate the comment again and again on subsequent runs
-  EXPECT_EQ(
+  verifyFormat(
       "namespace "
       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
       "    went::mad::now {\n"
       "int i;\n"
       "int j;\n"
       "} // namespace\n"
       "  // "
       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
       "went::mad::now",
-      format("namespace "
-             "would::it::save::you::a::lot::of::time::if_::i::"
-             "just::gave::up::and_::went::mad::now {\n"
-             "int i;\n"
-             "int j;\n"
-             "} // namespace\n"
-             "  // "
-             "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
-             "and_::went::mad::now",
-             Style));
+      "namespace "
+      Style);
 }
 
 TEST_F(FormatTest, LikelyUnlikely) {
   FormatStyle Style = getLLVMStyle();
 
   verifyFormat("if (argc > 5) [[unlikely]] {\n"
                "  return 29;\n"
                "}",