[clang-format][NFC] Clean up unit tests

[owenpan]

Summary

This patch adds a verifyNoChange macro to verify code that won't change after being formatted. (The code will not be messed up before being formatted.) It then replaces EXPECT_EQ with verifyFormat wherever applicable so that the code will be messed up before being formatted. When the replacement fails the unit test, verifyFormat is replaced with verifyNoChange.

[owenpan]

Cleaned up FormatTestJS.cpp as well.

[MyDeveloperDay]

Nice!

[owenpan]

Because FormatTestCSharp.cpp, FormatTestJS.cpp, and FormatTestSelective.cpp don't #include FormatTestBase.h, they can't benefit from verifyNoChange. However, the rest of the unit tests are all free of the repeated arguments in EXPECT_EQ and verifyFormat (as far as my script could identify and replace).

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, LLVMStyleOverride) {
   EXPECT_EQ(FormatStyle::LK_Proto,
             getLLVMStyle(FormatStyle::LK_Proto).Language);
 }
 
 //===----------------------------------------------------------------------===//
 // Basic function tests.
 //===----------------------------------------------------------------------===//
 
-TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
-  EXPECT_EQ(";", format(";"));
-}
+TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) { 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;"));
 }
 

 }
 
 TEST_F(FormatTest, UnderstandsLinePPDirective) {
   EXPECT_EQ("# 123 \"A string literal\"",
             format("   #     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)));
EXPECT_EQ("// somecomment\n"
                    "  #include \"a.h\"\n"
                    "#define A(A,\\\n"
                    "    B)\n"
                    "    #include \"b.h\"\n"
                    " // somecomment\n",
                    getLLVMStyleWithColumns(13)));
 }
 
-TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
+TEST_F(FormatTest, LayoutSingleHash) { verifyFormat("#\na;"); }
 
 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
   EXPECT_EQ("#define A    \\\n"
             "  c;         \\\n"
             "  e;\n"
             "f;",
             format("#define A c; e;\n"
                    "f;",
                    getLLVMStyleWithColumns(14)));
 }
 
-TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
+TEST_F(FormatTest, LayoutRemainingTokens) { verifyFormat("{}"); }
 
 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
   EXPECT_EQ("int x,\n"
             "#define A\n"
             "    y;",
             format("int x,\n#define A\ny;"));
 }
 
 TEST_F(FormatTest, HashInMacroDefinition) {
-  EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
-  EXPECT_EQ("#define A(c) u#c", format("#define A(c) u#c", getLLVMStyle()));
-  EXPECT_EQ("#define A(c) U#c", format("#define A(c) U#c", getLLVMStyle()));
-  EXPECT_EQ("#define A(c) u8#c", format("#define A(c) u8#c", getLLVMStyle()));
-  EXPECT_EQ("#define A(c) LR#c", format("#define A(c) LR#c", getLLVMStyle()));
-  EXPECT_EQ("#define A(c) uR#c", format("#define A(c) uR#c", getLLVMStyle()));
-  EXPECT_EQ("#define A(c) UR#c", format("#define A(c) UR#c", getLLVMStyle()));
-  EXPECT_EQ("#define A(c) u8R#c", format("#define A(c) u8R#c", getLLVMStyle()));
+  verifyFormat("#define A(c) L#c", getLLVMStyle());
+  verifyFormat("#define A(c) u#c", getLLVMStyle());
+  verifyFormat("#define A(c) U#c", getLLVMStyle());
+  verifyFormat("#define A(c) u8#c", getLLVMStyle());
+  verifyFormat("#define A(c) LR#c", getLLVMStyle());
+  verifyFormat("#define A(c) uR#c", getLLVMStyle());
+  verifyFormat("#define A(c) UR#c", getLLVMStyle());
+  verifyFormat("#define A(c) u8R#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)");
+  verifyFormat("#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);
 }
 
EXPECT_EQ("SOME_MACRO\n"
             "void f();\n"
             "} // namespace",
             format("SOME_MACRO\n"
                    "  namespace    {\n"
                    "void   f(  );\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();"));
+  verifyNoChange("MACRO\nf();");
   // Only if everything is upper case.
   EXPECT_EQ("class A : public QObject {\n"
             "  Q_Object A() {}\n"
             "};",
             format("class A  :  public QObject {\n"
                    "     Q_Object\n"
                    "  A() {\n}\n"
                    "}  ;"));
const char *ToFormat = ""
                            "#  define A 0\n"
                            "// Code. Separated by blank line.\n"
                            "\n"
                            "#  define B 0\n"
                            "   // Code. Not aligned with #\n"
                            "#  define C 0\n"
                            "#endif";
     EXPECT_EQ(Expected, format(ToFormat, Style));
-    EXPECT_EQ(Expected, format(Expected, Style));
+    verifyFormat(Expected, Style);
   }
   // Keep block quotes aligned.
   {
     const char *Expected = ""
                            "void f() {\n"
                            "#if 1\n"
                            "/* Preprocessor aligned. */\n"
                            "#  define A 0\n"
const char *ToFormat = ""
                            "#  define A 0\n"
                            "/* Code. Separated by blank line. */\n"
                            "\n"
                            "#  define B 0\n"
                            "   /* Code. Not aligned with # */\n"
                            "#  define C 0\n"
                            "#endif";
     EXPECT_EQ(Expected, format(ToFormat, Style));
-    EXPECT_EQ(Expected, format(Expected, Style));
+    verifyNoChange(Expected, Style);
   }
   // Keep comments aligned with un-indented directives.
   {
     const char *Expected = ""
                            "void f() {\n"
                            "// Preprocessor aligned.\n"
                            "#define A 0\n"
                            "  // Code. Separated by blank line.\n"
                            "\n"
                            "#define B 0\n"
                            "  // Code. Not aligned with #\n"
                            "#define C 0\n";
     const char *ToFormat = ""
                            "void f() {\n"
                            "// Preprocessor aligned.\n"
                            "#define A 0\n"
                            "// Code. Separated by blank line.\n"
                            "\n"
                            "#define B 0\n"
                            "   // Code. Not aligned with #\n"
                            "#define C 0\n";
     EXPECT_EQ(Expected, format(ToFormat, Style));
-    EXPECT_EQ(Expected, format(Expected, Style));
+    verifyFormat(Expected, Style);
   }
   // Test AfterHash with tabs.
   {
     FormatStyle Tabbed = Style;
     Tabbed.UseTab = FormatStyle::UT_Always;
     Tabbed.IndentWidth = 8;
     Tabbed.TabWidth = 8;
     verifyFormat("#ifdef _WIN32\n"
const char *ToFormat = "void f() {\n"
                            "// Aligned to preprocessor.\n"
                            "#define A 0\n"
                            "// Aligned to code.\n"
                            "int b;\n"
                            "#endif\n"
                            "#endif\n"
                            "}";
     EXPECT_EQ(Expected, format(ToFormat, Style));
-    EXPECT_EQ(Expected, format(Expected, Style));
+    verifyFormat(Expected, Style);
   }
   {
     const char *Expected = "void f() {\n"
                            "/* Aligned to preprocessor. */\n"
                            "#if 1\n"
                            "  /* Aligned to code. */\n"
                            "  int a;\n"
                            "  #if 1\n"
const char *ToFormat = "void f() {\n"
                            "/* Aligned to preprocessor. */\n"
                            "#define A 0\n"
                            "/* Aligned to code. */\n"
                            "int b;\n"
                            "#endif\n"
                            "#endif\n"
                            "}";
     EXPECT_EQ(Expected, format(ToFormat, Style));
-    EXPECT_EQ(Expected, format(Expected, Style));
+    verifyNoChange(Expected, Style);
   }
 
   // Test single comment before preprocessor
   verifyFormat("// Comment\n"
                "\n"
                "#if 1\n"
                "#endif",
                Style);

 
 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>"));
+  verifyNoChange("<a\n\\\\\n>");
 
   FormatStyle AlignLeft = getLLVMStyle();
   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
   EXPECT_EQ("#define MACRO(x) \\\n"
             "private:         \\\n"
             "  int x(int a);\n",
             format("#define MACRO(x) \\\n"
                    "private:         \\\n"
                    "  int x(int a);\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>"));
+  verifyNoChange("<a\r\n\\\\\r\n>");
   EXPECT_EQ("#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));
 
EXPECT_EQ("#define A                                       \\\n"
             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
             "  }",
             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
                    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));
   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
TEST_F(FormatTest, FormatsAccessModifiers) {
   verifyFormat("struct foo { /* comment */\n"
                "private:\n"
                "  int i;\n"
                "  // comment\n"
                "\n"
                "private:\n"
                "  int j;\n"
                "};\n",
-               "struct foo { /* comment */\n"
-               "private:\n"
-               "  int i;\n"
-               "  // comment\n"
-               "\n"
-               "private:\n"
-               "  int j;\n"
-               "};\n",
                Style);
   verifyFormat("struct foo {\n"
                "#ifdef FOO\n"
                "#endif\n"
                "\n"
                "private:\n"
                "  int i;\n"
                "#ifdef FOO\n"
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"));
+  verifyNoChange("#error Leave     all         white!!!!! space* alone!\n");
   EXPECT_EQ(
       "#warning Leave     all         white!!!!! space* alone!\n",
       format("#warning Leave     all         white!!!!! space* alone!\n"));
   EXPECT_EQ("#error 1", format("  #  error   1"));
   EXPECT_EQ("#warning 1", format("  #  warning 1"));
 }
 
 TEST_F(FormatTest, FormatHashIfExpressions) {
TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
   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;"));
+  verifyFormat("- (id)Method6:(id)A:(id)B:(id)C:(id)D;");
   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
             "forAllCells:(BOOL)flag;",
             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
                    "forAllCells:(BOOL)flag;"));
 
   // Very long objectiveC method declaration.
   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
EXPECT_EQ(
       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
   EXPECT_EQ(
       "#define A  \\\n"
       "  \"so \"    \\\n"
       "  \"text \"  \\\n"
       "  \"other\";",
       format("#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)));
+  verifyFormat("\"some text\"", getLLVMStyleWithColumns(1));
+  verifyFormat("\"some text\"", getLLVMStyleWithColumns(11));
   EXPECT_EQ("\"some \"\n"
             "\"text\"",
             format("\"some text\"", getLLVMStyleWithColumns(10)));
   EXPECT_EQ("\"some \"\n"
             "\"text\"",
             format("\"some text\"", getLLVMStyleWithColumns(7)));
   EXPECT_EQ("\"some\"\n"
             "\" tex\"\n"
EXPECT_EQ("ffff(\n"
             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
                    getGoogleStyle()));
 
   FormatStyle Style = getLLVMStyleWithColumns(12);
   Style.BreakStringLiterals = false;
-  EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
+  verifyFormat("\"some text other\";", Style);
 
   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
   EXPECT_EQ("#define A \\\n"
             "  \"some \" \\\n"
             "  \"text \" \\\n"
             "  \"other\";",
             format("#define A \"some text other\";", AlignLeft));
TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
   // 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\";", Style);
+  verifyFormat("uR\"x(raw literal)x\";", Style);
+  verifyFormat("LR\"x(raw literal)x\";", Style);
+  verifyFormat("UR\"x(raw literal)x\";", Style);
+  verifyFormat("u8R\"x(raw literal)x\";", Style);
 }
 
 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
   FormatStyle Style = getLLVMStyleWithColumns(20);
   EXPECT_EQ(
       "_T(\"aaaaaaaaaaaaaa\")\n"
       "_T(\"aaaaaaaaaaaaaa\")\n"
       "_T(\"aaaaaaaaaaaa\")",
TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
   EXPECT_EQ("someFunction(\n"
             "    \"aaabbbcc \"\n"
             "    \"dddeeefff\");",
             format("someFunction(\"aaabbbcc dddeeefff\");",
                    getLLVMStyleWithColumns(25)));
 }
 
 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
-  EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
-  EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
+  verifyFormat("\"\\a\"", getLLVMStyleWithColumns(3));
+  verifyFormat("\"\\\"", getLLVMStyleWithColumns(2));
   EXPECT_EQ("\"test\"\n"
             "\"\\n\"",
             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
   EXPECT_EQ("\"tes\\\\\"\n"
             "\"n\"",
             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
   EXPECT_EQ("\"\\\\\\\\\"\n"
             "\"\\n\"",
             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
-  EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
+  verifyFormat("\"\\uff01\"", getLLVMStyleWithColumns(7));
   EXPECT_EQ("\"\\uff01\"\n"
             "\"test\"",
             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
-  EXPECT_EQ("\"\\Uff01ff02\"",
-            format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
+  verifyFormat("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11));
   EXPECT_EQ("\"\\x000000000001\"\n"
             "\"next\"",
             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
-  EXPECT_EQ("\"\\x000000000001next\"",
-            format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
-  EXPECT_EQ("\"\\x000000000001\"",
-            format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
+  verifyFormat("\"\\x000000000001next\"", getLLVMStyleWithColumns(15));
+  verifyFormat("\"\\x000000000001\"", getLLVMStyleWithColumns(7));
   EXPECT_EQ("\"test\"\n"
             "\"\\000000\"\n"
             "\"000001\"",
             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
   EXPECT_EQ("\"test\\000\"\n"
             "\"00000000\"\n"
             "\"1\"",
             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\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)));
 }
 
 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");
+  verifyFormat("\xef\xbb\xbf#include <iostream>");
+  verifyFormat("\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));
EXPECT_EQ("const char *sssss =\n"
             "    \"一二三四五六七八\\\n"
             " 九 十\";",
             format("const char *sssss = \"一二三四五六七八\\\n"
                    " 九 十\";",
                    getLLVMStyleWithColumns(30)));
 }
 
 TEST_F(FormatTest, SplitsUTF8LineComments) {
-  EXPECT_EQ("// aaaaÄ\xc2\x8d",
-            format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
+  verifyFormat("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10));
   EXPECT_EQ("// Я из лесу\n"
             "// вышел; был\n"
             "// сильный\n"
             "// мороз.",
             format("// Я из лесу вышел; был сильный мороз.",
                    getLLVMStyleWithColumns(13)));
   EXPECT_EQ("// 一二三\n"
             "// 四五六七\n"
verifyFormat("auto c = []() {};",
                MergeEmptyOnly);
 
   FormatStyle MergeInline = getLLVMStyle();
   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
   verifyFormat("auto c = []() {\n"
                "  return b;\n"
                "};",
                "auto c = []() { return b; };", MergeInline);
-  verifyFormat("function([]() { return b; })", "function([]() { return b; })",
-               MergeInline);
-  verifyFormat("function([]() { return b; }, a)",
-               "function([]() { return b; }, a)", MergeInline);
-  verifyFormat("function(a, []() { return b; })",
-               "function(a, []() { return b; })", MergeInline);
+  verifyFormat("function([]() { return b; })", MergeInline);
+  verifyFormat("function([]() { return b; }, a)", MergeInline);
+  verifyFormat("function(a, []() { return b; })", MergeInline);
 
   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
   // AllowShortLambdasOnASingleLine
   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
       FormatStyle::ShortLambdaStyle::SLS_None;
std::string code = "#if A\n"
                      "a.\n"
                      "#endif\n"
                      "    a = 1;\n"
                      "#else\n"
                      "#endif\n"
                      "#if C\n"
                      "#else\n"
                      "#endif\n";
-  EXPECT_EQ(code, format(code));
+  verifyFormat(code);
 }
 
 TEST_F(FormatTest, HandleConflictMarkers) {
   // Git/SVN conflict markers.
   EXPECT_EQ("int a;\n"
             "void f() {\n"
             "  callme(some(parameter1,\n"
             "<<<<<<< text by the vcs\n"
TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
   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));
 }
 
 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';");
 }
 
 TEST_F(FormatTest, DoNotFormatLikelyXml) {
-  EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
-  EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
+  verifyFormat("<!-- ;> -->", getGoogleStyle());
+  verifyNoChange(" <!-- >; -->", getGoogleStyle());
 }
 
 TEST_F(FormatTest, StructuredBindings) {
   // Structured bindings is a C++17 feature.
   // all modes, including C++11, C++14 and C++17
   verifyFormat("auto [a, b] = f();");
   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
TEST_F(FormatTest, WhitespaceSensitiveMacros) {
   Style.WhitespaceSensitiveMacros.push_back("FOO");
 
   // Newlines are important here.
   verifyFormat("FOO(1+2 )\n", Style);
   verifyFormat("FOO(a:b:c)\n", Style);
 
   // Don't use the helpers here, since 'mess up' will change the whitespace
   // and these are all whitespace sensitive by definition
-  EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
-            format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
+  verifyFormat("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style);
   EXPECT_EQ(
       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
-  EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
-            format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
+  verifyFormat("FOO(String-ized&Messy+But,: :Still=Intentional);", Style);
   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
             "       Still=Intentional);",
             format("FOO(String-ized&Messy+But,: :\n"
                    "       Still=Intentional);",
                    Style));
   Style.AlignConsecutiveAssignments.Enabled = true;
   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
             "       Still=Intentional);",
             format("FOO(String-ized=&Messy+But,: :\n"
                    "       Still=Intentional);",
                    Style));
 
   Style.ColumnLimit = 21;
-  EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
-            format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
+  verifyFormat("FOO(String-ized&Messy+But: :Still=Intentional);", Style);
 }
 
 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
   // These tests are not in NamespaceEndCommentsFixerTest because that doesn't
   // test its interaction with line wrapping
   FormatStyle Style = getLLVMStyleWithColumns(80);
   verifyFormat("namespace {\n"
                "int i;\n"

 TEST_F(FormatTest, StatementAttributeLikeMacros) {
   FormatStyle Style = getLLVMStyle();
   StringRef Source = "void Foo::slot() {\n"
                      "  unsigned char MyChar = 'x';\n"
                      "  emit signal(MyChar);\n"
                      "  Q_EMIT signal(MyChar);\n"
                      "}";
 
-  EXPECT_EQ(Source, format(Source, Style));
+  verifyFormat(Source, Style);
 
   Style.AlignConsecutiveDeclarations.Enabled = true;
   EXPECT_EQ("void Foo::slot() {\n"
             "  unsigned char MyChar = 'x';\n"
             "  emit          signal(MyChar);\n"
             "  Q_EMIT signal(MyChar);\n"
             "}",
             format(Source, Style));
 
   Style.StatementAttributeLikeMacros.push_back("emit");
-  EXPECT_EQ(Source, format(Source, Style));
+  verifyFormat(Source, Style);
 
   Style.StatementAttributeLikeMacros = {};
   EXPECT_EQ("void Foo::slot() {\n"
             "  unsigned char MyChar = 'x';\n"
             "  emit          signal(MyChar);\n"
             "  Q_EMIT        signal(MyChar);\n"
             "}",
             format(Source, Style));
constexpr StringRef Code =
       "  // This is a line comment (block) with quite some long lines, at "
       "least for the LLVM Style.\n"
       "  // We already did this with multi line comments and strings. Just to "
       "check if everything is working.\n"
       "  const std::string SmallString = \"Hello World\";\n"
       "  // Small line comment\n"
       "  return String.size() > SmallString.size();\n"
       "}";
-  EXPECT_EQ(Code, format(Code, Style));
+  verifyNoChange(Code, Style);
 }
 
 TEST_F(FormatTest, FormatDecayCopy) {
   // error cases from unit tests
   verifyFormat("foo(auto())");
   verifyFormat("foo(auto{})");
   verifyFormat("foo(auto({}))");
   verifyFormat("foo(auto{{}})");
verifyFormat("[[nodiscard]]\n"
                "[[foo([[]])]] [[nodiscard]]\n"
                "int g(int &i) {\n"
                "  i = 0;\n"
                "  return 1;\n"
                "}",
                Code, Style);
 
   Style.BreakAfterAttributes = FormatStyle::ABS_Leave;
-  EXPECT_EQ(Code, format(Code, Style));
+  verifyNoChange(Code, Style);
 }
 
 TEST_F(FormatTest, InsertNewlineAtEOF) {
   FormatStyle Style = getLLVMStyle();
   Style.InsertNewlineAtEOF = true;
 
   verifyFormat("int i;\n", Style);
   verifyFormat("int i;\n", "int i;", Style);
 }
 
 TEST_F(FormatTest, KeepEmptyLinesAtEOF) {
   FormatStyle Style = getLLVMStyle();
   Style.KeepEmptyLinesAtEOF = true;
 
   const StringRef Code{"int i;\n\n"};
-  verifyFormat(Code, Code, Style);
+  verifyNoChange(Code, Style);
   verifyFormat(Code, "int i;\n\n\n", Style);
 }
 
 TEST_F(FormatTest, SpaceAfterUDL) {
   verifyFormat("auto c = (4s).count();");
   verifyFormat("auto x = 5s .count() == 5;");
 }
 

clang/unittests/Format/FormatTestBase.h

protected:
   void
   _verifyIndependentOfContext(const char *File, int Line, llvm::StringRef Text,
                               const std::optional<FormatStyle> &Style = {}) {
     _verifyFormat(File, Line, Text, Style);
     _verifyFormat(File, Line, llvm::Twine("void f() { " + Text + " }").str(),
                   Style);
   }
 
+  void _verifyNoChange(const char *File, int Line, llvm::StringRef Code,
+                       const std::optional<FormatStyle> &Style = {}) {
+    _verifyFormat(File, Line, Code, Code, Style);
+  }
+
   /// \brief Verify that clang-format does not crash on the given input.
   void verifyNoCrash(llvm::StringRef Code,
                      const std::optional<FormatStyle> &Style = {}) {
     format(Code, Style, SC_DoNotCheck);
   }
 
   int ReplacementCount;
 };
 
 #undef DEBUG_TYPE
 
 #define verifyIndependentOfContext(...)                                        \
   _verifyIndependentOfContext(__FILE__, __LINE__, __VA_ARGS__)
 #define verifyIncompleteFormat(...)                                            \
   _verifyIncompleteFormat(__FILE__, __LINE__, __VA_ARGS__)
+#define verifyNoChange(...) _verifyNoChange(__FILE__, __LINE__, __VA_ARGS__)
 #define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__)
 #define verifyGoogleFormat(Code) verifyFormat(Code, getGoogleStyle())
 
 } // namespace test
 } // namespace format
 } // namespace clang
 
 #endif

clang/unittests/Format/FormatTestComments.cpp

EXPECT_EQ(
       "// e f  g\n"
       "// h i j k",
       format("\\\n// a b c d e f  g h i j k", getLLVMStyleWithColumns(10)));
   EXPECT_EQ("if (true) // A comment that\n"
             "          // doesn't fit on\n"
             "          // one line",
             format("if (true) // A comment that doesn't fit on one line   ",
                    getLLVMStyleWithColumns(30)));
-  EXPECT_EQ("//    Don't_touch_leading_whitespace",
-            format("//    Don't_touch_leading_whitespace",
-                   getLLVMStyleWithColumns(20)));
+  verifyNoChange("//    Don't_touch_leading_whitespace",
+                 getLLVMStyleWithColumns(20));
   EXPECT_EQ("// Add leading\n"
             "// whitespace",
             format("//Add leading whitespace", getLLVMStyleWithColumns(20)));
   EXPECT_EQ("/// Add leading\n"
             "/// whitespace",
             format("///Add leading whitespace", getLLVMStyleWithColumns(20)));
   EXPECT_EQ("//! Add leading\n"
             "//! whitespace",
             format("//!Add leading whitespace", getLLVMStyleWithColumns(20)));
   EXPECT_EQ("// whitespace", format("//whitespace", getLLVMStyle()));
   EXPECT_EQ("// Even if it makes the line exceed the column\n"
             "// limit",
             format("//Even if it makes the line exceed the column limit",
                    getLLVMStyleWithColumns(51)));
-  EXPECT_EQ("//--But not here", format("//--But not here", getLLVMStyle()));
+  verifyFormat("//--But not here", getLLVMStyle());
   EXPECT_EQ("/// line 1\n"
             "// add leading whitespace",
             format("/// line 1\n"
                    "//add leading whitespace",
                    getLLVMStyleWithColumns(30)));
   EXPECT_EQ("/// line 1\n"
             "/// line 2\n"
             "//! line 3\n"
EXPECT_EQ("void ffffff(\n"
             "    int bbbbbbbbbb, // xxxxxxx\n"
             "                    // yyyyyyyyyy\n"
             "    int c, int d, int e) {}",
             format("void ffffff(\n"
                    "    int aaaaaaaaa, // wwww\n"
                    "    int bbbbbbbbbb, // xxxxxxx yyyyyyyyyy\n"
                    "    int c, int d, int e) {}",
                    getLLVMStyleWithColumns(40)));
-  EXPECT_EQ("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-            format("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-                   getLLVMStyleWithColumns(20)));
+  verifyFormat("//\t aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+               getLLVMStyleWithColumns(20));
   EXPECT_EQ(
       "#define XXX // a b c d\n"
       "            // e f g h",
       format("#define XXX // a b c d e f g h", getLLVMStyleWithColumns(22)));
   EXPECT_EQ(
       "#define XXX // q w e r\n"
       "            // t y u i",
       format("#define XXX //q w e r t y u i", getLLVMStyleWithColumns(22)));
EXPECT_EQ("int f(int i) {\n"
                    "  }\n"
                    "}"));
 
   const StringRef Code("void func() {\n"
                        "  // clang-format off\n"
                        "  #define KV(value) #value, value\n"
                        "  // clang-format on\n"
                        "}");
-  EXPECT_EQ(Code, format(Code));
+  verifyNoChange(Code);
 }
 
 TEST_F(FormatTestComments, SplitsLongLinesInComments) {
   // FIXME: Do we need to fix up the "  */" at the end?
   // It doesn't look like any of our current logic triggers this.
   EXPECT_EQ("/* This is a long\n"
             " * comment that\n"
             " * doesn't fit on\n"
EXPECT_EQ("/**\n"
             format("/**\n"
                    " * multiline block comment\n"
                    " *\n"
                    " */",
                    getLLVMStyleWithColumns(20)));
 
   // This reproduces a crashing bug where both adaptStartOfLine and
   // getCommentSplit were trying to wrap after the "/**".
-  EXPECT_EQ("/** multilineblockcommentwithnowrapopportunity */",
-            format("/** multilineblockcommentwithnowrapopportunity */",
-                   getLLVMStyleWithColumns(20)));
+  verifyFormat("/** multilineblockcommentwithnowrapopportunity */",
+               getLLVMStyleWithColumns(20));
 
   EXPECT_EQ("/*\n"
             "\n"
             "\n"
             "    */\n",
             format("  /*       \n"
                    "      \n"
                    "               \n"
EXPECT_EQ("// long long long\n"
                    getLLVMStyleWithColumns(20)));
 
   // Shrink the first line, then reflow the second line up.
   EXPECT_EQ("// long long long", format("// long              long\n"
                                         "// long",
                                         getLLVMStyleWithColumns(20)));
 
   // Don't shrink leading whitespace.
-  EXPECT_EQ("int i; ///           a",
-            format("int i; ///           a", getLLVMStyleWithColumns(20)));
+  verifyNoChange("int i; ///           a", getLLVMStyleWithColumns(20));
 
   // Shrink trailing whitespace if there is no postfix and reflow.
   EXPECT_EQ("// long long long\n"
             "// long long",
             format("// long long long long    \n"
                    "// long",
                    getLLVMStyleWithColumns(20)));
 
EXPECT_EQ("#define A /*123*/ \\\n"
                    getLLVMStyleWithColumns(15)));
 
   EXPECT_EQ("#define A\n"
             "/* */ someCall(\n"
             "    parameter);",
             format("#define A\n"
                    "/* */someCall(parameter);",
                    getLLVMStyleWithColumns(15)));
-  EXPECT_EQ("/*\n**\n*/", format("/*\n**\n*/"));
+  verifyNoChange("/*\n**\n*/");
   EXPECT_EQ("/*\n"
             " *\n"
             " * aaaaaa\n"
             " * aaaaaa\n"
             " */",
             format("/*\n"
                    "*\n"
                    " * aaaaaa aaaaaa\n"
TEST_F(FormatTestComments, SpaceAtLineCommentBegin) {
   EXPECT_EQ("//\n"
             "\n"
             "void foo() { //\n"
             "  //\n"
             "}",
             format(NoTextInComment, Style));
 
   Style.SpacesInLineCommentPrefix.Minimum = 0;
-  EXPECT_EQ("//#comment", format("//#comment", Style));
+  verifyFormat("//#comment", Style);
   EXPECT_EQ("//\n"
             "\n"
             "void foo() { //\n"
             "  //\n"
             "}",
             format(NoTextInComment, Style));
 
   Style.SpacesInLineCommentPrefix.Minimum = 5;

clang/unittests/Format/FormatTestJS.cpp

TEST_F(FormatTestJS, JSDocComments) {
   // Break a short first line if the ending '*/' is on a newline.
   EXPECT_EQ("/**\n"
             " * jsdoc line 1\n"
             " */",
             format("/** jsdoc line 1\n"
                    " */",
                    getGoogleJSStyleWithColumns(20)));
   // Don't break the first line of a short single line jsdoc comment.
-  EXPECT_EQ("/** jsdoc line 1 */",
-            format("/** jsdoc line 1 */", getGoogleJSStyleWithColumns(20)));
+  verifyFormat("/** jsdoc line 1 */", getGoogleJSStyleWithColumns(20));
   // Don't break the first line of a single line jsdoc comment if it just fits
   // the column limit.
-  EXPECT_EQ("/** jsdoc line 12 */",
-            format("/** jsdoc line 12 */", getGoogleJSStyleWithColumns(20)));
+  verifyFormat("/** jsdoc line 12 */", getGoogleJSStyleWithColumns(20));
   // Don't break after '/**' and before '*/' if there is no space between
   // '/**' and the content.
   EXPECT_EQ(
       "/*** nonjsdoc long\n"
       " * line */",
       format("/*** nonjsdoc long line */", getGoogleJSStyleWithColumns(20)));
   EXPECT_EQ(
       "/**strange long long\n"
EXPECT_EQ("function f() {\n"
             "}",
             format("function f() {\n"
                    "/** comment about x */\n"
                    "var x = 1;\n"
                    "}",
                    getGoogleJSStyleWithColumns(20)));
 
   // Don't break the first line of a single line short jsdoc comment pragma.
-  EXPECT_EQ("/** @returns j */",
-            format("/** @returns j */", getGoogleJSStyleWithColumns(20)));
+  verifyFormat("/** @returns j */", getGoogleJSStyleWithColumns(20));
 
   // Break a single line long jsdoc comment pragma.
   EXPECT_EQ("/**\n"
             " * @returns {string}\n"
             " *     jsdoc line 12\n"
             " */",
             format("/** @returns {string} jsdoc line 12 */",
                    getGoogleJSStyleWithColumns(20)));

clang/unittests/Format/FormatTestJava.cpp

TEST_F(FormatTestJava, FormatsLambdas) {
   verifyFormat("Runnable someLambda =\n"
                "    (int aaaaa) -> DoSomething(aaaaa);",
                getStyleWithColumns(40));
 }
 
 TEST_F(FormatTestJava, BreaksStringLiterals) {
   // FIXME: String literal breaking is currently disabled for Java and JS, as it
   // requires strings to be merged using "+" which we don't support.
-  EXPECT_EQ("\"some text other\";",
-            format("\"some text other\";", getStyleWithColumns(14)));
+  verifyFormat("\"some text other\";", getStyleWithColumns(14));
 }
 
 TEST_F(FormatTestJava, AlignsBlockComments) {
   EXPECT_EQ("/*\n"
             " * Really multi-line\n"
             " * comment.\n"
             " */\n"
             "void f() {}",

clang/unittests/Format/QualifierFixerTest.cpp

 }
 
 TEST_F(QualifierFixerTest, QualifiersCustomOrder) {
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Left;
   Style.QualifierOrder = {"friend", "inline",   "constexpr", "static",
                           "const",  "volatile", "type"};
 
-  verifyFormat("const volatile int a;", "const volatile int a;", Style);
+  verifyFormat("const volatile int a;", Style);
   verifyFormat("const volatile int a;", "volatile const int a;", Style);
   verifyFormat("const volatile int a;", "int const volatile a;", Style);
   verifyFormat("const volatile int a;", "int volatile const a;", Style);
   verifyFormat("const volatile int a;", "const int volatile a;", Style);
 
   verifyFormat("static const volatile int a;", "const static int volatile a;",
                Style);
   verifyFormat("inline static const volatile int a;",
verifyFormat(
       "template <typename Func> explicit Action(Action<Func> const &action);",
       "template <typename Func>\nexplicit Action(const Action<Func>& action);",
       Style);
 
   verifyFormat("int const a;", "const int a;", Style);
   verifyFormat("int const *a;", "const int *a;", Style);
   verifyFormat("int const &a;", "const int &a;", Style);
   verifyFormat("foo(int const &a)", "foo(const int &a)", Style);
-  verifyFormat("unsigned char *a;", "unsigned char *a;", Style);
+  verifyFormat("unsigned char *a;", Style);
   verifyFormat("unsigned char const *a;", "const unsigned char *a;", Style);
   verifyFormat("vector<int, int const, int &, int const &> args1",
                "vector<int, const int, int &, const int &> args1", Style);
   verifyFormat("unsigned int const &get_nu() const",
                "const unsigned int &get_nu() const", Style);
   verifyFormat("Foo<int> const &a", "const Foo<int> &a", Style);
   verifyFormat("Foo<int>::iterator const &a", "const Foo<int>::iterator &a",
                Style);
TEST_F(QualifierFixerTest, RightQualifier) {
   verifyFormat("long long int const volatile;", "long long volatile int const;",
                Style);
   verifyFormat("long long int const volatile;", "long volatile long const int;",
                Style);
   verifyFormat("long long int const volatile;", "const long long volatile int;",
                Style);
 
   verifyFormat("static int const bat;", "static const int bat;", Style);
-  verifyFormat("static int const bat;", "static int const bat;", Style);
+  verifyFormat("static int const bat;", Style);
 
   // static is not configured, unchanged on the left of the right hand
   // qualifiers.
   verifyFormat("int static const volatile;", "volatile const int static;",
                Style);
   verifyFormat("int static const volatile;", "const volatile int static;",
                Style);
   verifyFormat("int static const volatile;", "const int volatile static;",
                Style);
   verifyFormat("Foo static const volatile;", "volatile const Foo static;",
                Style);
   verifyFormat("Foo static const volatile;", "const volatile Foo static;",
                Style);
   verifyFormat("Foo static const volatile;", "const Foo volatile static;",
                Style);
 
   verifyFormat("Foo inline static const;", "const Foo inline static;", Style);
   verifyFormat("Foo inline static const;", "Foo const inline static;", Style);
   verifyFormat("Foo inline static const;", "Foo inline const static;", Style);
-  verifyFormat("Foo inline static const;", "Foo inline static const;", Style);
+  verifyFormat("Foo inline static const;", Style);
 
   verifyFormat("Foo<T volatile>::Bar<Type const, 5> const volatile A::*;",
                "volatile const Foo<volatile T>::Bar<const Type, 5> A::*;",
                Style);
 
   verifyFormat("int const Foo<int>::bat = 0;", "const int Foo<int>::bat = 0;",
                Style);
-  verifyFormat("int const Foo<int>::bat = 0;", "int const Foo<int>::bat = 0;",
-               Style);
+  verifyFormat("int const Foo<int>::bat = 0;", Style);
   verifyFormat("void fn(Foo<T> const &i);", "void fn(const Foo<T> &i);", Style);
-  verifyFormat("int const Foo<int>::fn() {", "int const Foo<int>::fn() {",
-               Style);
+  verifyFormat("int const Foo<int>::fn() {", Style);
   verifyFormat("Foo<Foo<int>> const *p;", "const Foo<Foo<int>> *p;", Style);
   verifyFormat(
       "Foo<Foo<int>> const *p = const_cast<Foo<Foo<int>> const *>(&ffi);",
       "const Foo<Foo<int>> *p = const_cast<const Foo<Foo<int>> *>(&ffi);",
       Style);
 
   verifyFormat("void fn(Foo<T> const &i);", "void fn(const Foo<T> &i);", Style);
   verifyFormat("void fns(ns::S const &s);", "void fns(const ns::S &s);", Style);
TEST_F(QualifierFixerTest, RightQualifier) {
   // Variable declaration based on template type.
   verifyFormat("Bar<std::Foo const> bar", "Bar<const std::Foo> bar", Style);
 
   // Using typename for a nested dependent type name.
   verifyFormat("typename Foo::iterator const;", "const typename Foo::iterator;",
                Style);
 
   // Don't move past C-style struct/class.
-  verifyFormat("void foo(const struct A a);", "void foo(const struct A a);",
-               Style);
-  verifyFormat("void foo(const class A a);", "void foo(const class A a);",
-               Style);
+  verifyFormat("void foo(const struct A a);", Style);
+  verifyFormat("void foo(const class A a);", Style);
 
   // Don't move past struct/class combined declaration and variable
   // definition.
-  verifyFormat("const struct {\n} var;", "const struct {\n} var;", Style);
-  verifyFormat("struct {\n} const var;", "struct {\n} const var;", Style);
-  verifyFormat("const class {\n} var;", "const class {\n} var;", Style);
-  verifyFormat("class {\n} const var;", "class {\n} const var;", Style);
+  verifyFormat("const struct {\n} var;", Style);
+  verifyFormat("struct {\n} const var;", Style);
+  verifyFormat("const class {\n} var;", Style);
+  verifyFormat("class {\n} const var;", Style);
 
   // Leave left qualifers unchanged for combined declaration and variable
   // definition.
-  verifyFormat("volatile const class {\n} var;",
-               "volatile const class {\n} var;", Style);
-  verifyFormat("const volatile class {\n} var;",
-               "const volatile class {\n} var;", Style);
+  verifyFormat("volatile const class {\n} var;", Style);
+  verifyFormat("const volatile class {\n} var;", Style);
   // Also do no sorting with respect to not-configured tokens.
-  verifyFormat("const static volatile class {\n} var;",
-               "const static volatile class {\n} var;", Style);
+  verifyFormat("const static volatile class {\n} var;", Style);
   // Sort right qualifiers for combined declaration and variable definition.
-  verifyFormat("class {\n} const volatile var;",
-               "class {\n} const volatile var;", Style);
+  verifyFormat("class {\n} const volatile var;", Style);
   verifyFormat("class {\n} const volatile var;",
                "class {\n} volatile const var;", Style);
   // Static keyword is not configured, should end up on the left of the right
   // side.
-  verifyFormat("class {\n} static const volatile var;",
-               "class {\n} static const volatile var;", Style);
+  verifyFormat("class {\n} static const volatile var;", Style);
   verifyFormat("class {\n} static const volatile var;",
                "class {\n} volatile static const var;", Style);
 
   // ::template for dependent names
   verifyFormat("::template Foo<T> const volatile var;",
                "const volatile ::template Foo<T> var;", Style);
   verifyFormat("typename ::template Foo<T> const volatile var;",
                "const volatile typename ::template Foo<T> var;", Style);
TEST_F(QualifierFixerTest, RightQualifier) {
   verifyFormat("foo<Bar<Baz> const>();", "foo<const Bar<Baz>>();", Style);
   verifyFormat("foo<Bar<Baz> const>();", "foo<const Bar<Baz> >();", Style);
   verifyFormat("Bar<32, Foo<25> const>;", "Bar<32, const Foo<25>>;", Style);
   verifyFormat("A<B<C<D> const> const>;", "A<const B<const C<D>>>;", Style);
   verifyFormat("A<B<C<D const> const> const>;", "A<const B<const C<const D>>>;",
                Style);
 
   // Don't move past decltype, typeof, or _Atomic.
-  verifyFormat("const decltype(foo)", "const decltype(foo)", Style);
-  verifyFormat("const typeof(foo)", "const typeof(foo)", Style);
-  verifyFormat("const _Atomic(foo)", "const _Atomic(foo)", Style);
+  verifyFormat("const decltype(foo)", Style);
+  verifyFormat("const typeof(foo)", Style);
+  verifyFormat("const _Atomic(foo)", Style);
 
   // Comments
   const int ColumnLimit = Style.ColumnLimit;
   Style.ColumnLimit = 200;
   verifyFormat("/*c*/ Foo const *foo;", "const /*c*/ Foo *foo;", Style);
   verifyFormat("Foo const /*c*/ *foo;", "const Foo /*c*/ *foo;", Style);
   verifyFormat("Foo const * /*c*/ foo;", "const Foo * /*c*/ foo;", Style);
 
verifyFormat("/*c*/ /*c*/ typename /*c*/ C /*c*/<T> /*c*/ ::/*c*/ template "
                Style);
 
   verifyFormat("/*c*/ unsigned /*c*/ long const /*c*/ a;",
                "const /*c*/ unsigned /*c*/ long /*c*/ a;", Style);
   verifyFormat("unsigned /*c*/ long /*c*/ long const a;",
                "const unsigned /*c*/ long /*c*/ long a;", Style);
 
   // Not changed
-  verifyFormat("foo() /*c*/ const", "foo() /*c*/ const", Style);
-  verifyFormat("const /*c*/ struct a;", "const /*c*/ struct a;", Style);
-  verifyFormat("const /*c*/ class a;", "const /*c*/ class a;", Style);
-  verifyFormat("const /*c*/ decltype(v) a;", "const /*c*/ decltype(v) a;",
-               Style);
-  verifyFormat("const /*c*/ typeof(v) a;", "const /*c*/ typeof(v) a;", Style);
-  verifyFormat("const /*c*/ _Atomic(v) a;", "const /*c*/ _Atomic(v) a;", Style);
-  verifyFormat("const decltype /*c*/ (v) a;", "const decltype /*c*/ (v) a;",
-               Style);
-  verifyFormat("const /*c*/ class {\n} volatile /*c*/ foo = {};",
-               "const /*c*/ class {\n} volatile /*c*/ foo = {};", Style);
+  verifyFormat("foo() /*c*/ const", Style);
+  verifyFormat("const /*c*/ struct a;", Style);
+  verifyFormat("const /*c*/ class a;", Style);
+  verifyFormat("const /*c*/ decltype(v) a;", Style);
+  verifyFormat("const /*c*/ typeof(v) a;", Style);
+  verifyFormat("const /*c*/ _Atomic(v) a;", Style);
+  verifyFormat("const decltype /*c*/ (v) a;", Style);
+  verifyFormat("const /*c*/ class {\n} volatile /*c*/ foo = {};", Style);
 
   Style.ColumnLimit = ColumnLimit;
 
   // Don't adjust macros
-  verifyFormat("const INTPTR a;", "const INTPTR a;", Style);
+  verifyFormat("const INTPTR a;", Style);
 
   // Pointers to members
   verifyFormat("int S::*a;", Style);
   verifyFormat("int const S::*a;", "const int S:: *a;", Style);
   verifyFormat("int const S::*const a;", "const int S::* const a;", Style);
   verifyFormat("int A::*const A::*p1;", Style);
   verifyFormat("float (C::*p)(int);", Style);
   verifyFormat("float (C::*const p)(int);", Style);
verifyFormat("const Foo<int>::iterator &a", "Foo<int>::iterator const &a",
                Style);
   verifyFormat("const ::Foo<int>::iterator &a", "::Foo<int>::iterator const &a",
                Style);
 
   verifyFormat("const int a;", "int const a;", Style);
   verifyFormat("const int *a;", "int const *a;", Style);
   verifyFormat("const int &a;", "int const &a;", Style);
   verifyFormat("foo(const int &a)", "foo(int const &a)", Style);
-  verifyFormat("unsigned char *a;", "unsigned char *a;", Style);
+  verifyFormat("unsigned char *a;", Style);
   verifyFormat("const unsigned int &get_nu() const",
                "unsigned int const &get_nu() const", Style);
 
   verifyFormat("const volatile int;", "volatile const int;", Style);
-  verifyFormat("const volatile int;", "const volatile int;", Style);
+  verifyFormat("const volatile int;", Style);
   verifyFormat("const volatile int;", "const int volatile;", Style);
 
   verifyFormat("const volatile int *restrict;", "volatile const int *restrict;",
                Style);
-  verifyFormat("const volatile int *restrict;", "const volatile int *restrict;",
-               Style);
+  verifyFormat("const volatile int *restrict;", Style);
   verifyFormat("const volatile int *restrict;", "const int volatile *restrict;",
                Style);
 
   verifyFormat("const volatile long long int;", "volatile long long int const;",
                Style);
   verifyFormat("const volatile long long int;", "volatile long long const int;",
                Style);
   verifyFormat("const volatile long long int;", "long long volatile int const;",
TEST_F(QualifierFixerTest, LeftQualifier) {
   verifyFormat(
       "template <typename Func> explicit Action(const Action<Func> &action);",
       Style);
   verifyFormat(
       "template <typename Func> explicit Action(const Action<Func> &action);",
       "template <typename Func> explicit Action(Action<Func> const &action);",
       Style);
 
-  verifyFormat("static const int bat;", "static const int bat;", Style);
+  verifyFormat("static const int bat;", Style);
   verifyFormat("static const int bat;", "static int const bat;", Style);
 
-  verifyFormat("static const int Foo<int>::bat = 0;",
-               "static const int Foo<int>::bat = 0;", Style);
+  verifyFormat("static const int Foo<int>::bat = 0;", Style);
   verifyFormat("static const int Foo<int>::bat = 0;",
                "static int const Foo<int>::bat = 0;", Style);
 
   verifyFormat("void fn(const Foo<T> &i);");
 
-  verifyFormat("const int Foo<int>::bat = 0;", "const int Foo<int>::bat = 0;",
-               Style);
+  verifyFormat("const int Foo<int>::bat = 0;", Style);
   verifyFormat("const int Foo<int>::bat = 0;", "int const Foo<int>::bat = 0;",
                Style);
   verifyFormat("void fn(const Foo<T> &i);", "void fn( Foo<T> const &i);",
                Style);
   verifyFormat("const int Foo<int>::fn() {", "int const Foo<int>::fn() {",
                Style);
   verifyFormat("const Foo<Foo<int>> *p;", "Foo<Foo<int>> const *p;", Style);
   verifyFormat(
TEST_F(QualifierFixerTest, LeftQualifier) {
 
   verifyFormat("const unsigned long a;", "unsigned long const a;", Style);
   verifyFormat("const unsigned long long a;", "unsigned long long const a;",
                Style);
 
   verifyFormat("const long long unsigned a;", "long const long unsigned a;",
                Style);
 
-  verifyFormat("const std::Foo", "const std::Foo", Style);
-  verifyFormat("const std::Foo<>", "const std::Foo<>", Style);
+  verifyFormat("const std::Foo", Style);
+  verifyFormat("const std::Foo<>", Style);
   verifyFormat("const std::Foo < int", "const std::Foo<int", Style);
-  verifyFormat("const std::Foo<int>", "const std::Foo<int>", Style);
+  verifyFormat("const std::Foo<int>", Style);
 
   // Multiple template parameters.
   verifyFormat("Bar<const std::Foo, 32>;", "Bar<std::Foo const, 32>;", Style);
 
   // Variable declaration based on template type.
   verifyFormat("Bar<const std::Foo> bar;", "Bar<std::Foo const> bar;", Style);
 
   // Using typename for a dependent name.
   verifyFormat("const typename Foo::iterator;", "typename Foo::iterator const;",
                Style);
 
   // Don't move past C-style struct/class.
-  verifyFormat("void foo(struct A const a);", "void foo(struct A const a);",
-               Style);
-  verifyFormat("void foo(class A const a);", "void foo(class A const a);",
-               Style);
+  verifyFormat("void foo(struct A const a);", Style);
+  verifyFormat("void foo(class A const a);", Style);
 
   // Don't move past struct/class combined declaration and variable
   // definition.
-  verifyFormat("const struct {\n} var;", "const struct {\n} var;", Style);
-  verifyFormat("struct {\n} const var;", "struct {\n} const var;", Style);
-  verifyFormat("const class {\n} var;", "const class {\n} var;", Style);
-  verifyFormat("class {\n} const var;", "class {\n} const var;", Style);
+  verifyFormat("const struct {\n} var;", Style);
+  verifyFormat("struct {\n} const var;", Style);
+  verifyFormat("const class {\n} var;", Style);
+  verifyFormat("class {\n} const var;", Style);
 
   // Sort left qualifiers for struct/class combined declaration and variable
   // definition.
-  verifyFormat("const volatile class {\n} var;",
-               "const volatile class {\n} var;", Style);
+  verifyFormat("const volatile class {\n} var;", Style);
   verifyFormat("const volatile class {\n} var;",
                "volatile const class {\n} var;", Style);
   // Leave right qualifers unchanged for struct/class combined declaration and
   // variable definition.
-  verifyFormat("class {\n} const volatile var;",
-               "class {\n} const volatile var;", Style);
-  verifyFormat("class {\n} volatile const var;",
-               "class {\n} volatile const var;", Style);
+  verifyFormat("class {\n} const volatile var;", Style);
+  verifyFormat("class {\n} volatile const var;", Style);
 
   verifyFormat("foo<const Bar<Baz<T>>>();", "foo<Bar<Baz<T>> const>();", Style);
   verifyFormat("foo<const Bar<Baz<T>>>();", "foo<Bar<Baz<T> > const>();",
                Style);
   verifyFormat("Bar<32, const Foo<25>>;", "Bar<32, Foo<25> const>;", Style);
   verifyFormat("A<const B<const C<D>>>;", "A<B<C<D> const> const>;", Style);
   verifyFormat("A<const B<const C<const D>>>;", "A<B<C<D const> const> const>;",
                Style);
 
   // Don't move past decltype, typeof, or _Atomic.
-  verifyFormat("decltype(foo) const", "decltype(foo) const", Style);
-  verifyFormat("typeof(foo) const", "typeof(foo) const", Style);
-  verifyFormat("_Atomic(foo) const", "_Atomic(foo) const", Style);
+  verifyFormat("decltype(foo) const", Style);
+  verifyFormat("typeof(foo) const", Style);
+  verifyFormat("_Atomic(foo) const", Style);
 
   // ::template for dependent names
   verifyFormat("const volatile ::template Foo<T> var;",
                "::template Foo<T> const volatile var;", Style);
   verifyFormat("const volatile typename ::template Foo<T> var;",
                "typename ::template Foo<T> const volatile var;", Style);
   verifyFormat("const typename Bar::template Foo<T>::T;",
                "typename Bar::template Foo<T>::T const;", Style);
verifyFormat("/*c*/ const typename /*c*/ C /*c*/<T> /*c*/ ::/*c*/ template "
                Style);
 
   verifyFormat("const unsigned /*c*/ long /*c*/ a;",
                "unsigned /*c*/ long /*c*/ const a;", Style);
   verifyFormat("const unsigned /*c*/ long /*c*/ long a;",
                "unsigned /*c*/ long /*c*/ long const a;", Style);
 
   // Not changed
-  verifyFormat("foo() /*c*/ const", "foo() /*c*/ const", Style);
-  verifyFormat("struct /*c*/ const a;", "struct /*c*/ const a;", Style);
-  verifyFormat("class /*c*/ const a;", "class /*c*/ const a;", Style);
-  verifyFormat("decltype(v) /*c*/ const a;", "decltype(v) /*c*/ const a;",
-               Style);
-  verifyFormat("typeof(v) /*c*/ const a;", "typeof(v) /*c*/ const a;", Style);
-  verifyFormat("_Atomic(v) /*c*/ const a;", "_Atomic(v) /*c*/ const a;", Style);
-  verifyFormat("decltype /*c*/ (v) const a;", "decltype /*c*/ (v) const a;",
-               Style);
-  verifyFormat("const /*c*/ class {\n} /*c*/ volatile /*c*/ foo = {};",
-               "const /*c*/ class {\n} /*c*/ volatile /*c*/ foo = {};", Style);
+  verifyFormat("foo() /*c*/ const", Style);
+  verifyFormat("struct /*c*/ const a;", Style);
+  verifyFormat("class /*c*/ const a;", Style);
+  verifyFormat("decltype(v) /*c*/ const a;", Style);
+  verifyFormat("typeof(v) /*c*/ const a;", Style);
+  verifyFormat("_Atomic(v) /*c*/ const a;", Style);
+  verifyFormat("decltype /*c*/ (v) const a;", Style);
+  verifyFormat("const /*c*/ class {\n} /*c*/ volatile /*c*/ foo = {};", Style);
 
   Style.ColumnLimit = ColumnLimit;
 
   // Don't adjust macros
-  verifyFormat("INTPTR const a;", "INTPTR const a;", Style);
+  verifyFormat("INTPTR const a;", Style);
 
   // Pointers to members
   verifyFormat("int S::*a;", Style);
   verifyFormat("const int S::*a;", "int const S:: *a;", Style);
   verifyFormat("const int S::*const a;", "int const S::* const a;", Style);
   verifyFormat("int A::*const A::*p1;", Style);
   verifyFormat("float (C::*p)(int);", Style);
   verifyFormat("float (C::*const p)(int);", Style);
   verifyFormat("float (C::*p)(int) const;", Style);
   verifyFormat("const float (C::*p)(int);", "float const (C::*p)(int);", Style);
 }
 
 TEST_F(QualifierFixerTest, ConstVolatileQualifiersOrder) {
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Left;
   Style.QualifierOrder = {"inline", "static", "const", "volatile", "type"};
 
   // The Default
   EXPECT_EQ(Style.QualifierOrder.size(), (size_t)5);
 
-  verifyFormat("const volatile int a;", "const volatile int a;", Style);
+  verifyFormat("const volatile int a;", Style);
   verifyFormat("const volatile int a;", "volatile const int a;", Style);
   verifyFormat("const volatile int a;", "int const volatile a;", Style);
   verifyFormat("const volatile int a;", "int volatile const a;", Style);
   verifyFormat("const volatile int a;", "const int volatile a;", Style);
 
-  verifyFormat("const volatile Foo a;", "const volatile Foo a;", Style);
+  verifyFormat("const volatile Foo a;", Style);
   verifyFormat("const volatile Foo a;", "volatile const Foo a;", Style);
   verifyFormat("const volatile Foo a;", "Foo const volatile a;", Style);
   verifyFormat("const volatile Foo a;", "Foo volatile const a;", Style);
   verifyFormat("const volatile Foo a;", "const Foo volatile a;", Style);
 
   Style.QualifierAlignment = FormatStyle::QAS_Right;
   Style.QualifierOrder = {"type", "const", "volatile"};
 
   verifyFormat("int const volatile a;", "const volatile int a;", Style);
   verifyFormat("int const volatile a;", "volatile const int a;", Style);
-  verifyFormat("int const volatile a;", "int const volatile a;", Style);
+  verifyFormat("int const volatile a;", Style);
   verifyFormat("int const volatile a;", "int volatile const a;", Style);
   verifyFormat("int const volatile a;", "const int volatile a;", Style);
 
   verifyFormat("Foo const volatile a;", "const volatile Foo a;", Style);
   verifyFormat("Foo const volatile a;", "volatile const Foo a;", Style);
-  verifyFormat("Foo const volatile a;", "Foo const volatile a;", Style);
+  verifyFormat("Foo const volatile a;", Style);
   verifyFormat("Foo const volatile a;", "Foo volatile const a;", Style);
   verifyFormat("Foo const volatile a;", "const Foo volatile a;", Style);
 
   Style.QualifierAlignment = FormatStyle::QAS_Left;
   Style.QualifierOrder = {"volatile", "const", "type"};
 
   verifyFormat("volatile const int a;", "const volatile int a;", Style);
-  verifyFormat("volatile const int a;", "volatile const int a;", Style);
+  verifyFormat("volatile const int a;", Style);
   verifyFormat("volatile const int a;", "int const volatile a;", Style);
   verifyFormat("volatile const int a;", "int volatile const a;", Style);
   verifyFormat("volatile const int a;", "const int volatile a;", Style);
 
   verifyFormat("volatile const Foo a;", "const volatile Foo a;", Style);
-  verifyFormat("volatile const Foo a;", "volatile const Foo a;", Style);
+  verifyFormat("volatile const Foo a;", Style);
   verifyFormat("volatile const Foo a;", "Foo const volatile a;", Style);
   verifyFormat("volatile const Foo a;", "Foo volatile const a;", Style);
   verifyFormat("volatile const Foo a;", "const Foo volatile a;", Style);
 
   Style.QualifierAlignment = FormatStyle::QAS_Right;
   Style.QualifierOrder = {"type", "volatile", "const"};
 
   verifyFormat("int volatile const a;", "const volatile int a;", Style);
   verifyFormat("int volatile const a;", "volatile const int a;", Style);
   verifyFormat("int volatile const a;", "int const volatile a;", Style);
-  verifyFormat("int volatile const a;", "int volatile const a;", Style);
+  verifyFormat("int volatile const a;", Style);
   verifyFormat("int volatile const a;", "const int volatile a;", Style);
 
   verifyFormat("Foo volatile const a;", "const volatile Foo a;", Style);
   verifyFormat("Foo volatile const a;", "volatile const Foo a;", Style);
   verifyFormat("Foo volatile const a;", "Foo const volatile a;", Style);
-  verifyFormat("Foo volatile const a;", "Foo volatile const a;", Style);
+  verifyFormat("Foo volatile const a;", Style);
   verifyFormat("Foo volatile const a;", "const Foo volatile a;", Style);
 
   Style.QualifierAlignment = FormatStyle::QAS_Custom;
   Style.QualifierOrder = {"type", "volatile", "const"};
 
   verifyFormat("int volatile const a;", "const volatile int a;", Style);
   verifyFormat("int volatile const a;", "volatile const int a;", Style);
   verifyFormat("int volatile const a;", "int const volatile a;", Style);
-  verifyFormat("int volatile const a;", "int volatile const a;", Style);
+  verifyFormat("int volatile const a;", Style);
   verifyFormat("int volatile const a;", "const int volatile a;", Style);
 
   verifyFormat("Foo volatile const a;", "const volatile Foo a;", Style);
   verifyFormat("Foo volatile const a;", "volatile const Foo a;", Style);
   verifyFormat("Foo volatile const a;", "Foo const volatile a;", Style);
-  verifyFormat("Foo volatile const a;", "Foo volatile const a;", Style);
+  verifyFormat("Foo volatile const a;", Style);
   verifyFormat("Foo volatile const a;", "const Foo volatile a;", Style);
 }
 
 TEST_F(QualifierFixerTest, InlineStatics) {
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Left;
   Style.QualifierOrder = {"inline", "static", "const", "volatile", "type"};
   EXPECT_EQ(Style.QualifierOrder.size(), (size_t)5);
TEST_F(QualifierFixerTest, DontPushQualifierThroughNonSpecifiedTypes) {
   Style.QualifierAlignment = FormatStyle::QAS_Left;
   Style.QualifierOrder = {"const", "volatile", "type"};
 
   verifyFormat("inline static const int a;", Style);
 
   Style.QualifierOrder = {"static", "const", "type"};
 
   verifyFormat("inline static const int a;", Style);
-  verifyFormat("static inline const int a;", "static inline const int a;",
-               Style);
+  verifyFormat("static inline const int a;", Style);
 
   verifyFormat("static const int a;", "const static int a;", Style);
 
   Style.QualifierOrder = {"const", "volatile", "type"};
   // static is not configured, unchanged at right hand qualifiers.
   verifyFormat("const volatile int static;", "int volatile static const;",
                Style);
   verifyFormat("const volatile int static;", "int const static volatile;",
                Style);
   verifyFormat("const volatile int static;", "const int static volatile;",
                Style);
   verifyFormat("const volatile Foo static;", "Foo volatile static const;",
                Style);
   verifyFormat("const volatile Foo static;", "Foo const static volatile;",
                Style);
   verifyFormat("const volatile Foo static;", "const Foo static volatile;",
                Style);
 
   verifyFormat("inline static const Foo;", "inline static Foo const;", Style);
-  verifyFormat("inline static const Foo;", "inline static const Foo;", Style);
+  verifyFormat("inline static const Foo;", Style);
 
   // Don't move qualifiers to the right for aestethics only.
-  verifyFormat("inline const static Foo;", "inline const static Foo;", Style);
-  verifyFormat("const inline static Foo;", "const inline static Foo;", Style);
+  verifyFormat("inline const static Foo;", Style);
+  verifyFormat("const inline static Foo;", Style);
 }
 
 TEST_F(QualifierFixerTest, UnsignedQualifier) {
 
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Left;
   Style.QualifierOrder = {"const", "type"};