1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "clang/Format/Format.h"
10 
11 #include "../Tooling/ReplacementTest.h"
12 #include "FormatTestUtils.h"
13 
14 #include "clang/Frontend/TextDiagnosticPrinter.h"
15 #include "llvm/Support/Debug.h"
16 #include "llvm/Support/MemoryBuffer.h"
17 #include "gtest/gtest.h"
18 
19 #define DEBUG_TYPE "format-test"
20 
21 using clang::tooling::ReplacementTest;
22 using clang::tooling::toReplacements;
23 using testing::internal::ScopedTrace;
24 
25 namespace clang {
26 namespace format {
27 namespace {
28 
29 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
30 
31 class FormatTest : public ::testing::Test {
32 protected:
33   enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck };
34 
35   std::string format(llvm::StringRef Code,
36                      const FormatStyle &Style = getLLVMStyle(),
37                      StatusCheck CheckComplete = SC_ExpectComplete) {
38     LLVM_DEBUG(llvm::errs() << "---\n");
39     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
40     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
41     FormattingAttemptStatus Status;
42     tooling::Replacements Replaces =
43         reformat(Style, Code, Ranges, "<stdin>", &Status);
44     if (CheckComplete != SC_DoNotCheck) {
45       bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete;
46       EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
47           << Code << "\n\n";
48     }
49     ReplacementCount = Replaces.size();
50     auto Result = applyAllReplacements(Code, Replaces);
51     EXPECT_TRUE(static_cast<bool>(Result));
52     LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
53     return *Result;
54   }
55 
56   FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) {
57     Style.ColumnLimit = ColumnLimit;
58     return Style;
59   }
60 
61   FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
62     return getStyleWithColumns(getLLVMStyle(), ColumnLimit);
63   }
64 
65   FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
66     return getStyleWithColumns(getGoogleStyle(), ColumnLimit);
67   }
68 
69   void _verifyFormat(const char *File, int Line, llvm::StringRef Expected,
70                      llvm::StringRef Code,
71                      const FormatStyle &Style = getLLVMStyle()) {
72     ScopedTrace t(File, Line, ::testing::Message() << Code.str());
73     EXPECT_EQ(Expected.str(), format(Expected, Style))
74         << "Expected code is not stable";
75     EXPECT_EQ(Expected.str(), format(Code, Style));
76     if (Style.Language == FormatStyle::LK_Cpp) {
77       // Objective-C++ is a superset of C++, so everything checked for C++
78       // needs to be checked for Objective-C++ as well.
79       FormatStyle ObjCStyle = Style;
80       ObjCStyle.Language = FormatStyle::LK_ObjC;
81       EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
82     }
83   }
84 
85   void _verifyFormat(const char *File, int Line, llvm::StringRef Code,
86                      const FormatStyle &Style = getLLVMStyle()) {
87     _verifyFormat(File, Line, Code, test::messUp(Code), Style);
88   }
89 
90   void _verifyIncompleteFormat(const char *File, int Line, llvm::StringRef Code,
91                                const FormatStyle &Style = getLLVMStyle()) {
92     ScopedTrace t(File, Line, ::testing::Message() << Code.str());
93     EXPECT_EQ(Code.str(),
94               format(test::messUp(Code), Style, SC_ExpectIncomplete));
95   }
96 
97   void _verifyIndependentOfContext(const char *File, int Line,
98                                    llvm::StringRef Text,
99                                    const FormatStyle &Style = getLLVMStyle()) {
100     _verifyFormat(File, Line, Text, Style);
101     _verifyFormat(File, Line, llvm::Twine("void f() { " + Text + " }").str(),
102                   Style);
103   }
104 
105   /// \brief Verify that clang-format does not crash on the given input.
106   void verifyNoCrash(llvm::StringRef Code,
107                      const FormatStyle &Style = getLLVMStyle()) {
108     format(Code, Style, SC_DoNotCheck);
109   }
110 
111   int ReplacementCount;
112 };
113 
114 #define verifyIndependentOfContext(...)                                        \
115   _verifyIndependentOfContext(__FILE__, __LINE__, __VA_ARGS__)
116 #define verifyIncompleteFormat(...)                                            \
117   _verifyIncompleteFormat(__FILE__, __LINE__, __VA_ARGS__)
118 #define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__)
119 #define verifyGoogleFormat(Code) verifyFormat(Code, getGoogleStyle())
120 
121 TEST_F(FormatTest, MessUp) {
122   EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
123   EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
124   EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
125   EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
126   EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
127 }
128 
129 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) {
130   EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language);
131 }
132 
133 TEST_F(FormatTest, LLVMStyleOverride) {
134   EXPECT_EQ(FormatStyle::LK_Proto,
135             getLLVMStyle(FormatStyle::LK_Proto).Language);
136 }
137 
138 //===----------------------------------------------------------------------===//
139 // Basic function tests.
140 //===----------------------------------------------------------------------===//
141 
142 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
143   EXPECT_EQ(";", format(";"));
144 }
145 
146 TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
147   EXPECT_EQ("int i;", format("  int i;"));
148   EXPECT_EQ("\nint i;", format(" \n\t \v \f  int i;"));
149   EXPECT_EQ("int i;\nint j;", format("    int i; int j;"));
150   EXPECT_EQ("int i;\nint j;", format("    int i;\n  int j;"));
151 }
152 
153 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
154   EXPECT_EQ("int i;", format("int\ni;"));
155 }
156 
157 TEST_F(FormatTest, FormatsNestedBlockStatements) {
158   EXPECT_EQ("{\n  {\n    {}\n  }\n}", format("{{{}}}"));
159 }
160 
161 TEST_F(FormatTest, FormatsNestedCall) {
162   verifyFormat("Method(f1, f2(f3));");
163   verifyFormat("Method(f1(f2, f3()));");
164   verifyFormat("Method(f1(f2, (f3())));");
165 }
166 
167 TEST_F(FormatTest, NestedNameSpecifiers) {
168   verifyFormat("vector<::Type> v;");
169   verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
170   verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
171   verifyFormat("static constexpr bool Bar = typeof(bar())::value;");
172   verifyFormat("static constexpr bool Bar = __underlying_type(bar())::value;");
173   verifyFormat("static constexpr bool Bar = _Atomic(bar())::value;");
174   verifyFormat("bool a = 2 < ::SomeFunction();");
175   verifyFormat("ALWAYS_INLINE ::std::string getName();");
176   verifyFormat("some::string getName();");
177 }
178 
179 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
180   EXPECT_EQ("if (a) {\n"
181             "  f();\n"
182             "}",
183             format("if(a){f();}"));
184   EXPECT_EQ(4, ReplacementCount);
185   EXPECT_EQ("if (a) {\n"
186             "  f();\n"
187             "}",
188             format("if (a) {\n"
189                    "  f();\n"
190                    "}"));
191   EXPECT_EQ(0, ReplacementCount);
192   EXPECT_EQ("/*\r\n"
193             "\r\n"
194             "*/\r\n",
195             format("/*\r\n"
196                    "\r\n"
197                    "*/\r\n"));
198   EXPECT_EQ(0, ReplacementCount);
199 }
200 
201 TEST_F(FormatTest, RemovesEmptyLines) {
202   EXPECT_EQ("class C {\n"
203             "  int i;\n"
204             "};",
205             format("class C {\n"
206                    " int i;\n"
207                    "\n"
208                    "};"));
209 
210   // Don't remove empty lines at the start of namespaces or extern "C" blocks.
211   EXPECT_EQ("namespace N {\n"
212             "\n"
213             "int i;\n"
214             "}",
215             format("namespace N {\n"
216                    "\n"
217                    "int    i;\n"
218                    "}",
219                    getGoogleStyle()));
220   EXPECT_EQ("/* something */ namespace N {\n"
221             "\n"
222             "int i;\n"
223             "}",
224             format("/* something */ namespace N {\n"
225                    "\n"
226                    "int    i;\n"
227                    "}",
228                    getGoogleStyle()));
229   EXPECT_EQ("inline namespace N {\n"
230             "\n"
231             "int i;\n"
232             "}",
233             format("inline namespace N {\n"
234                    "\n"
235                    "int    i;\n"
236                    "}",
237                    getGoogleStyle()));
238   EXPECT_EQ("/* something */ inline namespace N {\n"
239             "\n"
240             "int i;\n"
241             "}",
242             format("/* something */ inline namespace N {\n"
243                    "\n"
244                    "int    i;\n"
245                    "}",
246                    getGoogleStyle()));
247   EXPECT_EQ("export namespace N {\n"
248             "\n"
249             "int i;\n"
250             "}",
251             format("export namespace N {\n"
252                    "\n"
253                    "int    i;\n"
254                    "}",
255                    getGoogleStyle()));
256   EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
257             "\n"
258             "int i;\n"
259             "}",
260             format("extern /**/ \"C\" /**/ {\n"
261                    "\n"
262                    "int    i;\n"
263                    "}",
264                    getGoogleStyle()));
265 
266   // ...but do keep inlining and removing empty lines for non-block extern "C"
267   // functions.
268   verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
269   EXPECT_EQ("extern \"C\" int f() {\n"
270             "  int i = 42;\n"
271             "  return i;\n"
272             "}",
273             format("extern \"C\" int f() {\n"
274                    "\n"
275                    "  int i = 42;\n"
276                    "  return i;\n"
277                    "}",
278                    getGoogleStyle()));
279 
280   // Remove empty lines at the beginning and end of blocks.
281   EXPECT_EQ("void f() {\n"
282             "\n"
283             "  if (a) {\n"
284             "\n"
285             "    f();\n"
286             "  }\n"
287             "}",
288             format("void f() {\n"
289                    "\n"
290                    "  if (a) {\n"
291                    "\n"
292                    "    f();\n"
293                    "\n"
294                    "  }\n"
295                    "\n"
296                    "}",
297                    getLLVMStyle()));
298   EXPECT_EQ("void f() {\n"
299             "  if (a) {\n"
300             "    f();\n"
301             "  }\n"
302             "}",
303             format("void f() {\n"
304                    "\n"
305                    "  if (a) {\n"
306                    "\n"
307                    "    f();\n"
308                    "\n"
309                    "  }\n"
310                    "\n"
311                    "}",
312                    getGoogleStyle()));
313 
314   // Don't remove empty lines in more complex control statements.
315   EXPECT_EQ("void f() {\n"
316             "  if (a) {\n"
317             "    f();\n"
318             "\n"
319             "  } else if (b) {\n"
320             "    f();\n"
321             "  }\n"
322             "}",
323             format("void f() {\n"
324                    "  if (a) {\n"
325                    "    f();\n"
326                    "\n"
327                    "  } else if (b) {\n"
328                    "    f();\n"
329                    "\n"
330                    "  }\n"
331                    "\n"
332                    "}"));
333 
334   // Don't remove empty lines before namespace endings.
335   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
336   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
337   EXPECT_EQ("namespace {\n"
338             "int i;\n"
339             "\n"
340             "}",
341             format("namespace {\n"
342                    "int i;\n"
343                    "\n"
344                    "}",
345                    LLVMWithNoNamespaceFix));
346   EXPECT_EQ("namespace {\n"
347             "int i;\n"
348             "}",
349             format("namespace {\n"
350                    "int i;\n"
351                    "}",
352                    LLVMWithNoNamespaceFix));
353   EXPECT_EQ("namespace {\n"
354             "int i;\n"
355             "\n"
356             "};",
357             format("namespace {\n"
358                    "int i;\n"
359                    "\n"
360                    "};",
361                    LLVMWithNoNamespaceFix));
362   EXPECT_EQ("namespace {\n"
363             "int i;\n"
364             "};",
365             format("namespace {\n"
366                    "int i;\n"
367                    "};",
368                    LLVMWithNoNamespaceFix));
369   EXPECT_EQ("namespace {\n"
370             "int i;\n"
371             "\n"
372             "}",
373             format("namespace {\n"
374                    "int i;\n"
375                    "\n"
376                    "}"));
377   EXPECT_EQ("namespace {\n"
378             "int i;\n"
379             "\n"
380             "} // namespace",
381             format("namespace {\n"
382                    "int i;\n"
383                    "\n"
384                    "}  // namespace"));
385 
386   FormatStyle Style = getLLVMStyle();
387   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
388   Style.MaxEmptyLinesToKeep = 2;
389   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
390   Style.BraceWrapping.AfterClass = true;
391   Style.BraceWrapping.AfterFunction = true;
392   Style.KeepEmptyLinesAtTheStartOfBlocks = false;
393 
394   EXPECT_EQ("class Foo\n"
395             "{\n"
396             "  Foo() {}\n"
397             "\n"
398             "  void funk() {}\n"
399             "};",
400             format("class Foo\n"
401                    "{\n"
402                    "  Foo()\n"
403                    "  {\n"
404                    "  }\n"
405                    "\n"
406                    "  void funk() {}\n"
407                    "};",
408                    Style));
409 }
410 
411 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
412   verifyFormat("x = (a) and (b);");
413   verifyFormat("x = (a) or (b);");
414   verifyFormat("x = (a) bitand (b);");
415   verifyFormat("x = (a) bitor (b);");
416   verifyFormat("x = (a) not_eq (b);");
417   verifyFormat("x = (a) and_eq (b);");
418   verifyFormat("x = (a) or_eq (b);");
419   verifyFormat("x = (a) xor (b);");
420 }
421 
422 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) {
423   verifyFormat("x = compl(a);");
424   verifyFormat("x = not(a);");
425   verifyFormat("x = bitand(a);");
426   // Unary operator must not be merged with the next identifier
427   verifyFormat("x = compl a;");
428   verifyFormat("x = not a;");
429   verifyFormat("x = bitand a;");
430 }
431 
432 //===----------------------------------------------------------------------===//
433 // Tests for control statements.
434 //===----------------------------------------------------------------------===//
435 
436 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
437   verifyFormat("if (true)\n  f();\ng();");
438   verifyFormat("if (a)\n  if (b)\n    if (c)\n      g();\nh();");
439   verifyFormat("if (a)\n  if (b) {\n    f();\n  }\ng();");
440   verifyFormat("if constexpr (true)\n"
441                "  f();\ng();");
442   verifyFormat("if CONSTEXPR (true)\n"
443                "  f();\ng();");
444   verifyFormat("if constexpr (a)\n"
445                "  if constexpr (b)\n"
446                "    if constexpr (c)\n"
447                "      g();\n"
448                "h();");
449   verifyFormat("if CONSTEXPR (a)\n"
450                "  if CONSTEXPR (b)\n"
451                "    if CONSTEXPR (c)\n"
452                "      g();\n"
453                "h();");
454   verifyFormat("if constexpr (a)\n"
455                "  if constexpr (b) {\n"
456                "    f();\n"
457                "  }\n"
458                "g();");
459   verifyFormat("if CONSTEXPR (a)\n"
460                "  if CONSTEXPR (b) {\n"
461                "    f();\n"
462                "  }\n"
463                "g();");
464 
465   FormatStyle AllowsMergedIf = getLLVMStyle();
466   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
467   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
468       FormatStyle::SIS_WithoutElse;
469   verifyFormat("if (a)\n"
470                "  // comment\n"
471                "  f();",
472                AllowsMergedIf);
473   verifyFormat("{\n"
474                "  if (a)\n"
475                "  label:\n"
476                "    f();\n"
477                "}",
478                AllowsMergedIf);
479   verifyFormat("#define A \\\n"
480                "  if (a)  \\\n"
481                "  label:  \\\n"
482                "    f()",
483                AllowsMergedIf);
484   verifyFormat("if (a)\n"
485                "  ;",
486                AllowsMergedIf);
487   verifyFormat("if (a)\n"
488                "  if (b) return;",
489                AllowsMergedIf);
490 
491   verifyFormat("if (a) // Can't merge this\n"
492                "  f();\n",
493                AllowsMergedIf);
494   verifyFormat("if (a) /* still don't merge */\n"
495                "  f();",
496                AllowsMergedIf);
497   verifyFormat("if (a) { // Never merge this\n"
498                "  f();\n"
499                "}",
500                AllowsMergedIf);
501   verifyFormat("if (a) { /* Never merge this */\n"
502                "  f();\n"
503                "}",
504                AllowsMergedIf);
505 
506   AllowsMergedIf.ColumnLimit = 14;
507   verifyFormat("if (a) return;", AllowsMergedIf);
508   verifyFormat("if (aaaaaaaaa)\n"
509                "  return;",
510                AllowsMergedIf);
511 
512   AllowsMergedIf.ColumnLimit = 13;
513   verifyFormat("if (a)\n  return;", AllowsMergedIf);
514 }
515 
516 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) {
517   FormatStyle AllowsMergedIf = getLLVMStyle();
518   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
519   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
520       FormatStyle::SIS_WithoutElse;
521   verifyFormat("if (a)\n"
522                "  f();\n"
523                "else {\n"
524                "  g();\n"
525                "}",
526                AllowsMergedIf);
527   verifyFormat("if (a)\n"
528                "  f();\n"
529                "else\n"
530                "  g();\n",
531                AllowsMergedIf);
532 
533   AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
534 
535   verifyFormat("if (a) f();\n"
536                "else {\n"
537                "  g();\n"
538                "}",
539                AllowsMergedIf);
540   verifyFormat("if (a) f();\n"
541                "else {\n"
542                "  if (a) f();\n"
543                "  else {\n"
544                "    g();\n"
545                "  }\n"
546                "  g();\n"
547                "}",
548                AllowsMergedIf);
549 }
550 
551 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
552   FormatStyle AllowsMergedLoops = getLLVMStyle();
553   AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
554   verifyFormat("while (true) continue;", AllowsMergedLoops);
555   verifyFormat("for (;;) continue;", AllowsMergedLoops);
556   verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
557   verifyFormat("while (true)\n"
558                "  ;",
559                AllowsMergedLoops);
560   verifyFormat("for (;;)\n"
561                "  ;",
562                AllowsMergedLoops);
563   verifyFormat("for (;;)\n"
564                "  for (;;) continue;",
565                AllowsMergedLoops);
566   verifyFormat("for (;;) // Can't merge this\n"
567                "  continue;",
568                AllowsMergedLoops);
569   verifyFormat("for (;;) /* still don't merge */\n"
570                "  continue;",
571                AllowsMergedLoops);
572   verifyFormat("do a++;\n"
573                "while (true);",
574                AllowsMergedLoops);
575   verifyFormat("do /* Don't merge */\n"
576                "  a++;\n"
577                "while (true);",
578                AllowsMergedLoops);
579   verifyFormat("do // Don't merge\n"
580                "  a++;\n"
581                "while (true);",
582                AllowsMergedLoops);
583   verifyFormat("do\n"
584                "  // Don't merge\n"
585                "  a++;\n"
586                "while (true);",
587                AllowsMergedLoops);
588   // Without braces labels are interpreted differently.
589   verifyFormat("{\n"
590                "  do\n"
591                "  label:\n"
592                "    a++;\n"
593                "  while (true);\n"
594                "}",
595                AllowsMergedLoops);
596 }
597 
598 TEST_F(FormatTest, FormatShortBracedStatements) {
599   FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
600   AllowSimpleBracedStatements.ColumnLimit = 40;
601   AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine =
602       FormatStyle::SBS_Always;
603 
604   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
605       FormatStyle::SIS_WithoutElse;
606   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
607 
608   AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
609   AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
610   AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
611 
612   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
613   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
614   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
615   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
616   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
617   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
618   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
619   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
620   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
621   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
622   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
623                AllowSimpleBracedStatements);
624   verifyFormat("if (true) {\n"
625                "  ffffffffffffffffffffffff();\n"
626                "}",
627                AllowSimpleBracedStatements);
628   verifyFormat("if (true) {\n"
629                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
630                "}",
631                AllowSimpleBracedStatements);
632   verifyFormat("if (true) { //\n"
633                "  f();\n"
634                "}",
635                AllowSimpleBracedStatements);
636   verifyFormat("if (true) {\n"
637                "  f();\n"
638                "  f();\n"
639                "}",
640                AllowSimpleBracedStatements);
641   verifyFormat("if (true) {\n"
642                "  f();\n"
643                "} else {\n"
644                "  f();\n"
645                "}",
646                AllowSimpleBracedStatements);
647 
648   verifyFormat("struct A2 {\n"
649                "  int X;\n"
650                "};",
651                AllowSimpleBracedStatements);
652   verifyFormat("typedef struct A2 {\n"
653                "  int X;\n"
654                "} A2_t;",
655                AllowSimpleBracedStatements);
656   verifyFormat("template <int> struct A2 {\n"
657                "  struct B {};\n"
658                "};",
659                AllowSimpleBracedStatements);
660 
661   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
662       FormatStyle::SIS_Never;
663   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
664   verifyFormat("if (true) {\n"
665                "  f();\n"
666                "}",
667                AllowSimpleBracedStatements);
668   verifyFormat("if (true) {\n"
669                "  f();\n"
670                "} else {\n"
671                "  f();\n"
672                "}",
673                AllowSimpleBracedStatements);
674 
675   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
676   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
677   verifyFormat("while (true) {\n"
678                "  f();\n"
679                "}",
680                AllowSimpleBracedStatements);
681   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
682   verifyFormat("for (;;) {\n"
683                "  f();\n"
684                "}",
685                AllowSimpleBracedStatements);
686 
687   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
688       FormatStyle::SIS_WithoutElse;
689   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
690   AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement =
691       FormatStyle::BWACS_Always;
692 
693   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
694   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
695   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
696   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
697   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
698   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
699   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
700   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
701   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
702   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
703   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
704                AllowSimpleBracedStatements);
705   verifyFormat("if (true)\n"
706                "{\n"
707                "  ffffffffffffffffffffffff();\n"
708                "}",
709                AllowSimpleBracedStatements);
710   verifyFormat("if (true)\n"
711                "{\n"
712                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
713                "}",
714                AllowSimpleBracedStatements);
715   verifyFormat("if (true)\n"
716                "{ //\n"
717                "  f();\n"
718                "}",
719                AllowSimpleBracedStatements);
720   verifyFormat("if (true)\n"
721                "{\n"
722                "  f();\n"
723                "  f();\n"
724                "}",
725                AllowSimpleBracedStatements);
726   verifyFormat("if (true)\n"
727                "{\n"
728                "  f();\n"
729                "} else\n"
730                "{\n"
731                "  f();\n"
732                "}",
733                AllowSimpleBracedStatements);
734 
735   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
736       FormatStyle::SIS_Never;
737   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
738   verifyFormat("if (true)\n"
739                "{\n"
740                "  f();\n"
741                "}",
742                AllowSimpleBracedStatements);
743   verifyFormat("if (true)\n"
744                "{\n"
745                "  f();\n"
746                "} else\n"
747                "{\n"
748                "  f();\n"
749                "}",
750                AllowSimpleBracedStatements);
751 
752   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
753   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
754   verifyFormat("while (true)\n"
755                "{\n"
756                "  f();\n"
757                "}",
758                AllowSimpleBracedStatements);
759   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
760   verifyFormat("for (;;)\n"
761                "{\n"
762                "  f();\n"
763                "}",
764                AllowSimpleBracedStatements);
765 }
766 
767 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {
768   FormatStyle Style = getLLVMStyleWithColumns(60);
769   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
770   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
771   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
772   EXPECT_EQ("#define A                                                  \\\n"
773             "  if (HANDLEwernufrnuLwrmviferuvnierv)                     \\\n"
774             "  {                                                        \\\n"
775             "    RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier;               \\\n"
776             "  }\n"
777             "X;",
778             format("#define A \\\n"
779                    "   if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
780                    "      RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
781                    "   }\n"
782                    "X;",
783                    Style));
784 }
785 
786 TEST_F(FormatTest, ParseIfElse) {
787   verifyFormat("if (true)\n"
788                "  if (true)\n"
789                "    if (true)\n"
790                "      f();\n"
791                "    else\n"
792                "      g();\n"
793                "  else\n"
794                "    h();\n"
795                "else\n"
796                "  i();");
797   verifyFormat("if (true)\n"
798                "  if (true)\n"
799                "    if (true) {\n"
800                "      if (true)\n"
801                "        f();\n"
802                "    } else {\n"
803                "      g();\n"
804                "    }\n"
805                "  else\n"
806                "    h();\n"
807                "else {\n"
808                "  i();\n"
809                "}");
810   verifyFormat("if (true)\n"
811                "  if constexpr (true)\n"
812                "    if (true) {\n"
813                "      if constexpr (true)\n"
814                "        f();\n"
815                "    } else {\n"
816                "      g();\n"
817                "    }\n"
818                "  else\n"
819                "    h();\n"
820                "else {\n"
821                "  i();\n"
822                "}");
823   verifyFormat("if (true)\n"
824                "  if CONSTEXPR (true)\n"
825                "    if (true) {\n"
826                "      if CONSTEXPR (true)\n"
827                "        f();\n"
828                "    } else {\n"
829                "      g();\n"
830                "    }\n"
831                "  else\n"
832                "    h();\n"
833                "else {\n"
834                "  i();\n"
835                "}");
836   verifyFormat("void f() {\n"
837                "  if (a) {\n"
838                "  } else {\n"
839                "  }\n"
840                "}");
841 }
842 
843 TEST_F(FormatTest, ElseIf) {
844   verifyFormat("if (a) {\n} else if (b) {\n}");
845   verifyFormat("if (a)\n"
846                "  f();\n"
847                "else if (b)\n"
848                "  g();\n"
849                "else\n"
850                "  h();");
851   verifyFormat("if constexpr (a)\n"
852                "  f();\n"
853                "else if constexpr (b)\n"
854                "  g();\n"
855                "else\n"
856                "  h();");
857   verifyFormat("if CONSTEXPR (a)\n"
858                "  f();\n"
859                "else if CONSTEXPR (b)\n"
860                "  g();\n"
861                "else\n"
862                "  h();");
863   verifyFormat("if (a) {\n"
864                "  f();\n"
865                "}\n"
866                "// or else ..\n"
867                "else {\n"
868                "  g()\n"
869                "}");
870 
871   verifyFormat("if (a) {\n"
872                "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
873                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
874                "}");
875   verifyFormat("if (a) {\n"
876                "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
877                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
878                "}");
879   verifyFormat("if (a) {\n"
880                "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
881                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
882                "}");
883   verifyFormat("if (a) {\n"
884                "} else if (\n"
885                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
886                "}",
887                getLLVMStyleWithColumns(62));
888   verifyFormat("if (a) {\n"
889                "} else if constexpr (\n"
890                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
891                "}",
892                getLLVMStyleWithColumns(62));
893   verifyFormat("if (a) {\n"
894                "} else if CONSTEXPR (\n"
895                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
896                "}",
897                getLLVMStyleWithColumns(62));
898 }
899 
900 TEST_F(FormatTest, FormatsForLoop) {
901   verifyFormat(
902       "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
903       "     ++VeryVeryLongLoopVariable)\n"
904       "  ;");
905   verifyFormat("for (;;)\n"
906                "  f();");
907   verifyFormat("for (;;) {\n}");
908   verifyFormat("for (;;) {\n"
909                "  f();\n"
910                "}");
911   verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
912 
913   verifyFormat(
914       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
915       "                                          E = UnwrappedLines.end();\n"
916       "     I != E; ++I) {\n}");
917 
918   verifyFormat(
919       "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
920       "     ++IIIII) {\n}");
921   verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
922                "         aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
923                "     aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
924   verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
925                "         I = FD->getDeclsInPrototypeScope().begin(),\n"
926                "         E = FD->getDeclsInPrototypeScope().end();\n"
927                "     I != E; ++I) {\n}");
928   verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
929                "         I = Container.begin(),\n"
930                "         E = Container.end();\n"
931                "     I != E; ++I) {\n}",
932                getLLVMStyleWithColumns(76));
933 
934   verifyFormat(
935       "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
936       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
937       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
938       "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
939       "     ++aaaaaaaaaaa) {\n}");
940   verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
941                "                bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
942                "     ++i) {\n}");
943   verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
944                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
945                "}");
946   verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
947                "         aaaaaaaaaa);\n"
948                "     iter; ++iter) {\n"
949                "}");
950   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
951                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
952                "     aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
953                "     ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
954 
955   // These should not be formatted as Objective-C for-in loops.
956   verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
957   verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
958   verifyFormat("Foo *x;\nfor (x in y) {\n}");
959   verifyFormat(
960       "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
961 
962   FormatStyle NoBinPacking = getLLVMStyle();
963   NoBinPacking.BinPackParameters = false;
964   verifyFormat("for (int aaaaaaaaaaa = 1;\n"
965                "     aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
966                "                                           aaaaaaaaaaaaaaaa,\n"
967                "                                           aaaaaaaaaaaaaaaa,\n"
968                "                                           aaaaaaaaaaaaaaaa);\n"
969                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
970                "}",
971                NoBinPacking);
972   verifyFormat(
973       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
974       "                                          E = UnwrappedLines.end();\n"
975       "     I != E;\n"
976       "     ++I) {\n}",
977       NoBinPacking);
978 
979   FormatStyle AlignLeft = getLLVMStyle();
980   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
981   verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
982 }
983 
984 TEST_F(FormatTest, RangeBasedForLoops) {
985   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
986                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
987   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
988                "     aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
989   verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
990                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
991   verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
992                "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
993 }
994 
995 TEST_F(FormatTest, ForEachLoops) {
996   verifyFormat("void f() {\n"
997                "  foreach (Item *item, itemlist) {}\n"
998                "  Q_FOREACH (Item *item, itemlist) {}\n"
999                "  BOOST_FOREACH (Item *item, itemlist) {}\n"
1000                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
1001                "}");
1002 
1003   FormatStyle Style = getLLVMStyle();
1004   Style.SpaceBeforeParens =
1005       FormatStyle::SBPO_ControlStatementsExceptForEachMacros;
1006   verifyFormat("void f() {\n"
1007                "  foreach(Item *item, itemlist) {}\n"
1008                "  Q_FOREACH(Item *item, itemlist) {}\n"
1009                "  BOOST_FOREACH(Item *item, itemlist) {}\n"
1010                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
1011                "}",
1012                Style);
1013 
1014   // As function-like macros.
1015   verifyFormat("#define foreach(x, y)\n"
1016                "#define Q_FOREACH(x, y)\n"
1017                "#define BOOST_FOREACH(x, y)\n"
1018                "#define UNKNOWN_FOREACH(x, y)\n");
1019 
1020   // Not as function-like macros.
1021   verifyFormat("#define foreach (x, y)\n"
1022                "#define Q_FOREACH (x, y)\n"
1023                "#define BOOST_FOREACH (x, y)\n"
1024                "#define UNKNOWN_FOREACH (x, y)\n");
1025 
1026   // handle microsoft non standard extension
1027   verifyFormat("for each (char c in x->MyStringProperty)");
1028 }
1029 
1030 TEST_F(FormatTest, FormatsWhileLoop) {
1031   verifyFormat("while (true) {\n}");
1032   verifyFormat("while (true)\n"
1033                "  f();");
1034   verifyFormat("while () {\n}");
1035   verifyFormat("while () {\n"
1036                "  f();\n"
1037                "}");
1038 }
1039 
1040 TEST_F(FormatTest, FormatsDoWhile) {
1041   verifyFormat("do {\n"
1042                "  do_something();\n"
1043                "} while (something());");
1044   verifyFormat("do\n"
1045                "  do_something();\n"
1046                "while (something());");
1047 }
1048 
1049 TEST_F(FormatTest, FormatsSwitchStatement) {
1050   verifyFormat("switch (x) {\n"
1051                "case 1:\n"
1052                "  f();\n"
1053                "  break;\n"
1054                "case kFoo:\n"
1055                "case ns::kBar:\n"
1056                "case kBaz:\n"
1057                "  break;\n"
1058                "default:\n"
1059                "  g();\n"
1060                "  break;\n"
1061                "}");
1062   verifyFormat("switch (x) {\n"
1063                "case 1: {\n"
1064                "  f();\n"
1065                "  break;\n"
1066                "}\n"
1067                "case 2: {\n"
1068                "  break;\n"
1069                "}\n"
1070                "}");
1071   verifyFormat("switch (x) {\n"
1072                "case 1: {\n"
1073                "  f();\n"
1074                "  {\n"
1075                "    g();\n"
1076                "    h();\n"
1077                "  }\n"
1078                "  break;\n"
1079                "}\n"
1080                "}");
1081   verifyFormat("switch (x) {\n"
1082                "case 1: {\n"
1083                "  f();\n"
1084                "  if (foo) {\n"
1085                "    g();\n"
1086                "    h();\n"
1087                "  }\n"
1088                "  break;\n"
1089                "}\n"
1090                "}");
1091   verifyFormat("switch (x) {\n"
1092                "case 1: {\n"
1093                "  f();\n"
1094                "  g();\n"
1095                "} break;\n"
1096                "}");
1097   verifyFormat("switch (test)\n"
1098                "  ;");
1099   verifyFormat("switch (x) {\n"
1100                "default: {\n"
1101                "  // Do nothing.\n"
1102                "}\n"
1103                "}");
1104   verifyFormat("switch (x) {\n"
1105                "// comment\n"
1106                "// if 1, do f()\n"
1107                "case 1:\n"
1108                "  f();\n"
1109                "}");
1110   verifyFormat("switch (x) {\n"
1111                "case 1:\n"
1112                "  // Do amazing stuff\n"
1113                "  {\n"
1114                "    f();\n"
1115                "    g();\n"
1116                "  }\n"
1117                "  break;\n"
1118                "}");
1119   verifyFormat("#define A          \\\n"
1120                "  switch (x) {     \\\n"
1121                "  case a:          \\\n"
1122                "    foo = b;       \\\n"
1123                "  }",
1124                getLLVMStyleWithColumns(20));
1125   verifyFormat("#define OPERATION_CASE(name)           \\\n"
1126                "  case OP_name:                        \\\n"
1127                "    return operations::Operation##name\n",
1128                getLLVMStyleWithColumns(40));
1129   verifyFormat("switch (x) {\n"
1130                "case 1:;\n"
1131                "default:;\n"
1132                "  int i;\n"
1133                "}");
1134 
1135   verifyGoogleFormat("switch (x) {\n"
1136                      "  case 1:\n"
1137                      "    f();\n"
1138                      "    break;\n"
1139                      "  case kFoo:\n"
1140                      "  case ns::kBar:\n"
1141                      "  case kBaz:\n"
1142                      "    break;\n"
1143                      "  default:\n"
1144                      "    g();\n"
1145                      "    break;\n"
1146                      "}");
1147   verifyGoogleFormat("switch (x) {\n"
1148                      "  case 1: {\n"
1149                      "    f();\n"
1150                      "    break;\n"
1151                      "  }\n"
1152                      "}");
1153   verifyGoogleFormat("switch (test)\n"
1154                      "  ;");
1155 
1156   verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
1157                      "  case OP_name:              \\\n"
1158                      "    return operations::Operation##name\n");
1159   verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
1160                      "  // Get the correction operation class.\n"
1161                      "  switch (OpCode) {\n"
1162                      "    CASE(Add);\n"
1163                      "    CASE(Subtract);\n"
1164                      "    default:\n"
1165                      "      return operations::Unknown;\n"
1166                      "  }\n"
1167                      "#undef OPERATION_CASE\n"
1168                      "}");
1169   verifyFormat("DEBUG({\n"
1170                "  switch (x) {\n"
1171                "  case A:\n"
1172                "    f();\n"
1173                "    break;\n"
1174                "    // fallthrough\n"
1175                "  case B:\n"
1176                "    g();\n"
1177                "    break;\n"
1178                "  }\n"
1179                "});");
1180   EXPECT_EQ("DEBUG({\n"
1181             "  switch (x) {\n"
1182             "  case A:\n"
1183             "    f();\n"
1184             "    break;\n"
1185             "  // On B:\n"
1186             "  case B:\n"
1187             "    g();\n"
1188             "    break;\n"
1189             "  }\n"
1190             "});",
1191             format("DEBUG({\n"
1192                    "  switch (x) {\n"
1193                    "  case A:\n"
1194                    "    f();\n"
1195                    "    break;\n"
1196                    "  // On B:\n"
1197                    "  case B:\n"
1198                    "    g();\n"
1199                    "    break;\n"
1200                    "  }\n"
1201                    "});",
1202                    getLLVMStyle()));
1203   EXPECT_EQ("switch (n) {\n"
1204             "case 0: {\n"
1205             "  return false;\n"
1206             "}\n"
1207             "default: {\n"
1208             "  return true;\n"
1209             "}\n"
1210             "}",
1211             format("switch (n)\n"
1212                    "{\n"
1213                    "case 0: {\n"
1214                    "  return false;\n"
1215                    "}\n"
1216                    "default: {\n"
1217                    "  return true;\n"
1218                    "}\n"
1219                    "}",
1220                    getLLVMStyle()));
1221   verifyFormat("switch (a) {\n"
1222                "case (b):\n"
1223                "  return;\n"
1224                "}");
1225 
1226   verifyFormat("switch (a) {\n"
1227                "case some_namespace::\n"
1228                "    some_constant:\n"
1229                "  return;\n"
1230                "}",
1231                getLLVMStyleWithColumns(34));
1232 
1233   FormatStyle Style = getLLVMStyle();
1234   Style.IndentCaseLabels = true;
1235   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
1236   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1237   Style.BraceWrapping.AfterCaseLabel = true;
1238   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1239   EXPECT_EQ("switch (n)\n"
1240             "{\n"
1241             "  case 0:\n"
1242             "  {\n"
1243             "    return false;\n"
1244             "  }\n"
1245             "  default:\n"
1246             "  {\n"
1247             "    return true;\n"
1248             "  }\n"
1249             "}",
1250             format("switch (n) {\n"
1251                    "  case 0: {\n"
1252                    "    return false;\n"
1253                    "  }\n"
1254                    "  default: {\n"
1255                    "    return true;\n"
1256                    "  }\n"
1257                    "}",
1258                    Style));
1259   Style.BraceWrapping.AfterCaseLabel = false;
1260   EXPECT_EQ("switch (n)\n"
1261             "{\n"
1262             "  case 0: {\n"
1263             "    return false;\n"
1264             "  }\n"
1265             "  default: {\n"
1266             "    return true;\n"
1267             "  }\n"
1268             "}",
1269             format("switch (n) {\n"
1270                    "  case 0:\n"
1271                    "  {\n"
1272                    "    return false;\n"
1273                    "  }\n"
1274                    "  default:\n"
1275                    "  {\n"
1276                    "    return true;\n"
1277                    "  }\n"
1278                    "}",
1279                    Style));
1280   Style.IndentCaseLabels = false;
1281   Style.IndentCaseBlocks = true;
1282   EXPECT_EQ("switch (n)\n"
1283             "{\n"
1284             "case 0:\n"
1285             "  {\n"
1286             "    return false;\n"
1287             "  }\n"
1288             "case 1:\n"
1289             "  break;\n"
1290             "default:\n"
1291             "  {\n"
1292             "    return true;\n"
1293             "  }\n"
1294             "}",
1295             format("switch (n) {\n"
1296                    "case 0: {\n"
1297                    "  return false;\n"
1298                    "}\n"
1299                    "case 1:\n"
1300                    "  break;\n"
1301                    "default: {\n"
1302                    "  return true;\n"
1303                    "}\n"
1304                    "}",
1305                    Style));
1306   Style.IndentCaseLabels = true;
1307   Style.IndentCaseBlocks = true;
1308   EXPECT_EQ("switch (n)\n"
1309             "{\n"
1310             "  case 0:\n"
1311             "    {\n"
1312             "      return false;\n"
1313             "    }\n"
1314             "  case 1:\n"
1315             "    break;\n"
1316             "  default:\n"
1317             "    {\n"
1318             "      return true;\n"
1319             "    }\n"
1320             "}",
1321             format("switch (n) {\n"
1322                    "case 0: {\n"
1323                    "  return false;\n"
1324                    "}\n"
1325                    "case 1:\n"
1326                    "  break;\n"
1327                    "default: {\n"
1328                    "  return true;\n"
1329                    "}\n"
1330                    "}",
1331                    Style));
1332 }
1333 
1334 TEST_F(FormatTest, CaseRanges) {
1335   verifyFormat("switch (x) {\n"
1336                "case 'A' ... 'Z':\n"
1337                "case 1 ... 5:\n"
1338                "case a ... b:\n"
1339                "  break;\n"
1340                "}");
1341 }
1342 
1343 TEST_F(FormatTest, ShortEnums) {
1344   FormatStyle Style = getLLVMStyle();
1345   Style.AllowShortEnumsOnASingleLine = true;
1346   verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style);
1347   Style.AllowShortEnumsOnASingleLine = false;
1348   verifyFormat("enum\n"
1349                "{\n"
1350                "  A,\n"
1351                "  B,\n"
1352                "  C\n"
1353                "} ShortEnum1, ShortEnum2;",
1354                Style);
1355 }
1356 
1357 TEST_F(FormatTest, ShortCaseLabels) {
1358   FormatStyle Style = getLLVMStyle();
1359   Style.AllowShortCaseLabelsOnASingleLine = true;
1360   verifyFormat("switch (a) {\n"
1361                "case 1: x = 1; break;\n"
1362                "case 2: return;\n"
1363                "case 3:\n"
1364                "case 4:\n"
1365                "case 5: return;\n"
1366                "case 6: // comment\n"
1367                "  return;\n"
1368                "case 7:\n"
1369                "  // comment\n"
1370                "  return;\n"
1371                "case 8:\n"
1372                "  x = 8; // comment\n"
1373                "  break;\n"
1374                "default: y = 1; break;\n"
1375                "}",
1376                Style);
1377   verifyFormat("switch (a) {\n"
1378                "case 0: return; // comment\n"
1379                "case 1: break;  // comment\n"
1380                "case 2: return;\n"
1381                "// comment\n"
1382                "case 3: return;\n"
1383                "// comment 1\n"
1384                "// comment 2\n"
1385                "// comment 3\n"
1386                "case 4: break; /* comment */\n"
1387                "case 5:\n"
1388                "  // comment\n"
1389                "  break;\n"
1390                "case 6: /* comment */ x = 1; break;\n"
1391                "case 7: x = /* comment */ 1; break;\n"
1392                "case 8:\n"
1393                "  x = 1; /* comment */\n"
1394                "  break;\n"
1395                "case 9:\n"
1396                "  break; // comment line 1\n"
1397                "         // comment line 2\n"
1398                "}",
1399                Style);
1400   EXPECT_EQ("switch (a) {\n"
1401             "case 1:\n"
1402             "  x = 8;\n"
1403             "  // fall through\n"
1404             "case 2: x = 8;\n"
1405             "// comment\n"
1406             "case 3:\n"
1407             "  return; /* comment line 1\n"
1408             "           * comment line 2 */\n"
1409             "case 4: i = 8;\n"
1410             "// something else\n"
1411             "#if FOO\n"
1412             "case 5: break;\n"
1413             "#endif\n"
1414             "}",
1415             format("switch (a) {\n"
1416                    "case 1: x = 8;\n"
1417                    "  // fall through\n"
1418                    "case 2:\n"
1419                    "  x = 8;\n"
1420                    "// comment\n"
1421                    "case 3:\n"
1422                    "  return; /* comment line 1\n"
1423                    "           * comment line 2 */\n"
1424                    "case 4:\n"
1425                    "  i = 8;\n"
1426                    "// something else\n"
1427                    "#if FOO\n"
1428                    "case 5: break;\n"
1429                    "#endif\n"
1430                    "}",
1431                    Style));
1432   EXPECT_EQ("switch (a) {\n"
1433             "case 0:\n"
1434             "  return; // long long long long long long long long long long "
1435             "long long comment\n"
1436             "          // line\n"
1437             "}",
1438             format("switch (a) {\n"
1439                    "case 0: return; // long long long long long long long long "
1440                    "long long long long comment line\n"
1441                    "}",
1442                    Style));
1443   EXPECT_EQ("switch (a) {\n"
1444             "case 0:\n"
1445             "  return; /* long long long long long long long long long long "
1446             "long long comment\n"
1447             "             line */\n"
1448             "}",
1449             format("switch (a) {\n"
1450                    "case 0: return; /* long long long long long long long long "
1451                    "long long long long comment line */\n"
1452                    "}",
1453                    Style));
1454   verifyFormat("switch (a) {\n"
1455                "#if FOO\n"
1456                "case 0: return 0;\n"
1457                "#endif\n"
1458                "}",
1459                Style);
1460   verifyFormat("switch (a) {\n"
1461                "case 1: {\n"
1462                "}\n"
1463                "case 2: {\n"
1464                "  return;\n"
1465                "}\n"
1466                "case 3: {\n"
1467                "  x = 1;\n"
1468                "  return;\n"
1469                "}\n"
1470                "case 4:\n"
1471                "  if (x)\n"
1472                "    return;\n"
1473                "}",
1474                Style);
1475   Style.ColumnLimit = 21;
1476   verifyFormat("switch (a) {\n"
1477                "case 1: x = 1; break;\n"
1478                "case 2: return;\n"
1479                "case 3:\n"
1480                "case 4:\n"
1481                "case 5: return;\n"
1482                "default:\n"
1483                "  y = 1;\n"
1484                "  break;\n"
1485                "}",
1486                Style);
1487   Style.ColumnLimit = 80;
1488   Style.AllowShortCaseLabelsOnASingleLine = false;
1489   Style.IndentCaseLabels = true;
1490   EXPECT_EQ("switch (n) {\n"
1491             "  default /*comments*/:\n"
1492             "    return true;\n"
1493             "  case 0:\n"
1494             "    return false;\n"
1495             "}",
1496             format("switch (n) {\n"
1497                    "default/*comments*/:\n"
1498                    "  return true;\n"
1499                    "case 0:\n"
1500                    "  return false;\n"
1501                    "}",
1502                    Style));
1503   Style.AllowShortCaseLabelsOnASingleLine = true;
1504   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1505   Style.BraceWrapping.AfterCaseLabel = true;
1506   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1507   EXPECT_EQ("switch (n)\n"
1508             "{\n"
1509             "  case 0:\n"
1510             "  {\n"
1511             "    return false;\n"
1512             "  }\n"
1513             "  default:\n"
1514             "  {\n"
1515             "    return true;\n"
1516             "  }\n"
1517             "}",
1518             format("switch (n) {\n"
1519                    "  case 0: {\n"
1520                    "    return false;\n"
1521                    "  }\n"
1522                    "  default:\n"
1523                    "  {\n"
1524                    "    return true;\n"
1525                    "  }\n"
1526                    "}",
1527                    Style));
1528 }
1529 
1530 TEST_F(FormatTest, FormatsLabels) {
1531   verifyFormat("void f() {\n"
1532                "  some_code();\n"
1533                "test_label:\n"
1534                "  some_other_code();\n"
1535                "  {\n"
1536                "    some_more_code();\n"
1537                "  another_label:\n"
1538                "    some_more_code();\n"
1539                "  }\n"
1540                "}");
1541   verifyFormat("{\n"
1542                "  some_code();\n"
1543                "test_label:\n"
1544                "  some_other_code();\n"
1545                "}");
1546   verifyFormat("{\n"
1547                "  some_code();\n"
1548                "test_label:;\n"
1549                "  int i = 0;\n"
1550                "}");
1551   FormatStyle Style = getLLVMStyle();
1552   Style.IndentGotoLabels = false;
1553   verifyFormat("void f() {\n"
1554                "  some_code();\n"
1555                "test_label:\n"
1556                "  some_other_code();\n"
1557                "  {\n"
1558                "    some_more_code();\n"
1559                "another_label:\n"
1560                "    some_more_code();\n"
1561                "  }\n"
1562                "}",
1563                Style);
1564   verifyFormat("{\n"
1565                "  some_code();\n"
1566                "test_label:\n"
1567                "  some_other_code();\n"
1568                "}",
1569                Style);
1570   verifyFormat("{\n"
1571                "  some_code();\n"
1572                "test_label:;\n"
1573                "  int i = 0;\n"
1574                "}");
1575 }
1576 
1577 TEST_F(FormatTest, MultiLineControlStatements) {
1578   FormatStyle Style = getLLVMStyle();
1579   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1580   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine;
1581   Style.ColumnLimit = 20;
1582   // Short lines should keep opening brace on same line.
1583   EXPECT_EQ("if (foo) {\n"
1584             "  bar();\n"
1585             "}",
1586             format("if(foo){bar();}", Style));
1587   EXPECT_EQ("if (foo) {\n"
1588             "  bar();\n"
1589             "} else {\n"
1590             "  baz();\n"
1591             "}",
1592             format("if(foo){bar();}else{baz();}", Style));
1593   EXPECT_EQ("if (foo && bar) {\n"
1594             "  baz();\n"
1595             "}",
1596             format("if(foo&&bar){baz();}", Style));
1597   EXPECT_EQ("if (foo) {\n"
1598             "  bar();\n"
1599             "} else if (baz) {\n"
1600             "  quux();\n"
1601             "}",
1602             format("if(foo){bar();}else if(baz){quux();}", Style));
1603   EXPECT_EQ(
1604       "if (foo) {\n"
1605       "  bar();\n"
1606       "} else if (baz) {\n"
1607       "  quux();\n"
1608       "} else {\n"
1609       "  foobar();\n"
1610       "}",
1611       format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));
1612   EXPECT_EQ("for (;;) {\n"
1613             "  foo();\n"
1614             "}",
1615             format("for(;;){foo();}"));
1616   EXPECT_EQ("while (1) {\n"
1617             "  foo();\n"
1618             "}",
1619             format("while(1){foo();}", Style));
1620   EXPECT_EQ("switch (foo) {\n"
1621             "case bar:\n"
1622             "  return;\n"
1623             "}",
1624             format("switch(foo){case bar:return;}", Style));
1625   EXPECT_EQ("try {\n"
1626             "  foo();\n"
1627             "} catch (...) {\n"
1628             "  bar();\n"
1629             "}",
1630             format("try{foo();}catch(...){bar();}", Style));
1631   EXPECT_EQ("do {\n"
1632             "  foo();\n"
1633             "} while (bar &&\n"
1634             "         baz);",
1635             format("do{foo();}while(bar&&baz);", Style));
1636   // Long lines should put opening brace on new line.
1637   EXPECT_EQ("if (foo && bar &&\n"
1638             "    baz)\n"
1639             "{\n"
1640             "  quux();\n"
1641             "}",
1642             format("if(foo&&bar&&baz){quux();}", Style));
1643   EXPECT_EQ("if (foo && bar &&\n"
1644             "    baz)\n"
1645             "{\n"
1646             "  quux();\n"
1647             "}",
1648             format("if (foo && bar &&\n"
1649                    "    baz) {\n"
1650                    "  quux();\n"
1651                    "}",
1652                    Style));
1653   EXPECT_EQ("if (foo) {\n"
1654             "  bar();\n"
1655             "} else if (baz ||\n"
1656             "           quux)\n"
1657             "{\n"
1658             "  foobar();\n"
1659             "}",
1660             format("if(foo){bar();}else if(baz||quux){foobar();}", Style));
1661   EXPECT_EQ(
1662       "if (foo) {\n"
1663       "  bar();\n"
1664       "} else if (baz ||\n"
1665       "           quux)\n"
1666       "{\n"
1667       "  foobar();\n"
1668       "} else {\n"
1669       "  barbaz();\n"
1670       "}",
1671       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1672              Style));
1673   EXPECT_EQ("for (int i = 0;\n"
1674             "     i < 10; ++i)\n"
1675             "{\n"
1676             "  foo();\n"
1677             "}",
1678             format("for(int i=0;i<10;++i){foo();}", Style));
1679   EXPECT_EQ("foreach (int i,\n"
1680             "         list)\n"
1681             "{\n"
1682             "  foo();\n"
1683             "}",
1684             format("foreach(int i, list){foo();}", Style));
1685   Style.ColumnLimit =
1686       40; // to concentrate at brace wrapping, not line wrap due to column limit
1687   EXPECT_EQ("foreach (int i, list) {\n"
1688             "  foo();\n"
1689             "}",
1690             format("foreach(int i, list){foo();}", Style));
1691   Style.ColumnLimit =
1692       20; // to concentrate at brace wrapping, not line wrap due to column limit
1693   EXPECT_EQ("while (foo || bar ||\n"
1694             "       baz)\n"
1695             "{\n"
1696             "  quux();\n"
1697             "}",
1698             format("while(foo||bar||baz){quux();}", Style));
1699   EXPECT_EQ("switch (\n"
1700             "    foo = barbaz)\n"
1701             "{\n"
1702             "case quux:\n"
1703             "  return;\n"
1704             "}",
1705             format("switch(foo=barbaz){case quux:return;}", Style));
1706   EXPECT_EQ("try {\n"
1707             "  foo();\n"
1708             "} catch (\n"
1709             "    Exception &bar)\n"
1710             "{\n"
1711             "  baz();\n"
1712             "}",
1713             format("try{foo();}catch(Exception&bar){baz();}", Style));
1714   Style.ColumnLimit =
1715       40; // to concentrate at brace wrapping, not line wrap due to column limit
1716   EXPECT_EQ("try {\n"
1717             "  foo();\n"
1718             "} catch (Exception &bar) {\n"
1719             "  baz();\n"
1720             "}",
1721             format("try{foo();}catch(Exception&bar){baz();}", Style));
1722   Style.ColumnLimit =
1723       20; // to concentrate at brace wrapping, not line wrap due to column limit
1724 
1725   Style.BraceWrapping.BeforeElse = true;
1726   EXPECT_EQ(
1727       "if (foo) {\n"
1728       "  bar();\n"
1729       "}\n"
1730       "else if (baz ||\n"
1731       "         quux)\n"
1732       "{\n"
1733       "  foobar();\n"
1734       "}\n"
1735       "else {\n"
1736       "  barbaz();\n"
1737       "}",
1738       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1739              Style));
1740 
1741   Style.BraceWrapping.BeforeCatch = true;
1742   EXPECT_EQ("try {\n"
1743             "  foo();\n"
1744             "}\n"
1745             "catch (...) {\n"
1746             "  baz();\n"
1747             "}",
1748             format("try{foo();}catch(...){baz();}", Style));
1749 }
1750 
1751 TEST_F(FormatTest, BeforeWhile) {
1752   FormatStyle Style = getLLVMStyle();
1753   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1754 
1755   verifyFormat("do {\n"
1756                "  foo();\n"
1757                "} while (1);",
1758                Style);
1759   Style.BraceWrapping.BeforeWhile = true;
1760   verifyFormat("do {\n"
1761                "  foo();\n"
1762                "}\n"
1763                "while (1);",
1764                Style);
1765 }
1766 
1767 //===----------------------------------------------------------------------===//
1768 // Tests for classes, namespaces, etc.
1769 //===----------------------------------------------------------------------===//
1770 
1771 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
1772   verifyFormat("class A {};");
1773 }
1774 
1775 TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1776   verifyFormat("class A {\n"
1777                "public:\n"
1778                "public: // comment\n"
1779                "protected:\n"
1780                "private:\n"
1781                "  void f() {}\n"
1782                "};");
1783   verifyFormat("export class A {\n"
1784                "public:\n"
1785                "public: // comment\n"
1786                "protected:\n"
1787                "private:\n"
1788                "  void f() {}\n"
1789                "};");
1790   verifyGoogleFormat("class A {\n"
1791                      " public:\n"
1792                      " protected:\n"
1793                      " private:\n"
1794                      "  void f() {}\n"
1795                      "};");
1796   verifyGoogleFormat("export class A {\n"
1797                      " public:\n"
1798                      " protected:\n"
1799                      " private:\n"
1800                      "  void f() {}\n"
1801                      "};");
1802   verifyFormat("class A {\n"
1803                "public slots:\n"
1804                "  void f1() {}\n"
1805                "public Q_SLOTS:\n"
1806                "  void f2() {}\n"
1807                "protected slots:\n"
1808                "  void f3() {}\n"
1809                "protected Q_SLOTS:\n"
1810                "  void f4() {}\n"
1811                "private slots:\n"
1812                "  void f5() {}\n"
1813                "private Q_SLOTS:\n"
1814                "  void f6() {}\n"
1815                "signals:\n"
1816                "  void g1();\n"
1817                "Q_SIGNALS:\n"
1818                "  void g2();\n"
1819                "};");
1820 
1821   // Don't interpret 'signals' the wrong way.
1822   verifyFormat("signals.set();");
1823   verifyFormat("for (Signals signals : f()) {\n}");
1824   verifyFormat("{\n"
1825                "  signals.set(); // This needs indentation.\n"
1826                "}");
1827   verifyFormat("void f() {\n"
1828                "label:\n"
1829                "  signals.baz();\n"
1830                "}");
1831 }
1832 
1833 TEST_F(FormatTest, SeparatesLogicalBlocks) {
1834   EXPECT_EQ("class A {\n"
1835             "public:\n"
1836             "  void f();\n"
1837             "\n"
1838             "private:\n"
1839             "  void g() {}\n"
1840             "  // test\n"
1841             "protected:\n"
1842             "  int h;\n"
1843             "};",
1844             format("class A {\n"
1845                    "public:\n"
1846                    "void f();\n"
1847                    "private:\n"
1848                    "void g() {}\n"
1849                    "// test\n"
1850                    "protected:\n"
1851                    "int h;\n"
1852                    "};"));
1853   EXPECT_EQ("class A {\n"
1854             "protected:\n"
1855             "public:\n"
1856             "  void f();\n"
1857             "};",
1858             format("class A {\n"
1859                    "protected:\n"
1860                    "\n"
1861                    "public:\n"
1862                    "\n"
1863                    "  void f();\n"
1864                    "};"));
1865 
1866   // Even ensure proper spacing inside macros.
1867   EXPECT_EQ("#define B     \\\n"
1868             "  class A {   \\\n"
1869             "   protected: \\\n"
1870             "   public:    \\\n"
1871             "    void f(); \\\n"
1872             "  };",
1873             format("#define B     \\\n"
1874                    "  class A {   \\\n"
1875                    "   protected: \\\n"
1876                    "              \\\n"
1877                    "   public:    \\\n"
1878                    "              \\\n"
1879                    "    void f(); \\\n"
1880                    "  };",
1881                    getGoogleStyle()));
1882   // But don't remove empty lines after macros ending in access specifiers.
1883   EXPECT_EQ("#define A private:\n"
1884             "\n"
1885             "int i;",
1886             format("#define A         private:\n"
1887                    "\n"
1888                    "int              i;"));
1889 }
1890 
1891 TEST_F(FormatTest, FormatsClasses) {
1892   verifyFormat("class A : public B {};");
1893   verifyFormat("class A : public ::B {};");
1894 
1895   verifyFormat(
1896       "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1897       "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1898   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1899                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1900                "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1901   verifyFormat(
1902       "class A : public B, public C, public D, public E, public F {};");
1903   verifyFormat("class AAAAAAAAAAAA : public B,\n"
1904                "                     public C,\n"
1905                "                     public D,\n"
1906                "                     public E,\n"
1907                "                     public F,\n"
1908                "                     public G {};");
1909 
1910   verifyFormat("class\n"
1911                "    ReallyReallyLongClassName {\n"
1912                "  int i;\n"
1913                "};",
1914                getLLVMStyleWithColumns(32));
1915   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1916                "                           aaaaaaaaaaaaaaaa> {};");
1917   verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1918                "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1919                "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
1920   verifyFormat("template <class R, class C>\n"
1921                "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1922                "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
1923   verifyFormat("class ::A::B {};");
1924 }
1925 
1926 TEST_F(FormatTest, BreakInheritanceStyle) {
1927   FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
1928   StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
1929       FormatStyle::BILS_BeforeComma;
1930   verifyFormat("class MyClass : public X {};",
1931                StyleWithInheritanceBreakBeforeComma);
1932   verifyFormat("class MyClass\n"
1933                "    : public X\n"
1934                "    , public Y {};",
1935                StyleWithInheritanceBreakBeforeComma);
1936   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
1937                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
1938                "    , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1939                StyleWithInheritanceBreakBeforeComma);
1940   verifyFormat("struct aaaaaaaaaaaaa\n"
1941                "    : public aaaaaaaaaaaaaaaaaaa< // break\n"
1942                "          aaaaaaaaaaaaaaaa> {};",
1943                StyleWithInheritanceBreakBeforeComma);
1944 
1945   FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
1946   StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
1947       FormatStyle::BILS_AfterColon;
1948   verifyFormat("class MyClass : public X {};",
1949                StyleWithInheritanceBreakAfterColon);
1950   verifyFormat("class MyClass : public X, public Y {};",
1951                StyleWithInheritanceBreakAfterColon);
1952   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
1953                "    public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1954                "    public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1955                StyleWithInheritanceBreakAfterColon);
1956   verifyFormat("struct aaaaaaaaaaaaa :\n"
1957                "    public aaaaaaaaaaaaaaaaaaa< // break\n"
1958                "        aaaaaaaaaaaaaaaa> {};",
1959                StyleWithInheritanceBreakAfterColon);
1960 }
1961 
1962 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
1963   verifyFormat("class A {\n} a, b;");
1964   verifyFormat("struct A {\n} a, b;");
1965   verifyFormat("union A {\n} a;");
1966 }
1967 
1968 TEST_F(FormatTest, FormatsEnum) {
1969   verifyFormat("enum {\n"
1970                "  Zero,\n"
1971                "  One = 1,\n"
1972                "  Two = One + 1,\n"
1973                "  Three = (One + Two),\n"
1974                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1975                "  Five = (One, Two, Three, Four, 5)\n"
1976                "};");
1977   verifyGoogleFormat("enum {\n"
1978                      "  Zero,\n"
1979                      "  One = 1,\n"
1980                      "  Two = One + 1,\n"
1981                      "  Three = (One + Two),\n"
1982                      "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1983                      "  Five = (One, Two, Three, Four, 5)\n"
1984                      "};");
1985   verifyFormat("enum Enum {};");
1986   verifyFormat("enum {};");
1987   verifyFormat("enum X E {} d;");
1988   verifyFormat("enum __attribute__((...)) E {} d;");
1989   verifyFormat("enum __declspec__((...)) E {} d;");
1990   verifyFormat("enum {\n"
1991                "  Bar = Foo<int, int>::value\n"
1992                "};",
1993                getLLVMStyleWithColumns(30));
1994 
1995   verifyFormat("enum ShortEnum { A, B, C };");
1996   verifyGoogleFormat("enum ShortEnum { A, B, C };");
1997 
1998   EXPECT_EQ("enum KeepEmptyLines {\n"
1999             "  ONE,\n"
2000             "\n"
2001             "  TWO,\n"
2002             "\n"
2003             "  THREE\n"
2004             "}",
2005             format("enum KeepEmptyLines {\n"
2006                    "  ONE,\n"
2007                    "\n"
2008                    "  TWO,\n"
2009                    "\n"
2010                    "\n"
2011                    "  THREE\n"
2012                    "}"));
2013   verifyFormat("enum E { // comment\n"
2014                "  ONE,\n"
2015                "  TWO\n"
2016                "};\n"
2017                "int i;");
2018 
2019   FormatStyle EightIndent = getLLVMStyle();
2020   EightIndent.IndentWidth = 8;
2021   verifyFormat("enum {\n"
2022                "        VOID,\n"
2023                "        CHAR,\n"
2024                "        SHORT,\n"
2025                "        INT,\n"
2026                "        LONG,\n"
2027                "        SIGNED,\n"
2028                "        UNSIGNED,\n"
2029                "        BOOL,\n"
2030                "        FLOAT,\n"
2031                "        DOUBLE,\n"
2032                "        COMPLEX\n"
2033                "};",
2034                EightIndent);
2035 
2036   // Not enums.
2037   verifyFormat("enum X f() {\n"
2038                "  a();\n"
2039                "  return 42;\n"
2040                "}");
2041   verifyFormat("enum X Type::f() {\n"
2042                "  a();\n"
2043                "  return 42;\n"
2044                "}");
2045   verifyFormat("enum ::X f() {\n"
2046                "  a();\n"
2047                "  return 42;\n"
2048                "}");
2049   verifyFormat("enum ns::X f() {\n"
2050                "  a();\n"
2051                "  return 42;\n"
2052                "}");
2053 }
2054 
2055 TEST_F(FormatTest, FormatsEnumsWithErrors) {
2056   verifyFormat("enum Type {\n"
2057                "  One = 0; // These semicolons should be commas.\n"
2058                "  Two = 1;\n"
2059                "};");
2060   verifyFormat("namespace n {\n"
2061                "enum Type {\n"
2062                "  One,\n"
2063                "  Two, // missing };\n"
2064                "  int i;\n"
2065                "}\n"
2066                "void g() {}");
2067 }
2068 
2069 TEST_F(FormatTest, FormatsEnumStruct) {
2070   verifyFormat("enum struct {\n"
2071                "  Zero,\n"
2072                "  One = 1,\n"
2073                "  Two = One + 1,\n"
2074                "  Three = (One + Two),\n"
2075                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2076                "  Five = (One, Two, Three, Four, 5)\n"
2077                "};");
2078   verifyFormat("enum struct Enum {};");
2079   verifyFormat("enum struct {};");
2080   verifyFormat("enum struct X E {} d;");
2081   verifyFormat("enum struct __attribute__((...)) E {} d;");
2082   verifyFormat("enum struct __declspec__((...)) E {} d;");
2083   verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
2084 }
2085 
2086 TEST_F(FormatTest, FormatsEnumClass) {
2087   verifyFormat("enum class {\n"
2088                "  Zero,\n"
2089                "  One = 1,\n"
2090                "  Two = One + 1,\n"
2091                "  Three = (One + Two),\n"
2092                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2093                "  Five = (One, Two, Three, Four, 5)\n"
2094                "};");
2095   verifyFormat("enum class Enum {};");
2096   verifyFormat("enum class {};");
2097   verifyFormat("enum class X E {} d;");
2098   verifyFormat("enum class __attribute__((...)) E {} d;");
2099   verifyFormat("enum class __declspec__((...)) E {} d;");
2100   verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
2101 }
2102 
2103 TEST_F(FormatTest, FormatsEnumTypes) {
2104   verifyFormat("enum X : int {\n"
2105                "  A, // Force multiple lines.\n"
2106                "  B\n"
2107                "};");
2108   verifyFormat("enum X : int { A, B };");
2109   verifyFormat("enum X : std::uint32_t { A, B };");
2110 }
2111 
2112 TEST_F(FormatTest, FormatsTypedefEnum) {
2113   FormatStyle Style = getLLVMStyle();
2114   Style.ColumnLimit = 40;
2115   verifyFormat("typedef enum {} EmptyEnum;");
2116   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2117   verifyFormat("typedef enum {\n"
2118                "  ZERO = 0,\n"
2119                "  ONE = 1,\n"
2120                "  TWO = 2,\n"
2121                "  THREE = 3\n"
2122                "} LongEnum;",
2123                Style);
2124   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2125   Style.BraceWrapping.AfterEnum = true;
2126   verifyFormat("typedef enum {} EmptyEnum;");
2127   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2128   verifyFormat("typedef enum\n"
2129                "{\n"
2130                "  ZERO = 0,\n"
2131                "  ONE = 1,\n"
2132                "  TWO = 2,\n"
2133                "  THREE = 3\n"
2134                "} LongEnum;",
2135                Style);
2136 }
2137 
2138 TEST_F(FormatTest, FormatsNSEnums) {
2139   verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
2140   verifyGoogleFormat(
2141       "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }");
2142   verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
2143                      "  // Information about someDecentlyLongValue.\n"
2144                      "  someDecentlyLongValue,\n"
2145                      "  // Information about anotherDecentlyLongValue.\n"
2146                      "  anotherDecentlyLongValue,\n"
2147                      "  // Information about aThirdDecentlyLongValue.\n"
2148                      "  aThirdDecentlyLongValue\n"
2149                      "};");
2150   verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
2151                      "  // Information about someDecentlyLongValue.\n"
2152                      "  someDecentlyLongValue,\n"
2153                      "  // Information about anotherDecentlyLongValue.\n"
2154                      "  anotherDecentlyLongValue,\n"
2155                      "  // Information about aThirdDecentlyLongValue.\n"
2156                      "  aThirdDecentlyLongValue\n"
2157                      "};");
2158   verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
2159                      "  a = 1,\n"
2160                      "  b = 2,\n"
2161                      "  c = 3,\n"
2162                      "};");
2163   verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
2164                      "  a = 1,\n"
2165                      "  b = 2,\n"
2166                      "  c = 3,\n"
2167                      "};");
2168   verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
2169                      "  a = 1,\n"
2170                      "  b = 2,\n"
2171                      "  c = 3,\n"
2172                      "};");
2173   verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
2174                      "  a = 1,\n"
2175                      "  b = 2,\n"
2176                      "  c = 3,\n"
2177                      "};");
2178 }
2179 
2180 TEST_F(FormatTest, FormatsBitfields) {
2181   verifyFormat("struct Bitfields {\n"
2182                "  unsigned sClass : 8;\n"
2183                "  unsigned ValueKind : 2;\n"
2184                "};");
2185   verifyFormat("struct A {\n"
2186                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
2187                "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
2188                "};");
2189   verifyFormat("struct MyStruct {\n"
2190                "  uchar data;\n"
2191                "  uchar : 8;\n"
2192                "  uchar : 8;\n"
2193                "  uchar other;\n"
2194                "};");
2195   FormatStyle Style = getLLVMStyle();
2196   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
2197   verifyFormat("struct Bitfields {\n"
2198                "  unsigned sClass:8;\n"
2199                "  unsigned ValueKind:2;\n"
2200                "  uchar other;\n"
2201                "};",
2202                Style);
2203   verifyFormat("struct A {\n"
2204                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:1,\n"
2205                "      bbbbbbbbbbbbbbbbbbbbbbbbb:2;\n"
2206                "};",
2207                Style);
2208   Style.BitFieldColonSpacing = FormatStyle::BFCS_Before;
2209   verifyFormat("struct Bitfields {\n"
2210                "  unsigned sClass :8;\n"
2211                "  unsigned ValueKind :2;\n"
2212                "  uchar other;\n"
2213                "};",
2214                Style);
2215   Style.BitFieldColonSpacing = FormatStyle::BFCS_After;
2216   verifyFormat("struct Bitfields {\n"
2217                "  unsigned sClass: 8;\n"
2218                "  unsigned ValueKind: 2;\n"
2219                "  uchar other;\n"
2220                "};",
2221                Style);
2222 }
2223 
2224 TEST_F(FormatTest, FormatsNamespaces) {
2225   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
2226   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
2227 
2228   verifyFormat("namespace some_namespace {\n"
2229                "class A {};\n"
2230                "void f() { f(); }\n"
2231                "}",
2232                LLVMWithNoNamespaceFix);
2233   verifyFormat("namespace N::inline D {\n"
2234                "class A {};\n"
2235                "void f() { f(); }\n"
2236                "}",
2237                LLVMWithNoNamespaceFix);
2238   verifyFormat("namespace N::inline D::E {\n"
2239                "class A {};\n"
2240                "void f() { f(); }\n"
2241                "}",
2242                LLVMWithNoNamespaceFix);
2243   verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
2244                "class A {};\n"
2245                "void f() { f(); }\n"
2246                "}",
2247                LLVMWithNoNamespaceFix);
2248   verifyFormat("/* something */ namespace some_namespace {\n"
2249                "class A {};\n"
2250                "void f() { f(); }\n"
2251                "}",
2252                LLVMWithNoNamespaceFix);
2253   verifyFormat("namespace {\n"
2254                "class A {};\n"
2255                "void f() { f(); }\n"
2256                "}",
2257                LLVMWithNoNamespaceFix);
2258   verifyFormat("/* something */ namespace {\n"
2259                "class A {};\n"
2260                "void f() { f(); }\n"
2261                "}",
2262                LLVMWithNoNamespaceFix);
2263   verifyFormat("inline namespace X {\n"
2264                "class A {};\n"
2265                "void f() { f(); }\n"
2266                "}",
2267                LLVMWithNoNamespaceFix);
2268   verifyFormat("/* something */ inline namespace X {\n"
2269                "class A {};\n"
2270                "void f() { f(); }\n"
2271                "}",
2272                LLVMWithNoNamespaceFix);
2273   verifyFormat("export namespace X {\n"
2274                "class A {};\n"
2275                "void f() { f(); }\n"
2276                "}",
2277                LLVMWithNoNamespaceFix);
2278   verifyFormat("using namespace some_namespace;\n"
2279                "class A {};\n"
2280                "void f() { f(); }",
2281                LLVMWithNoNamespaceFix);
2282 
2283   // This code is more common than we thought; if we
2284   // layout this correctly the semicolon will go into
2285   // its own line, which is undesirable.
2286   verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
2287   verifyFormat("namespace {\n"
2288                "class A {};\n"
2289                "};",
2290                LLVMWithNoNamespaceFix);
2291 
2292   verifyFormat("namespace {\n"
2293                "int SomeVariable = 0; // comment\n"
2294                "} // namespace",
2295                LLVMWithNoNamespaceFix);
2296   EXPECT_EQ("#ifndef HEADER_GUARD\n"
2297             "#define HEADER_GUARD\n"
2298             "namespace my_namespace {\n"
2299             "int i;\n"
2300             "} // my_namespace\n"
2301             "#endif // HEADER_GUARD",
2302             format("#ifndef HEADER_GUARD\n"
2303                    " #define HEADER_GUARD\n"
2304                    "   namespace my_namespace {\n"
2305                    "int i;\n"
2306                    "}    // my_namespace\n"
2307                    "#endif    // HEADER_GUARD",
2308                    LLVMWithNoNamespaceFix));
2309 
2310   EXPECT_EQ("namespace A::B {\n"
2311             "class C {};\n"
2312             "}",
2313             format("namespace A::B {\n"
2314                    "class C {};\n"
2315                    "}",
2316                    LLVMWithNoNamespaceFix));
2317 
2318   FormatStyle Style = getLLVMStyle();
2319   Style.NamespaceIndentation = FormatStyle::NI_All;
2320   EXPECT_EQ("namespace out {\n"
2321             "  int i;\n"
2322             "  namespace in {\n"
2323             "    int i;\n"
2324             "  } // namespace in\n"
2325             "} // namespace out",
2326             format("namespace out {\n"
2327                    "int i;\n"
2328                    "namespace in {\n"
2329                    "int i;\n"
2330                    "} // namespace in\n"
2331                    "} // namespace out",
2332                    Style));
2333 
2334   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2335   EXPECT_EQ("namespace out {\n"
2336             "int i;\n"
2337             "namespace in {\n"
2338             "  int i;\n"
2339             "} // namespace in\n"
2340             "} // namespace out",
2341             format("namespace out {\n"
2342                    "int i;\n"
2343                    "namespace in {\n"
2344                    "int i;\n"
2345                    "} // namespace in\n"
2346                    "} // namespace out",
2347                    Style));
2348 }
2349 
2350 TEST_F(FormatTest, NamespaceMacros) {
2351   FormatStyle Style = getLLVMStyle();
2352   Style.NamespaceMacros.push_back("TESTSUITE");
2353 
2354   verifyFormat("TESTSUITE(A) {\n"
2355                "int foo();\n"
2356                "} // TESTSUITE(A)",
2357                Style);
2358 
2359   verifyFormat("TESTSUITE(A, B) {\n"
2360                "int foo();\n"
2361                "} // TESTSUITE(A)",
2362                Style);
2363 
2364   // Properly indent according to NamespaceIndentation style
2365   Style.NamespaceIndentation = FormatStyle::NI_All;
2366   verifyFormat("TESTSUITE(A) {\n"
2367                "  int foo();\n"
2368                "} // TESTSUITE(A)",
2369                Style);
2370   verifyFormat("TESTSUITE(A) {\n"
2371                "  namespace B {\n"
2372                "    int foo();\n"
2373                "  } // namespace B\n"
2374                "} // TESTSUITE(A)",
2375                Style);
2376   verifyFormat("namespace A {\n"
2377                "  TESTSUITE(B) {\n"
2378                "    int foo();\n"
2379                "  } // TESTSUITE(B)\n"
2380                "} // namespace A",
2381                Style);
2382 
2383   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2384   verifyFormat("TESTSUITE(A) {\n"
2385                "TESTSUITE(B) {\n"
2386                "  int foo();\n"
2387                "} // TESTSUITE(B)\n"
2388                "} // TESTSUITE(A)",
2389                Style);
2390   verifyFormat("TESTSUITE(A) {\n"
2391                "namespace B {\n"
2392                "  int foo();\n"
2393                "} // namespace B\n"
2394                "} // TESTSUITE(A)",
2395                Style);
2396   verifyFormat("namespace A {\n"
2397                "TESTSUITE(B) {\n"
2398                "  int foo();\n"
2399                "} // TESTSUITE(B)\n"
2400                "} // namespace A",
2401                Style);
2402 
2403   // Properly merge namespace-macros blocks in CompactNamespaces mode
2404   Style.NamespaceIndentation = FormatStyle::NI_None;
2405   Style.CompactNamespaces = true;
2406   verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
2407                "}} // TESTSUITE(A::B)",
2408                Style);
2409 
2410   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2411             "}} // TESTSUITE(out::in)",
2412             format("TESTSUITE(out) {\n"
2413                    "TESTSUITE(in) {\n"
2414                    "} // TESTSUITE(in)\n"
2415                    "} // TESTSUITE(out)",
2416                    Style));
2417 
2418   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2419             "}} // TESTSUITE(out::in)",
2420             format("TESTSUITE(out) {\n"
2421                    "TESTSUITE(in) {\n"
2422                    "} // TESTSUITE(in)\n"
2423                    "} // TESTSUITE(out)",
2424                    Style));
2425 
2426   // Do not merge different namespaces/macros
2427   EXPECT_EQ("namespace out {\n"
2428             "TESTSUITE(in) {\n"
2429             "} // TESTSUITE(in)\n"
2430             "} // namespace out",
2431             format("namespace out {\n"
2432                    "TESTSUITE(in) {\n"
2433                    "} // TESTSUITE(in)\n"
2434                    "} // namespace out",
2435                    Style));
2436   EXPECT_EQ("TESTSUITE(out) {\n"
2437             "namespace in {\n"
2438             "} // namespace in\n"
2439             "} // TESTSUITE(out)",
2440             format("TESTSUITE(out) {\n"
2441                    "namespace in {\n"
2442                    "} // namespace in\n"
2443                    "} // TESTSUITE(out)",
2444                    Style));
2445   Style.NamespaceMacros.push_back("FOOBAR");
2446   EXPECT_EQ("TESTSUITE(out) {\n"
2447             "FOOBAR(in) {\n"
2448             "} // FOOBAR(in)\n"
2449             "} // TESTSUITE(out)",
2450             format("TESTSUITE(out) {\n"
2451                    "FOOBAR(in) {\n"
2452                    "} // FOOBAR(in)\n"
2453                    "} // TESTSUITE(out)",
2454                    Style));
2455 }
2456 
2457 TEST_F(FormatTest, FormatsCompactNamespaces) {
2458   FormatStyle Style = getLLVMStyle();
2459   Style.CompactNamespaces = true;
2460   Style.NamespaceMacros.push_back("TESTSUITE");
2461 
2462   verifyFormat("namespace A { namespace B {\n"
2463                "}} // namespace A::B",
2464                Style);
2465 
2466   EXPECT_EQ("namespace out { namespace in {\n"
2467             "}} // namespace out::in",
2468             format("namespace out {\n"
2469                    "namespace in {\n"
2470                    "} // namespace in\n"
2471                    "} // namespace out",
2472                    Style));
2473 
2474   // Only namespaces which have both consecutive opening and end get compacted
2475   EXPECT_EQ("namespace out {\n"
2476             "namespace in1 {\n"
2477             "} // namespace in1\n"
2478             "namespace in2 {\n"
2479             "} // namespace in2\n"
2480             "} // namespace out",
2481             format("namespace out {\n"
2482                    "namespace in1 {\n"
2483                    "} // namespace in1\n"
2484                    "namespace in2 {\n"
2485                    "} // namespace in2\n"
2486                    "} // namespace out",
2487                    Style));
2488 
2489   EXPECT_EQ("namespace out {\n"
2490             "int i;\n"
2491             "namespace in {\n"
2492             "int j;\n"
2493             "} // namespace in\n"
2494             "int k;\n"
2495             "} // namespace out",
2496             format("namespace out { int i;\n"
2497                    "namespace in { int j; } // namespace in\n"
2498                    "int k; } // namespace out",
2499                    Style));
2500 
2501   EXPECT_EQ("namespace A { namespace B { namespace C {\n"
2502             "}}} // namespace A::B::C\n",
2503             format("namespace A { namespace B {\n"
2504                    "namespace C {\n"
2505                    "}} // namespace B::C\n"
2506                    "} // namespace A\n",
2507                    Style));
2508 
2509   Style.ColumnLimit = 40;
2510   EXPECT_EQ("namespace aaaaaaaaaa {\n"
2511             "namespace bbbbbbbbbb {\n"
2512             "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
2513             format("namespace aaaaaaaaaa {\n"
2514                    "namespace bbbbbbbbbb {\n"
2515                    "} // namespace bbbbbbbbbb\n"
2516                    "} // namespace aaaaaaaaaa",
2517                    Style));
2518 
2519   EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
2520             "namespace cccccc {\n"
2521             "}}} // namespace aaaaaa::bbbbbb::cccccc",
2522             format("namespace aaaaaa {\n"
2523                    "namespace bbbbbb {\n"
2524                    "namespace cccccc {\n"
2525                    "} // namespace cccccc\n"
2526                    "} // namespace bbbbbb\n"
2527                    "} // namespace aaaaaa",
2528                    Style));
2529   Style.ColumnLimit = 80;
2530 
2531   // Extra semicolon after 'inner' closing brace prevents merging
2532   EXPECT_EQ("namespace out { namespace in {\n"
2533             "}; } // namespace out::in",
2534             format("namespace out {\n"
2535                    "namespace in {\n"
2536                    "}; // namespace in\n"
2537                    "} // namespace out",
2538                    Style));
2539 
2540   // Extra semicolon after 'outer' closing brace is conserved
2541   EXPECT_EQ("namespace out { namespace in {\n"
2542             "}}; // namespace out::in",
2543             format("namespace out {\n"
2544                    "namespace in {\n"
2545                    "} // namespace in\n"
2546                    "}; // namespace out",
2547                    Style));
2548 
2549   Style.NamespaceIndentation = FormatStyle::NI_All;
2550   EXPECT_EQ("namespace out { namespace in {\n"
2551             "  int i;\n"
2552             "}} // namespace out::in",
2553             format("namespace out {\n"
2554                    "namespace in {\n"
2555                    "int i;\n"
2556                    "} // namespace in\n"
2557                    "} // namespace out",
2558                    Style));
2559   EXPECT_EQ("namespace out { namespace mid {\n"
2560             "  namespace in {\n"
2561             "    int j;\n"
2562             "  } // namespace in\n"
2563             "  int k;\n"
2564             "}} // namespace out::mid",
2565             format("namespace out { namespace mid {\n"
2566                    "namespace in { int j; } // namespace in\n"
2567                    "int k; }} // namespace out::mid",
2568                    Style));
2569 
2570   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2571   EXPECT_EQ("namespace out { namespace in {\n"
2572             "  int i;\n"
2573             "}} // namespace out::in",
2574             format("namespace out {\n"
2575                    "namespace in {\n"
2576                    "int i;\n"
2577                    "} // namespace in\n"
2578                    "} // namespace out",
2579                    Style));
2580   EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
2581             "  int i;\n"
2582             "}}} // namespace out::mid::in",
2583             format("namespace out {\n"
2584                    "namespace mid {\n"
2585                    "namespace in {\n"
2586                    "int i;\n"
2587                    "} // namespace in\n"
2588                    "} // namespace mid\n"
2589                    "} // namespace out",
2590                    Style));
2591 }
2592 
2593 TEST_F(FormatTest, FormatsExternC) {
2594   verifyFormat("extern \"C\" {\nint a;");
2595   verifyFormat("extern \"C\" {}");
2596   verifyFormat("extern \"C\" {\n"
2597                "int foo();\n"
2598                "}");
2599   verifyFormat("extern \"C\" int foo() {}");
2600   verifyFormat("extern \"C\" int foo();");
2601   verifyFormat("extern \"C\" int foo() {\n"
2602                "  int i = 42;\n"
2603                "  return i;\n"
2604                "}");
2605 
2606   FormatStyle Style = getLLVMStyle();
2607   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2608   Style.BraceWrapping.AfterFunction = true;
2609   verifyFormat("extern \"C\" int foo() {}", Style);
2610   verifyFormat("extern \"C\" int foo();", Style);
2611   verifyFormat("extern \"C\" int foo()\n"
2612                "{\n"
2613                "  int i = 42;\n"
2614                "  return i;\n"
2615                "}",
2616                Style);
2617 
2618   Style.BraceWrapping.AfterExternBlock = true;
2619   Style.BraceWrapping.SplitEmptyRecord = false;
2620   verifyFormat("extern \"C\"\n"
2621                "{}",
2622                Style);
2623   verifyFormat("extern \"C\"\n"
2624                "{\n"
2625                "  int foo();\n"
2626                "}",
2627                Style);
2628 }
2629 
2630 TEST_F(FormatTest, IndentExternBlockStyle) {
2631   FormatStyle Style = getLLVMStyle();
2632   Style.IndentWidth = 2;
2633 
2634   Style.IndentExternBlock = FormatStyle::IEBS_Indent;
2635   verifyFormat("extern \"C\" { /*9*/\n}", Style);
2636   verifyFormat("extern \"C\" {\n"
2637                "  int foo10();\n"
2638                "}",
2639                Style);
2640 
2641   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
2642   verifyFormat("extern \"C\" { /*11*/\n}", Style);
2643   verifyFormat("extern \"C\" {\n"
2644                "int foo12();\n"
2645                "}",
2646                Style);
2647 
2648   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2649   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2650   Style.BraceWrapping.AfterExternBlock = true;
2651   verifyFormat("extern \"C\"\n{ /*13*/\n}", Style);
2652   verifyFormat("extern \"C\"\n{\n"
2653                "  int foo14();\n"
2654                "}",
2655                Style);
2656 
2657   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2658   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2659   Style.BraceWrapping.AfterExternBlock = false;
2660   verifyFormat("extern \"C\" { /*15*/\n}", Style);
2661   verifyFormat("extern \"C\" {\n"
2662                "int foo16();\n"
2663                "}",
2664                Style);
2665 }
2666 
2667 TEST_F(FormatTest, FormatsInlineASM) {
2668   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2669   verifyFormat("asm(\"nop\" ::: \"memory\");");
2670   verifyFormat(
2671       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
2672       "    \"cpuid\\n\\t\"\n"
2673       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
2674       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
2675       "    : \"a\"(value));");
2676   EXPECT_EQ(
2677       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2678       "  __asm {\n"
2679       "        mov     edx,[that] // vtable in edx\n"
2680       "        mov     eax,methodIndex\n"
2681       "        call    [edx][eax*4] // stdcall\n"
2682       "  }\n"
2683       "}",
2684       format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
2685              "    __asm {\n"
2686              "        mov     edx,[that] // vtable in edx\n"
2687              "        mov     eax,methodIndex\n"
2688              "        call    [edx][eax*4] // stdcall\n"
2689              "    }\n"
2690              "}"));
2691   EXPECT_EQ("_asm {\n"
2692             "  xor eax, eax;\n"
2693             "  cpuid;\n"
2694             "}",
2695             format("_asm {\n"
2696                    "  xor eax, eax;\n"
2697                    "  cpuid;\n"
2698                    "}"));
2699   verifyFormat("void function() {\n"
2700                "  // comment\n"
2701                "  asm(\"\");\n"
2702                "}");
2703   EXPECT_EQ("__asm {\n"
2704             "}\n"
2705             "int i;",
2706             format("__asm   {\n"
2707                    "}\n"
2708                    "int   i;"));
2709 }
2710 
2711 TEST_F(FormatTest, FormatTryCatch) {
2712   verifyFormat("try {\n"
2713                "  throw a * b;\n"
2714                "} catch (int a) {\n"
2715                "  // Do nothing.\n"
2716                "} catch (...) {\n"
2717                "  exit(42);\n"
2718                "}");
2719 
2720   // Function-level try statements.
2721   verifyFormat("int f() try { return 4; } catch (...) {\n"
2722                "  return 5;\n"
2723                "}");
2724   verifyFormat("class A {\n"
2725                "  int a;\n"
2726                "  A() try : a(0) {\n"
2727                "  } catch (...) {\n"
2728                "    throw;\n"
2729                "  }\n"
2730                "};\n");
2731 
2732   // Incomplete try-catch blocks.
2733   verifyIncompleteFormat("try {} catch (");
2734 }
2735 
2736 TEST_F(FormatTest, FormatTryAsAVariable) {
2737   verifyFormat("int try;");
2738   verifyFormat("int try, size;");
2739   verifyFormat("try = foo();");
2740   verifyFormat("if (try < size) {\n  return true;\n}");
2741 
2742   verifyFormat("int catch;");
2743   verifyFormat("int catch, size;");
2744   verifyFormat("catch = foo();");
2745   verifyFormat("if (catch < size) {\n  return true;\n}");
2746 
2747   FormatStyle Style = getLLVMStyle();
2748   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2749   Style.BraceWrapping.AfterFunction = true;
2750   Style.BraceWrapping.BeforeCatch = true;
2751   verifyFormat("try {\n"
2752                "  int bar = 1;\n"
2753                "}\n"
2754                "catch (...) {\n"
2755                "  int bar = 1;\n"
2756                "}",
2757                Style);
2758   verifyFormat("#if NO_EX\n"
2759                "try\n"
2760                "#endif\n"
2761                "{\n"
2762                "}\n"
2763                "#if NO_EX\n"
2764                "catch (...) {\n"
2765                "}",
2766                Style);
2767   verifyFormat("try /* abc */ {\n"
2768                "  int bar = 1;\n"
2769                "}\n"
2770                "catch (...) {\n"
2771                "  int bar = 1;\n"
2772                "}",
2773                Style);
2774   verifyFormat("try\n"
2775                "// abc\n"
2776                "{\n"
2777                "  int bar = 1;\n"
2778                "}\n"
2779                "catch (...) {\n"
2780                "  int bar = 1;\n"
2781                "}",
2782                Style);
2783 }
2784 
2785 TEST_F(FormatTest, FormatSEHTryCatch) {
2786   verifyFormat("__try {\n"
2787                "  int a = b * c;\n"
2788                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2789                "  // Do nothing.\n"
2790                "}");
2791 
2792   verifyFormat("__try {\n"
2793                "  int a = b * c;\n"
2794                "} __finally {\n"
2795                "  // Do nothing.\n"
2796                "}");
2797 
2798   verifyFormat("DEBUG({\n"
2799                "  __try {\n"
2800                "  } __finally {\n"
2801                "  }\n"
2802                "});\n");
2803 }
2804 
2805 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2806   verifyFormat("try {\n"
2807                "  f();\n"
2808                "} catch {\n"
2809                "  g();\n"
2810                "}");
2811   verifyFormat("try {\n"
2812                "  f();\n"
2813                "} catch (A a) MACRO(x) {\n"
2814                "  g();\n"
2815                "} catch (B b) MACRO(x) {\n"
2816                "  g();\n"
2817                "}");
2818 }
2819 
2820 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2821   FormatStyle Style = getLLVMStyle();
2822   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2823                           FormatStyle::BS_WebKit}) {
2824     Style.BreakBeforeBraces = BraceStyle;
2825     verifyFormat("try {\n"
2826                  "  // something\n"
2827                  "} catch (...) {\n"
2828                  "  // something\n"
2829                  "}",
2830                  Style);
2831   }
2832   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2833   verifyFormat("try {\n"
2834                "  // something\n"
2835                "}\n"
2836                "catch (...) {\n"
2837                "  // something\n"
2838                "}",
2839                Style);
2840   verifyFormat("__try {\n"
2841                "  // something\n"
2842                "}\n"
2843                "__finally {\n"
2844                "  // something\n"
2845                "}",
2846                Style);
2847   verifyFormat("@try {\n"
2848                "  // something\n"
2849                "}\n"
2850                "@finally {\n"
2851                "  // something\n"
2852                "}",
2853                Style);
2854   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2855   verifyFormat("try\n"
2856                "{\n"
2857                "  // something\n"
2858                "}\n"
2859                "catch (...)\n"
2860                "{\n"
2861                "  // something\n"
2862                "}",
2863                Style);
2864   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2865   verifyFormat("try\n"
2866                "  {\n"
2867                "  // something white\n"
2868                "  }\n"
2869                "catch (...)\n"
2870                "  {\n"
2871                "  // something white\n"
2872                "  }",
2873                Style);
2874   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2875   verifyFormat("try\n"
2876                "  {\n"
2877                "    // something\n"
2878                "  }\n"
2879                "catch (...)\n"
2880                "  {\n"
2881                "    // something\n"
2882                "  }",
2883                Style);
2884   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2885   Style.BraceWrapping.BeforeCatch = true;
2886   verifyFormat("try {\n"
2887                "  // something\n"
2888                "}\n"
2889                "catch (...) {\n"
2890                "  // something\n"
2891                "}",
2892                Style);
2893 }
2894 
2895 TEST_F(FormatTest, StaticInitializers) {
2896   verifyFormat("static SomeClass SC = {1, 'a'};");
2897 
2898   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2899                "    100000000, "
2900                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2901 
2902   // Here, everything other than the "}" would fit on a line.
2903   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2904                "    10000000000000000000000000};");
2905   EXPECT_EQ("S s = {a,\n"
2906             "\n"
2907             "       b};",
2908             format("S s = {\n"
2909                    "  a,\n"
2910                    "\n"
2911                    "  b\n"
2912                    "};"));
2913 
2914   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2915   // line. However, the formatting looks a bit off and this probably doesn't
2916   // happen often in practice.
2917   verifyFormat("static int Variable[1] = {\n"
2918                "    {1000000000000000000000000000000000000}};",
2919                getLLVMStyleWithColumns(40));
2920 }
2921 
2922 TEST_F(FormatTest, DesignatedInitializers) {
2923   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2924   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2925                "                    .bbbbbbbbbb = 2,\n"
2926                "                    .cccccccccc = 3,\n"
2927                "                    .dddddddddd = 4,\n"
2928                "                    .eeeeeeeeee = 5};");
2929   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2930                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2931                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2932                "    .ccccccccccccccccccccccccccc = 3,\n"
2933                "    .ddddddddddddddddddddddddddd = 4,\n"
2934                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2935 
2936   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2937 
2938   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2939   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2940                "                    [2] = bbbbbbbbbb,\n"
2941                "                    [3] = cccccccccc,\n"
2942                "                    [4] = dddddddddd,\n"
2943                "                    [5] = eeeeeeeeee};");
2944   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2945                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2946                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2947                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2948                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2949                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2950 }
2951 
2952 TEST_F(FormatTest, NestedStaticInitializers) {
2953   verifyFormat("static A x = {{{}}};\n");
2954   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2955                "               {init1, init2, init3, init4}}};",
2956                getLLVMStyleWithColumns(50));
2957 
2958   verifyFormat("somes Status::global_reps[3] = {\n"
2959                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2960                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2961                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2962                getLLVMStyleWithColumns(60));
2963   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2964                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2965                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2966                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2967   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2968                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2969                "rect.fTop}};");
2970 
2971   verifyFormat(
2972       "SomeArrayOfSomeType a = {\n"
2973       "    {{1, 2, 3},\n"
2974       "     {1, 2, 3},\n"
2975       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2976       "      333333333333333333333333333333},\n"
2977       "     {1, 2, 3},\n"
2978       "     {1, 2, 3}}};");
2979   verifyFormat(
2980       "SomeArrayOfSomeType a = {\n"
2981       "    {{1, 2, 3}},\n"
2982       "    {{1, 2, 3}},\n"
2983       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2984       "      333333333333333333333333333333}},\n"
2985       "    {{1, 2, 3}},\n"
2986       "    {{1, 2, 3}}};");
2987 
2988   verifyFormat("struct {\n"
2989                "  unsigned bit;\n"
2990                "  const char *const name;\n"
2991                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2992                "                 {kOsWin, \"Windows\"},\n"
2993                "                 {kOsLinux, \"Linux\"},\n"
2994                "                 {kOsCrOS, \"Chrome OS\"}};");
2995   verifyFormat("struct {\n"
2996                "  unsigned bit;\n"
2997                "  const char *const name;\n"
2998                "} kBitsToOs[] = {\n"
2999                "    {kOsMac, \"Mac\"},\n"
3000                "    {kOsWin, \"Windows\"},\n"
3001                "    {kOsLinux, \"Linux\"},\n"
3002                "    {kOsCrOS, \"Chrome OS\"},\n"
3003                "};");
3004 }
3005 
3006 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
3007   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3008                "                      \\\n"
3009                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
3010 }
3011 
3012 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
3013   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
3014                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
3015 
3016   // Do break defaulted and deleted functions.
3017   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
3018                "    default;",
3019                getLLVMStyleWithColumns(40));
3020   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
3021                "    delete;",
3022                getLLVMStyleWithColumns(40));
3023 }
3024 
3025 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
3026   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
3027                getLLVMStyleWithColumns(40));
3028   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
3029                getLLVMStyleWithColumns(40));
3030   EXPECT_EQ("#define Q                              \\\n"
3031             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
3032             "  \"aaaaaaaa.cpp\"",
3033             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
3034                    getLLVMStyleWithColumns(40)));
3035 }
3036 
3037 TEST_F(FormatTest, UnderstandsLinePPDirective) {
3038   EXPECT_EQ("# 123 \"A string literal\"",
3039             format("   #     123    \"A string literal\""));
3040 }
3041 
3042 TEST_F(FormatTest, LayoutUnknownPPDirective) {
3043   EXPECT_EQ("#;", format("#;"));
3044   verifyFormat("#\n;\n;\n;");
3045 }
3046 
3047 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
3048   EXPECT_EQ("#line 42 \"test\"\n",
3049             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
3050   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
3051                                     getLLVMStyleWithColumns(12)));
3052 }
3053 
3054 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
3055   EXPECT_EQ("#line 42 \"test\"",
3056             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
3057   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
3058 }
3059 
3060 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
3061   verifyFormat("#define A \\x20");
3062   verifyFormat("#define A \\ x20");
3063   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
3064   verifyFormat("#define A ''");
3065   verifyFormat("#define A ''qqq");
3066   verifyFormat("#define A `qqq");
3067   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
3068   EXPECT_EQ("const char *c = STRINGIFY(\n"
3069             "\\na : b);",
3070             format("const char * c = STRINGIFY(\n"
3071                    "\\na : b);"));
3072 
3073   verifyFormat("a\r\\");
3074   verifyFormat("a\v\\");
3075   verifyFormat("a\f\\");
3076 }
3077 
3078 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
3079   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
3080   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
3081   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
3082   // FIXME: We never break before the macro name.
3083   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
3084 
3085   verifyFormat("#define A A\n#define A A");
3086   verifyFormat("#define A(X) A\n#define A A");
3087 
3088   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
3089   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
3090 }
3091 
3092 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
3093   EXPECT_EQ("// somecomment\n"
3094             "#include \"a.h\"\n"
3095             "#define A(  \\\n"
3096             "    A, B)\n"
3097             "#include \"b.h\"\n"
3098             "// somecomment\n",
3099             format("  // somecomment\n"
3100                    "  #include \"a.h\"\n"
3101                    "#define A(A,\\\n"
3102                    "    B)\n"
3103                    "    #include \"b.h\"\n"
3104                    " // somecomment\n",
3105                    getLLVMStyleWithColumns(13)));
3106 }
3107 
3108 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
3109 
3110 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
3111   EXPECT_EQ("#define A    \\\n"
3112             "  c;         \\\n"
3113             "  e;\n"
3114             "f;",
3115             format("#define A c; e;\n"
3116                    "f;",
3117                    getLLVMStyleWithColumns(14)));
3118 }
3119 
3120 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3121 
3122 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3123   EXPECT_EQ("int x,\n"
3124             "#define A\n"
3125             "    y;",
3126             format("int x,\n#define A\ny;"));
3127 }
3128 
3129 TEST_F(FormatTest, HashInMacroDefinition) {
3130   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3131   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
3132   verifyFormat("#define A  \\\n"
3133                "  {        \\\n"
3134                "    f(#c); \\\n"
3135                "  }",
3136                getLLVMStyleWithColumns(11));
3137 
3138   verifyFormat("#define A(X)         \\\n"
3139                "  void function##X()",
3140                getLLVMStyleWithColumns(22));
3141 
3142   verifyFormat("#define A(a, b, c)   \\\n"
3143                "  void a##b##c()",
3144                getLLVMStyleWithColumns(22));
3145 
3146   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3147 }
3148 
3149 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3150   EXPECT_EQ("#define A (x)", format("#define A (x)"));
3151   EXPECT_EQ("#define A(x)", format("#define A(x)"));
3152 
3153   FormatStyle Style = getLLVMStyle();
3154   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3155   verifyFormat("#define true ((foo)1)", Style);
3156   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3157   verifyFormat("#define false((foo)0)", Style);
3158 }
3159 
3160 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3161   EXPECT_EQ("#define A b;", format("#define A \\\n"
3162                                    "          \\\n"
3163                                    "  b;",
3164                                    getLLVMStyleWithColumns(25)));
3165   EXPECT_EQ("#define A \\\n"
3166             "          \\\n"
3167             "  a;      \\\n"
3168             "  b;",
3169             format("#define A \\\n"
3170                    "          \\\n"
3171                    "  a;      \\\n"
3172                    "  b;",
3173                    getLLVMStyleWithColumns(11)));
3174   EXPECT_EQ("#define A \\\n"
3175             "  a;      \\\n"
3176             "          \\\n"
3177             "  b;",
3178             format("#define A \\\n"
3179                    "  a;      \\\n"
3180                    "          \\\n"
3181                    "  b;",
3182                    getLLVMStyleWithColumns(11)));
3183 }
3184 
3185 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3186   verifyIncompleteFormat("#define A :");
3187   verifyFormat("#define SOMECASES  \\\n"
3188                "  case 1:          \\\n"
3189                "  case 2\n",
3190                getLLVMStyleWithColumns(20));
3191   verifyFormat("#define MACRO(a) \\\n"
3192                "  if (a)         \\\n"
3193                "    f();         \\\n"
3194                "  else           \\\n"
3195                "    g()",
3196                getLLVMStyleWithColumns(18));
3197   verifyFormat("#define A template <typename T>");
3198   verifyIncompleteFormat("#define STR(x) #x\n"
3199                          "f(STR(this_is_a_string_literal{));");
3200   verifyFormat("#pragma omp threadprivate( \\\n"
3201                "    y)), // expected-warning",
3202                getLLVMStyleWithColumns(28));
3203   verifyFormat("#d, = };");
3204   verifyFormat("#if \"a");
3205   verifyIncompleteFormat("({\n"
3206                          "#define b     \\\n"
3207                          "  }           \\\n"
3208                          "  a\n"
3209                          "a",
3210                          getLLVMStyleWithColumns(15));
3211   verifyFormat("#define A     \\\n"
3212                "  {           \\\n"
3213                "    {\n"
3214                "#define B     \\\n"
3215                "  }           \\\n"
3216                "  }",
3217                getLLVMStyleWithColumns(15));
3218   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3219   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3220   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3221   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
3222 }
3223 
3224 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3225   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3226   EXPECT_EQ("class A : public QObject {\n"
3227             "  Q_OBJECT\n"
3228             "\n"
3229             "  A() {}\n"
3230             "};",
3231             format("class A  :  public QObject {\n"
3232                    "     Q_OBJECT\n"
3233                    "\n"
3234                    "  A() {\n}\n"
3235                    "}  ;"));
3236   EXPECT_EQ("MACRO\n"
3237             "/*static*/ int i;",
3238             format("MACRO\n"
3239                    " /*static*/ int   i;"));
3240   EXPECT_EQ("SOME_MACRO\n"
3241             "namespace {\n"
3242             "void f();\n"
3243             "} // namespace",
3244             format("SOME_MACRO\n"
3245                    "  namespace    {\n"
3246                    "void   f(  );\n"
3247                    "} // namespace"));
3248   // Only if the identifier contains at least 5 characters.
3249   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3250   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3251   // Only if everything is upper case.
3252   EXPECT_EQ("class A : public QObject {\n"
3253             "  Q_Object A() {}\n"
3254             "};",
3255             format("class A  :  public QObject {\n"
3256                    "     Q_Object\n"
3257                    "  A() {\n}\n"
3258                    "}  ;"));
3259 
3260   // Only if the next line can actually start an unwrapped line.
3261   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3262             format("SOME_WEIRD_LOG_MACRO\n"
3263                    "<< SomeThing;"));
3264 
3265   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3266                "(n, buffers))\n",
3267                getChromiumStyle(FormatStyle::LK_Cpp));
3268 
3269   // See PR41483
3270   EXPECT_EQ("/**/ FOO(a)\n"
3271             "FOO(b)",
3272             format("/**/ FOO(a)\n"
3273                    "FOO(b)"));
3274 }
3275 
3276 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3277   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3278             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3279             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3280             "class X {};\n"
3281             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3282             "int *createScopDetectionPass() { return 0; }",
3283             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3284                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3285                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3286                    "  class X {};\n"
3287                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3288                    "  int *createScopDetectionPass() { return 0; }"));
3289   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3290   // braces, so that inner block is indented one level more.
3291   EXPECT_EQ("int q() {\n"
3292             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3293             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3294             "  IPC_END_MESSAGE_MAP()\n"
3295             "}",
3296             format("int q() {\n"
3297                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3298                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3299                    "  IPC_END_MESSAGE_MAP()\n"
3300                    "}"));
3301 
3302   // Same inside macros.
3303   EXPECT_EQ("#define LIST(L) \\\n"
3304             "  L(A)          \\\n"
3305             "  L(B)          \\\n"
3306             "  L(C)",
3307             format("#define LIST(L) \\\n"
3308                    "  L(A) \\\n"
3309                    "  L(B) \\\n"
3310                    "  L(C)",
3311                    getGoogleStyle()));
3312 
3313   // These must not be recognized as macros.
3314   EXPECT_EQ("int q() {\n"
3315             "  f(x);\n"
3316             "  f(x) {}\n"
3317             "  f(x)->g();\n"
3318             "  f(x)->*g();\n"
3319             "  f(x).g();\n"
3320             "  f(x) = x;\n"
3321             "  f(x) += x;\n"
3322             "  f(x) -= x;\n"
3323             "  f(x) *= x;\n"
3324             "  f(x) /= x;\n"
3325             "  f(x) %= x;\n"
3326             "  f(x) &= x;\n"
3327             "  f(x) |= x;\n"
3328             "  f(x) ^= x;\n"
3329             "  f(x) >>= x;\n"
3330             "  f(x) <<= x;\n"
3331             "  f(x)[y].z();\n"
3332             "  LOG(INFO) << x;\n"
3333             "  ifstream(x) >> x;\n"
3334             "}\n",
3335             format("int q() {\n"
3336                    "  f(x)\n;\n"
3337                    "  f(x)\n {}\n"
3338                    "  f(x)\n->g();\n"
3339                    "  f(x)\n->*g();\n"
3340                    "  f(x)\n.g();\n"
3341                    "  f(x)\n = x;\n"
3342                    "  f(x)\n += x;\n"
3343                    "  f(x)\n -= x;\n"
3344                    "  f(x)\n *= x;\n"
3345                    "  f(x)\n /= x;\n"
3346                    "  f(x)\n %= x;\n"
3347                    "  f(x)\n &= x;\n"
3348                    "  f(x)\n |= x;\n"
3349                    "  f(x)\n ^= x;\n"
3350                    "  f(x)\n >>= x;\n"
3351                    "  f(x)\n <<= x;\n"
3352                    "  f(x)\n[y].z();\n"
3353                    "  LOG(INFO)\n << x;\n"
3354                    "  ifstream(x)\n >> x;\n"
3355                    "}\n"));
3356   EXPECT_EQ("int q() {\n"
3357             "  F(x)\n"
3358             "  if (1) {\n"
3359             "  }\n"
3360             "  F(x)\n"
3361             "  while (1) {\n"
3362             "  }\n"
3363             "  F(x)\n"
3364             "  G(x);\n"
3365             "  F(x)\n"
3366             "  try {\n"
3367             "    Q();\n"
3368             "  } catch (...) {\n"
3369             "  }\n"
3370             "}\n",
3371             format("int q() {\n"
3372                    "F(x)\n"
3373                    "if (1) {}\n"
3374                    "F(x)\n"
3375                    "while (1) {}\n"
3376                    "F(x)\n"
3377                    "G(x);\n"
3378                    "F(x)\n"
3379                    "try { Q(); } catch (...) {}\n"
3380                    "}\n"));
3381   EXPECT_EQ("class A {\n"
3382             "  A() : t(0) {}\n"
3383             "  A(int i) noexcept() : {}\n"
3384             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3385             "  try : t(0) {\n"
3386             "  } catch (...) {\n"
3387             "  }\n"
3388             "};",
3389             format("class A {\n"
3390                    "  A()\n : t(0) {}\n"
3391                    "  A(int i)\n noexcept() : {}\n"
3392                    "  A(X x)\n"
3393                    "  try : t(0) {} catch (...) {}\n"
3394                    "};"));
3395   FormatStyle Style = getLLVMStyle();
3396   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3397   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3398   Style.BraceWrapping.AfterFunction = true;
3399   EXPECT_EQ("void f()\n"
3400             "try\n"
3401             "{\n"
3402             "}",
3403             format("void f() try {\n"
3404                    "}",
3405                    Style));
3406   EXPECT_EQ("class SomeClass {\n"
3407             "public:\n"
3408             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3409             "};",
3410             format("class SomeClass {\n"
3411                    "public:\n"
3412                    "  SomeClass()\n"
3413                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3414                    "};"));
3415   EXPECT_EQ("class SomeClass {\n"
3416             "public:\n"
3417             "  SomeClass()\n"
3418             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3419             "};",
3420             format("class SomeClass {\n"
3421                    "public:\n"
3422                    "  SomeClass()\n"
3423                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3424                    "};",
3425                    getLLVMStyleWithColumns(40)));
3426 
3427   verifyFormat("MACRO(>)");
3428 
3429   // Some macros contain an implicit semicolon.
3430   Style = getLLVMStyle();
3431   Style.StatementMacros.push_back("FOO");
3432   verifyFormat("FOO(a) int b = 0;");
3433   verifyFormat("FOO(a)\n"
3434                "int b = 0;",
3435                Style);
3436   verifyFormat("FOO(a);\n"
3437                "int b = 0;",
3438                Style);
3439   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3440                "int b = 0;",
3441                Style);
3442   verifyFormat("FOO()\n"
3443                "int b = 0;",
3444                Style);
3445   verifyFormat("FOO\n"
3446                "int b = 0;",
3447                Style);
3448   verifyFormat("void f() {\n"
3449                "  FOO(a)\n"
3450                "  return a;\n"
3451                "}",
3452                Style);
3453   verifyFormat("FOO(a)\n"
3454                "FOO(b)",
3455                Style);
3456   verifyFormat("int a = 0;\n"
3457                "FOO(b)\n"
3458                "int c = 0;",
3459                Style);
3460   verifyFormat("int a = 0;\n"
3461                "int x = FOO(a)\n"
3462                "int b = 0;",
3463                Style);
3464   verifyFormat("void foo(int a) { FOO(a) }\n"
3465                "uint32_t bar() {}",
3466                Style);
3467 }
3468 
3469 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3470   verifyFormat("#define A \\\n"
3471                "  f({     \\\n"
3472                "    g();  \\\n"
3473                "  });",
3474                getLLVMStyleWithColumns(11));
3475 }
3476 
3477 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3478   FormatStyle Style = getLLVMStyle();
3479   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3480   Style.ColumnLimit = 40;
3481   verifyFormat("#ifdef _WIN32\n"
3482                "#define A 0\n"
3483                "#ifdef VAR2\n"
3484                "#define B 1\n"
3485                "#include <someheader.h>\n"
3486                "#define MACRO                          \\\n"
3487                "  some_very_long_func_aaaaaaaaaa();\n"
3488                "#endif\n"
3489                "#else\n"
3490                "#define A 1\n"
3491                "#endif",
3492                Style);
3493   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3494   verifyFormat("#ifdef _WIN32\n"
3495                "#  define A 0\n"
3496                "#  ifdef VAR2\n"
3497                "#    define B 1\n"
3498                "#    include <someheader.h>\n"
3499                "#    define MACRO                      \\\n"
3500                "      some_very_long_func_aaaaaaaaaa();\n"
3501                "#  endif\n"
3502                "#else\n"
3503                "#  define A 1\n"
3504                "#endif",
3505                Style);
3506   verifyFormat("#if A\n"
3507                "#  define MACRO                        \\\n"
3508                "    void a(int x) {                    \\\n"
3509                "      b();                             \\\n"
3510                "      c();                             \\\n"
3511                "      d();                             \\\n"
3512                "      e();                             \\\n"
3513                "      f();                             \\\n"
3514                "    }\n"
3515                "#endif",
3516                Style);
3517   // Comments before include guard.
3518   verifyFormat("// file comment\n"
3519                "// file comment\n"
3520                "#ifndef HEADER_H\n"
3521                "#define HEADER_H\n"
3522                "code();\n"
3523                "#endif",
3524                Style);
3525   // Test with include guards.
3526   verifyFormat("#ifndef HEADER_H\n"
3527                "#define HEADER_H\n"
3528                "code();\n"
3529                "#endif",
3530                Style);
3531   // Include guards must have a #define with the same variable immediately
3532   // after #ifndef.
3533   verifyFormat("#ifndef NOT_GUARD\n"
3534                "#  define FOO\n"
3535                "code();\n"
3536                "#endif",
3537                Style);
3538 
3539   // Include guards must cover the entire file.
3540   verifyFormat("code();\n"
3541                "code();\n"
3542                "#ifndef NOT_GUARD\n"
3543                "#  define NOT_GUARD\n"
3544                "code();\n"
3545                "#endif",
3546                Style);
3547   verifyFormat("#ifndef NOT_GUARD\n"
3548                "#  define NOT_GUARD\n"
3549                "code();\n"
3550                "#endif\n"
3551                "code();",
3552                Style);
3553   // Test with trailing blank lines.
3554   verifyFormat("#ifndef HEADER_H\n"
3555                "#define HEADER_H\n"
3556                "code();\n"
3557                "#endif\n",
3558                Style);
3559   // Include guards don't have #else.
3560   verifyFormat("#ifndef NOT_GUARD\n"
3561                "#  define NOT_GUARD\n"
3562                "code();\n"
3563                "#else\n"
3564                "#endif",
3565                Style);
3566   verifyFormat("#ifndef NOT_GUARD\n"
3567                "#  define NOT_GUARD\n"
3568                "code();\n"
3569                "#elif FOO\n"
3570                "#endif",
3571                Style);
3572   // Non-identifier #define after potential include guard.
3573   verifyFormat("#ifndef FOO\n"
3574                "#  define 1\n"
3575                "#endif\n",
3576                Style);
3577   // #if closes past last non-preprocessor line.
3578   verifyFormat("#ifndef FOO\n"
3579                "#define FOO\n"
3580                "#if 1\n"
3581                "int i;\n"
3582                "#  define A 0\n"
3583                "#endif\n"
3584                "#endif\n",
3585                Style);
3586   // Don't crash if there is an #elif directive without a condition.
3587   verifyFormat("#if 1\n"
3588                "int x;\n"
3589                "#elif\n"
3590                "int y;\n"
3591                "#else\n"
3592                "int z;\n"
3593                "#endif",
3594                Style);
3595   // FIXME: This doesn't handle the case where there's code between the
3596   // #ifndef and #define but all other conditions hold. This is because when
3597   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3598   // previous code line yet, so we can't detect it.
3599   EXPECT_EQ("#ifndef NOT_GUARD\n"
3600             "code();\n"
3601             "#define NOT_GUARD\n"
3602             "code();\n"
3603             "#endif",
3604             format("#ifndef NOT_GUARD\n"
3605                    "code();\n"
3606                    "#  define NOT_GUARD\n"
3607                    "code();\n"
3608                    "#endif",
3609                    Style));
3610   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3611   // be outside an include guard. Examples are #pragma once and
3612   // #pragma GCC diagnostic, or anything else that does not change the meaning
3613   // of the file if it's included multiple times.
3614   EXPECT_EQ("#ifdef WIN32\n"
3615             "#  pragma once\n"
3616             "#endif\n"
3617             "#ifndef HEADER_H\n"
3618             "#  define HEADER_H\n"
3619             "code();\n"
3620             "#endif",
3621             format("#ifdef WIN32\n"
3622                    "#  pragma once\n"
3623                    "#endif\n"
3624                    "#ifndef HEADER_H\n"
3625                    "#define HEADER_H\n"
3626                    "code();\n"
3627                    "#endif",
3628                    Style));
3629   // FIXME: This does not detect when there is a single non-preprocessor line
3630   // in front of an include-guard-like structure where other conditions hold
3631   // because ScopedLineState hides the line.
3632   EXPECT_EQ("code();\n"
3633             "#ifndef HEADER_H\n"
3634             "#define HEADER_H\n"
3635             "code();\n"
3636             "#endif",
3637             format("code();\n"
3638                    "#ifndef HEADER_H\n"
3639                    "#  define HEADER_H\n"
3640                    "code();\n"
3641                    "#endif",
3642                    Style));
3643   // Keep comments aligned with #, otherwise indent comments normally. These
3644   // tests cannot use verifyFormat because messUp manipulates leading
3645   // whitespace.
3646   {
3647     const char *Expected = ""
3648                            "void f() {\n"
3649                            "#if 1\n"
3650                            "// Preprocessor aligned.\n"
3651                            "#  define A 0\n"
3652                            "  // Code. Separated by blank line.\n"
3653                            "\n"
3654                            "#  define B 0\n"
3655                            "  // Code. Not aligned with #\n"
3656                            "#  define C 0\n"
3657                            "#endif";
3658     const char *ToFormat = ""
3659                            "void f() {\n"
3660                            "#if 1\n"
3661                            "// Preprocessor aligned.\n"
3662                            "#  define A 0\n"
3663                            "// Code. Separated by blank line.\n"
3664                            "\n"
3665                            "#  define B 0\n"
3666                            "   // Code. Not aligned with #\n"
3667                            "#  define C 0\n"
3668                            "#endif";
3669     EXPECT_EQ(Expected, format(ToFormat, Style));
3670     EXPECT_EQ(Expected, format(Expected, Style));
3671   }
3672   // Keep block quotes aligned.
3673   {
3674     const char *Expected = ""
3675                            "void f() {\n"
3676                            "#if 1\n"
3677                            "/* Preprocessor aligned. */\n"
3678                            "#  define A 0\n"
3679                            "  /* Code. Separated by blank line. */\n"
3680                            "\n"
3681                            "#  define B 0\n"
3682                            "  /* Code. Not aligned with # */\n"
3683                            "#  define C 0\n"
3684                            "#endif";
3685     const char *ToFormat = ""
3686                            "void f() {\n"
3687                            "#if 1\n"
3688                            "/* Preprocessor aligned. */\n"
3689                            "#  define A 0\n"
3690                            "/* Code. Separated by blank line. */\n"
3691                            "\n"
3692                            "#  define B 0\n"
3693                            "   /* Code. Not aligned with # */\n"
3694                            "#  define C 0\n"
3695                            "#endif";
3696     EXPECT_EQ(Expected, format(ToFormat, Style));
3697     EXPECT_EQ(Expected, format(Expected, Style));
3698   }
3699   // Keep comments aligned with un-indented directives.
3700   {
3701     const char *Expected = ""
3702                            "void f() {\n"
3703                            "// Preprocessor aligned.\n"
3704                            "#define A 0\n"
3705                            "  // Code. Separated by blank line.\n"
3706                            "\n"
3707                            "#define B 0\n"
3708                            "  // Code. Not aligned with #\n"
3709                            "#define C 0\n";
3710     const char *ToFormat = ""
3711                            "void f() {\n"
3712                            "// Preprocessor aligned.\n"
3713                            "#define A 0\n"
3714                            "// Code. Separated by blank line.\n"
3715                            "\n"
3716                            "#define B 0\n"
3717                            "   // Code. Not aligned with #\n"
3718                            "#define C 0\n";
3719     EXPECT_EQ(Expected, format(ToFormat, Style));
3720     EXPECT_EQ(Expected, format(Expected, Style));
3721   }
3722   // Test AfterHash with tabs.
3723   {
3724     FormatStyle Tabbed = Style;
3725     Tabbed.UseTab = FormatStyle::UT_Always;
3726     Tabbed.IndentWidth = 8;
3727     Tabbed.TabWidth = 8;
3728     verifyFormat("#ifdef _WIN32\n"
3729                  "#\tdefine A 0\n"
3730                  "#\tifdef VAR2\n"
3731                  "#\t\tdefine B 1\n"
3732                  "#\t\tinclude <someheader.h>\n"
3733                  "#\t\tdefine MACRO          \\\n"
3734                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3735                  "#\tendif\n"
3736                  "#else\n"
3737                  "#\tdefine A 1\n"
3738                  "#endif",
3739                  Tabbed);
3740   }
3741 
3742   // Regression test: Multiline-macro inside include guards.
3743   verifyFormat("#ifndef HEADER_H\n"
3744                "#define HEADER_H\n"
3745                "#define A()        \\\n"
3746                "  int i;           \\\n"
3747                "  int j;\n"
3748                "#endif // HEADER_H",
3749                getLLVMStyleWithColumns(20));
3750 
3751   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3752   // Basic before hash indent tests
3753   verifyFormat("#ifdef _WIN32\n"
3754                "  #define A 0\n"
3755                "  #ifdef VAR2\n"
3756                "    #define B 1\n"
3757                "    #include <someheader.h>\n"
3758                "    #define MACRO                      \\\n"
3759                "      some_very_long_func_aaaaaaaaaa();\n"
3760                "  #endif\n"
3761                "#else\n"
3762                "  #define A 1\n"
3763                "#endif",
3764                Style);
3765   verifyFormat("#if A\n"
3766                "  #define MACRO                        \\\n"
3767                "    void a(int x) {                    \\\n"
3768                "      b();                             \\\n"
3769                "      c();                             \\\n"
3770                "      d();                             \\\n"
3771                "      e();                             \\\n"
3772                "      f();                             \\\n"
3773                "    }\n"
3774                "#endif",
3775                Style);
3776   // Keep comments aligned with indented directives. These
3777   // tests cannot use verifyFormat because messUp manipulates leading
3778   // whitespace.
3779   {
3780     const char *Expected = "void f() {\n"
3781                            "// Aligned to preprocessor.\n"
3782                            "#if 1\n"
3783                            "  // Aligned to code.\n"
3784                            "  int a;\n"
3785                            "  #if 1\n"
3786                            "    // Aligned to preprocessor.\n"
3787                            "    #define A 0\n"
3788                            "  // Aligned to code.\n"
3789                            "  int b;\n"
3790                            "  #endif\n"
3791                            "#endif\n"
3792                            "}";
3793     const char *ToFormat = "void f() {\n"
3794                            "// Aligned to preprocessor.\n"
3795                            "#if 1\n"
3796                            "// Aligned to code.\n"
3797                            "int a;\n"
3798                            "#if 1\n"
3799                            "// Aligned to preprocessor.\n"
3800                            "#define A 0\n"
3801                            "// Aligned to code.\n"
3802                            "int b;\n"
3803                            "#endif\n"
3804                            "#endif\n"
3805                            "}";
3806     EXPECT_EQ(Expected, format(ToFormat, Style));
3807     EXPECT_EQ(Expected, format(Expected, Style));
3808   }
3809   {
3810     const char *Expected = "void f() {\n"
3811                            "/* Aligned to preprocessor. */\n"
3812                            "#if 1\n"
3813                            "  /* Aligned to code. */\n"
3814                            "  int a;\n"
3815                            "  #if 1\n"
3816                            "    /* Aligned to preprocessor. */\n"
3817                            "    #define A 0\n"
3818                            "  /* Aligned to code. */\n"
3819                            "  int b;\n"
3820                            "  #endif\n"
3821                            "#endif\n"
3822                            "}";
3823     const char *ToFormat = "void f() {\n"
3824                            "/* Aligned to preprocessor. */\n"
3825                            "#if 1\n"
3826                            "/* Aligned to code. */\n"
3827                            "int a;\n"
3828                            "#if 1\n"
3829                            "/* Aligned to preprocessor. */\n"
3830                            "#define A 0\n"
3831                            "/* Aligned to code. */\n"
3832                            "int b;\n"
3833                            "#endif\n"
3834                            "#endif\n"
3835                            "}";
3836     EXPECT_EQ(Expected, format(ToFormat, Style));
3837     EXPECT_EQ(Expected, format(Expected, Style));
3838   }
3839 
3840   // Test single comment before preprocessor
3841   verifyFormat("// Comment\n"
3842                "\n"
3843                "#if 1\n"
3844                "#endif",
3845                Style);
3846 }
3847 
3848 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3849   verifyFormat("{\n  { a #c; }\n}");
3850 }
3851 
3852 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3853   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3854             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3855   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3856             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3857 }
3858 
3859 TEST_F(FormatTest, EscapedNewlines) {
3860   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3861   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3862             format("#define A \\\nint i;\\\n  int j;", Narrow));
3863   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3864   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3865   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3866   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3867 
3868   FormatStyle AlignLeft = getLLVMStyle();
3869   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3870   EXPECT_EQ("#define MACRO(x) \\\n"
3871             "private:         \\\n"
3872             "  int x(int a);\n",
3873             format("#define MACRO(x) \\\n"
3874                    "private:         \\\n"
3875                    "  int x(int a);\n",
3876                    AlignLeft));
3877 
3878   // CRLF line endings
3879   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3880             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3881   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3882   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3883   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3884   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3885   EXPECT_EQ("#define MACRO(x) \\\r\n"
3886             "private:         \\\r\n"
3887             "  int x(int a);\r\n",
3888             format("#define MACRO(x) \\\r\n"
3889                    "private:         \\\r\n"
3890                    "  int x(int a);\r\n",
3891                    AlignLeft));
3892 
3893   FormatStyle DontAlign = getLLVMStyle();
3894   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3895   DontAlign.MaxEmptyLinesToKeep = 3;
3896   // FIXME: can't use verifyFormat here because the newline before
3897   // "public:" is not inserted the first time it's reformatted
3898   EXPECT_EQ("#define A \\\n"
3899             "  class Foo { \\\n"
3900             "    void bar(); \\\n"
3901             "\\\n"
3902             "\\\n"
3903             "\\\n"
3904             "  public: \\\n"
3905             "    void baz(); \\\n"
3906             "  };",
3907             format("#define A \\\n"
3908                    "  class Foo { \\\n"
3909                    "    void bar(); \\\n"
3910                    "\\\n"
3911                    "\\\n"
3912                    "\\\n"
3913                    "  public: \\\n"
3914                    "    void baz(); \\\n"
3915                    "  };",
3916                    DontAlign));
3917 }
3918 
3919 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3920   verifyFormat("#define A \\\n"
3921                "  int v(  \\\n"
3922                "      a); \\\n"
3923                "  int i;",
3924                getLLVMStyleWithColumns(11));
3925 }
3926 
3927 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3928   EXPECT_EQ(
3929       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3930       "                      \\\n"
3931       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3932       "\n"
3933       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3934       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3935       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3936              "\\\n"
3937              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3938              "  \n"
3939              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3940              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3941 }
3942 
3943 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3944   EXPECT_EQ("int\n"
3945             "#define A\n"
3946             "    a;",
3947             format("int\n#define A\na;"));
3948   verifyFormat("functionCallTo(\n"
3949                "    someOtherFunction(\n"
3950                "        withSomeParameters, whichInSequence,\n"
3951                "        areLongerThanALine(andAnotherCall,\n"
3952                "#define A B\n"
3953                "                           withMoreParamters,\n"
3954                "                           whichStronglyInfluenceTheLayout),\n"
3955                "        andMoreParameters),\n"
3956                "    trailing);",
3957                getLLVMStyleWithColumns(69));
3958   verifyFormat("Foo::Foo()\n"
3959                "#ifdef BAR\n"
3960                "    : baz(0)\n"
3961                "#endif\n"
3962                "{\n"
3963                "}");
3964   verifyFormat("void f() {\n"
3965                "  if (true)\n"
3966                "#ifdef A\n"
3967                "    f(42);\n"
3968                "  x();\n"
3969                "#else\n"
3970                "    g();\n"
3971                "  x();\n"
3972                "#endif\n"
3973                "}");
3974   verifyFormat("void f(param1, param2,\n"
3975                "       param3,\n"
3976                "#ifdef A\n"
3977                "       param4(param5,\n"
3978                "#ifdef A1\n"
3979                "              param6,\n"
3980                "#ifdef A2\n"
3981                "              param7),\n"
3982                "#else\n"
3983                "              param8),\n"
3984                "       param9,\n"
3985                "#endif\n"
3986                "       param10,\n"
3987                "#endif\n"
3988                "       param11)\n"
3989                "#else\n"
3990                "       param12)\n"
3991                "#endif\n"
3992                "{\n"
3993                "  x();\n"
3994                "}",
3995                getLLVMStyleWithColumns(28));
3996   verifyFormat("#if 1\n"
3997                "int i;");
3998   verifyFormat("#if 1\n"
3999                "#endif\n"
4000                "#if 1\n"
4001                "#else\n"
4002                "#endif\n");
4003   verifyFormat("DEBUG({\n"
4004                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4005                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
4006                "});\n"
4007                "#if a\n"
4008                "#else\n"
4009                "#endif");
4010 
4011   verifyIncompleteFormat("void f(\n"
4012                          "#if A\n"
4013                          ");\n"
4014                          "#else\n"
4015                          "#endif");
4016 }
4017 
4018 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
4019   verifyFormat("#endif\n"
4020                "#if B");
4021 }
4022 
4023 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
4024   FormatStyle SingleLine = getLLVMStyle();
4025   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
4026   verifyFormat("#if 0\n"
4027                "#elif 1\n"
4028                "#endif\n"
4029                "void foo() {\n"
4030                "  if (test) foo2();\n"
4031                "}",
4032                SingleLine);
4033 }
4034 
4035 TEST_F(FormatTest, LayoutBlockInsideParens) {
4036   verifyFormat("functionCall({ int i; });");
4037   verifyFormat("functionCall({\n"
4038                "  int i;\n"
4039                "  int j;\n"
4040                "});");
4041   verifyFormat("functionCall(\n"
4042                "    {\n"
4043                "      int i;\n"
4044                "      int j;\n"
4045                "    },\n"
4046                "    aaaa, bbbb, cccc);");
4047   verifyFormat("functionA(functionB({\n"
4048                "            int i;\n"
4049                "            int j;\n"
4050                "          }),\n"
4051                "          aaaa, bbbb, cccc);");
4052   verifyFormat("functionCall(\n"
4053                "    {\n"
4054                "      int i;\n"
4055                "      int j;\n"
4056                "    },\n"
4057                "    aaaa, bbbb, // comment\n"
4058                "    cccc);");
4059   verifyFormat("functionA(functionB({\n"
4060                "            int i;\n"
4061                "            int j;\n"
4062                "          }),\n"
4063                "          aaaa, bbbb, // comment\n"
4064                "          cccc);");
4065   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
4066   verifyFormat("functionCall(aaaa, bbbb, {\n"
4067                "  int i;\n"
4068                "  int j;\n"
4069                "});");
4070   verifyFormat(
4071       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
4072       "    {\n"
4073       "      int i; // break\n"
4074       "    },\n"
4075       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4076       "                                     ccccccccccccccccc));");
4077   verifyFormat("DEBUG({\n"
4078                "  if (a)\n"
4079                "    f();\n"
4080                "});");
4081 }
4082 
4083 TEST_F(FormatTest, LayoutBlockInsideStatement) {
4084   EXPECT_EQ("SOME_MACRO { int i; }\n"
4085             "int i;",
4086             format("  SOME_MACRO  {int i;}  int i;"));
4087 }
4088 
4089 TEST_F(FormatTest, LayoutNestedBlocks) {
4090   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
4091                "  struct s {\n"
4092                "    int i;\n"
4093                "  };\n"
4094                "  s kBitsToOs[] = {{10}};\n"
4095                "  for (int i = 0; i < 10; ++i)\n"
4096                "    return;\n"
4097                "}");
4098   verifyFormat("call(parameter, {\n"
4099                "  something();\n"
4100                "  // Comment using all columns.\n"
4101                "  somethingelse();\n"
4102                "});",
4103                getLLVMStyleWithColumns(40));
4104   verifyFormat("DEBUG( //\n"
4105                "    { f(); }, a);");
4106   verifyFormat("DEBUG( //\n"
4107                "    {\n"
4108                "      f(); //\n"
4109                "    },\n"
4110                "    a);");
4111 
4112   EXPECT_EQ("call(parameter, {\n"
4113             "  something();\n"
4114             "  // Comment too\n"
4115             "  // looooooooooong.\n"
4116             "  somethingElse();\n"
4117             "});",
4118             format("call(parameter, {\n"
4119                    "  something();\n"
4120                    "  // Comment too looooooooooong.\n"
4121                    "  somethingElse();\n"
4122                    "});",
4123                    getLLVMStyleWithColumns(29)));
4124   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
4125   EXPECT_EQ("DEBUG({ // comment\n"
4126             "  int i;\n"
4127             "});",
4128             format("DEBUG({ // comment\n"
4129                    "int  i;\n"
4130                    "});"));
4131   EXPECT_EQ("DEBUG({\n"
4132             "  int i;\n"
4133             "\n"
4134             "  // comment\n"
4135             "  int j;\n"
4136             "});",
4137             format("DEBUG({\n"
4138                    "  int  i;\n"
4139                    "\n"
4140                    "  // comment\n"
4141                    "  int  j;\n"
4142                    "});"));
4143 
4144   verifyFormat("DEBUG({\n"
4145                "  if (a)\n"
4146                "    return;\n"
4147                "});");
4148   verifyGoogleFormat("DEBUG({\n"
4149                      "  if (a) return;\n"
4150                      "});");
4151   FormatStyle Style = getGoogleStyle();
4152   Style.ColumnLimit = 45;
4153   verifyFormat("Debug(\n"
4154                "    aaaaa,\n"
4155                "    {\n"
4156                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4157                "    },\n"
4158                "    a);",
4159                Style);
4160 
4161   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4162 
4163   verifyNoCrash("^{v^{a}}");
4164 }
4165 
4166 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4167   EXPECT_EQ("#define MACRO()                     \\\n"
4168             "  Debug(aaa, /* force line break */ \\\n"
4169             "        {                           \\\n"
4170             "          int i;                    \\\n"
4171             "          int j;                    \\\n"
4172             "        })",
4173             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
4174                    "          {  int   i;  int  j;   })",
4175                    getGoogleStyle()));
4176 
4177   EXPECT_EQ("#define A                                       \\\n"
4178             "  [] {                                          \\\n"
4179             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
4180             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4181             "  }",
4182             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4183                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4184                    getGoogleStyle()));
4185 }
4186 
4187 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4188   EXPECT_EQ("{}", format("{}"));
4189   verifyFormat("enum E {};");
4190   verifyFormat("enum E {}");
4191   FormatStyle Style = getLLVMStyle();
4192   Style.SpaceInEmptyBlock = true;
4193   EXPECT_EQ("void f() { }", format("void f() {}", Style));
4194   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4195   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4196 }
4197 
4198 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4199   FormatStyle Style = getLLVMStyle();
4200   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4201   Style.MacroBlockEnd = "^[A-Z_]+_END$";
4202   verifyFormat("FOO_BEGIN\n"
4203                "  FOO_ENTRY\n"
4204                "FOO_END",
4205                Style);
4206   verifyFormat("FOO_BEGIN\n"
4207                "  NESTED_FOO_BEGIN\n"
4208                "    NESTED_FOO_ENTRY\n"
4209                "  NESTED_FOO_END\n"
4210                "FOO_END",
4211                Style);
4212   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4213                "  int x;\n"
4214                "  x = 1;\n"
4215                "FOO_END(Baz)",
4216                Style);
4217 }
4218 
4219 //===----------------------------------------------------------------------===//
4220 // Line break tests.
4221 //===----------------------------------------------------------------------===//
4222 
4223 TEST_F(FormatTest, PreventConfusingIndents) {
4224   verifyFormat(
4225       "void f() {\n"
4226       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4227       "                         parameter, parameter, parameter)),\n"
4228       "                     SecondLongCall(parameter));\n"
4229       "}");
4230   verifyFormat(
4231       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4232       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4233       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4234       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
4235   verifyFormat(
4236       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4237       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4238       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4239       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4240   verifyFormat(
4241       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4242       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4243       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4244       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
4245   verifyFormat("int a = bbbb && ccc &&\n"
4246                "        fffff(\n"
4247                "#define A Just forcing a new line\n"
4248                "            ddd);");
4249 }
4250 
4251 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4252   verifyFormat(
4253       "bool aaaaaaa =\n"
4254       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4255       "    bbbbbbbb();");
4256   verifyFormat(
4257       "bool aaaaaaa =\n"
4258       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4259       "    bbbbbbbb();");
4260 
4261   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4262                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4263                "    ccccccccc == ddddddddddd;");
4264   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4265                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4266                "    ccccccccc == ddddddddddd;");
4267   verifyFormat(
4268       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4269       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4270       "    ccccccccc == ddddddddddd;");
4271 
4272   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4273                "                 aaaaaa) &&\n"
4274                "         bbbbbb && cccccc;");
4275   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4276                "                 aaaaaa) >>\n"
4277                "         bbbbbb;");
4278   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4279                "    SourceMgr.getSpellingColumnNumber(\n"
4280                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4281                "    1);");
4282 
4283   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4284                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4285                "    cccccc) {\n}");
4286   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4287                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4288                "              cccccc) {\n}");
4289   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4290                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4291                "              cccccc) {\n}");
4292   verifyFormat("b = a &&\n"
4293                "    // Comment\n"
4294                "    b.c && d;");
4295 
4296   // If the LHS of a comparison is not a binary expression itself, the
4297   // additional linebreak confuses many people.
4298   verifyFormat(
4299       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4300       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4301       "}");
4302   verifyFormat(
4303       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4304       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4305       "}");
4306   verifyFormat(
4307       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4308       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4309       "}");
4310   verifyFormat(
4311       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4312       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4313       "}");
4314   // Even explicit parentheses stress the precedence enough to make the
4315   // additional break unnecessary.
4316   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4317                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4318                "}");
4319   // This cases is borderline, but with the indentation it is still readable.
4320   verifyFormat(
4321       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4322       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4323       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4324       "}",
4325       getLLVMStyleWithColumns(75));
4326 
4327   // If the LHS is a binary expression, we should still use the additional break
4328   // as otherwise the formatting hides the operator precedence.
4329   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4330                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4331                "    5) {\n"
4332                "}");
4333   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4334                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4335                "    5) {\n"
4336                "}");
4337 
4338   FormatStyle OnePerLine = getLLVMStyle();
4339   OnePerLine.BinPackParameters = false;
4340   verifyFormat(
4341       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4342       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4343       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4344       OnePerLine);
4345 
4346   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4347                "                .aaa(aaaaaaaaaaaaa) *\n"
4348                "            aaaaaaa +\n"
4349                "        aaaaaaa;",
4350                getLLVMStyleWithColumns(40));
4351 }
4352 
4353 TEST_F(FormatTest, ExpressionIndentation) {
4354   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4355                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4356                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4357                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4358                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4359                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4360                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4361                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4362                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4363   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4364                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4365                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4366                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4367   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4368                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4369                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4370                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4371   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4372                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4373                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4374                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4375   verifyFormat("if () {\n"
4376                "} else if (aaaaa && bbbbb > // break\n"
4377                "                        ccccc) {\n"
4378                "}");
4379   verifyFormat("if () {\n"
4380                "} else if constexpr (aaaaa && bbbbb > // break\n"
4381                "                                  ccccc) {\n"
4382                "}");
4383   verifyFormat("if () {\n"
4384                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4385                "                                  ccccc) {\n"
4386                "}");
4387   verifyFormat("if () {\n"
4388                "} else if (aaaaa &&\n"
4389                "           bbbbb > // break\n"
4390                "               ccccc &&\n"
4391                "           ddddd) {\n"
4392                "}");
4393 
4394   // Presence of a trailing comment used to change indentation of b.
4395   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4396                "       b;\n"
4397                "return aaaaaaaaaaaaaaaaaaa +\n"
4398                "       b; //",
4399                getLLVMStyleWithColumns(30));
4400 }
4401 
4402 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4403   // Not sure what the best system is here. Like this, the LHS can be found
4404   // immediately above an operator (everything with the same or a higher
4405   // indent). The RHS is aligned right of the operator and so compasses
4406   // everything until something with the same indent as the operator is found.
4407   // FIXME: Is this a good system?
4408   FormatStyle Style = getLLVMStyle();
4409   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4410   verifyFormat(
4411       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4412       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4413       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4414       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4415       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4416       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4417       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4418       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4419       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4420       Style);
4421   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4422                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4423                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4424                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4425                Style);
4426   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4427                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4428                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4429                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4430                Style);
4431   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4432                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4433                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4434                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4435                Style);
4436   verifyFormat("if () {\n"
4437                "} else if (aaaaa\n"
4438                "           && bbbbb // break\n"
4439                "                  > ccccc) {\n"
4440                "}",
4441                Style);
4442   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4443                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4444                Style);
4445   verifyFormat("return (a)\n"
4446                "       // comment\n"
4447                "       + b;",
4448                Style);
4449   verifyFormat(
4450       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4451       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4452       "             + cc;",
4453       Style);
4454 
4455   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4456                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4457                Style);
4458 
4459   // Forced by comments.
4460   verifyFormat(
4461       "unsigned ContentSize =\n"
4462       "    sizeof(int16_t)   // DWARF ARange version number\n"
4463       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4464       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4465       "    + sizeof(int8_t); // Segment Size (in bytes)");
4466 
4467   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4468                "       == boost::fusion::at_c<1>(iiii).second;",
4469                Style);
4470 
4471   Style.ColumnLimit = 60;
4472   verifyFormat("zzzzzzzzzz\n"
4473                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4474                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4475                Style);
4476 
4477   Style.ColumnLimit = 80;
4478   Style.IndentWidth = 4;
4479   Style.TabWidth = 4;
4480   Style.UseTab = FormatStyle::UT_Always;
4481   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4482   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4483   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4484             "\t&& (someOtherLongishConditionPart1\n"
4485             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4486             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4487                    "(someOtherLongishConditionPart1 || "
4488                    "someOtherEvenLongerNestedConditionPart2);",
4489                    Style));
4490 }
4491 
4492 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4493   FormatStyle Style = getLLVMStyle();
4494   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4495   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4496 
4497   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4498                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4499                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4500                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4501                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4502                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4503                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4504                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4505                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
4506                Style);
4507   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4508                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4509                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4510                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4511                Style);
4512   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4513                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4514                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4515                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4516                Style);
4517   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4518                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4519                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4520                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4521                Style);
4522   verifyFormat("if () {\n"
4523                "} else if (aaaaa\n"
4524                "           && bbbbb // break\n"
4525                "                  > ccccc) {\n"
4526                "}",
4527                Style);
4528   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4529                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4530                Style);
4531   verifyFormat("return (a)\n"
4532                "     // comment\n"
4533                "     + b;",
4534                Style);
4535   verifyFormat(
4536       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4537       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4538       "           + cc;",
4539       Style);
4540   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4541                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4542                "                        : 3333333333333333;",
4543                Style);
4544   verifyFormat(
4545       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
4546       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
4547       "                                             : eeeeeeeeeeeeeeeeee)\n"
4548       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4549       "                        : 3333333333333333;",
4550       Style);
4551   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4552                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4553                Style);
4554 
4555   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4556                "    == boost::fusion::at_c<1>(iiii).second;",
4557                Style);
4558 
4559   Style.ColumnLimit = 60;
4560   verifyFormat("zzzzzzzzzzzzz\n"
4561                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4562                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4563                Style);
4564 
4565   // Forced by comments.
4566   Style.ColumnLimit = 80;
4567   verifyFormat(
4568       "unsigned ContentSize\n"
4569       "    = sizeof(int16_t) // DWARF ARange version number\n"
4570       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4571       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4572       "    + sizeof(int8_t); // Segment Size (in bytes)",
4573       Style);
4574 
4575   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4576   verifyFormat(
4577       "unsigned ContentSize =\n"
4578       "    sizeof(int16_t)   // DWARF ARange version number\n"
4579       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4580       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4581       "    + sizeof(int8_t); // Segment Size (in bytes)",
4582       Style);
4583 
4584   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4585   verifyFormat(
4586       "unsigned ContentSize =\n"
4587       "    sizeof(int16_t)   // DWARF ARange version number\n"
4588       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4589       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4590       "    + sizeof(int8_t); // Segment Size (in bytes)",
4591       Style);
4592 }
4593 
4594 TEST_F(FormatTest, EnforcedOperatorWraps) {
4595   // Here we'd like to wrap after the || operators, but a comment is forcing an
4596   // earlier wrap.
4597   verifyFormat("bool x = aaaaa //\n"
4598                "         || bbbbb\n"
4599                "         //\n"
4600                "         || cccc;");
4601 }
4602 
4603 TEST_F(FormatTest, NoOperandAlignment) {
4604   FormatStyle Style = getLLVMStyle();
4605   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4606   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4607                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4608                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4609                Style);
4610   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4611   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4612                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4613                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4614                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4615                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4616                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4617                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4618                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4619                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4620                Style);
4621 
4622   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4623                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4624                "    + cc;",
4625                Style);
4626   verifyFormat("int a = aa\n"
4627                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4628                "        * cccccccccccccccccccccccccccccccccccc;\n",
4629                Style);
4630 
4631   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4632   verifyFormat("return (a > b\n"
4633                "    // comment1\n"
4634                "    // comment2\n"
4635                "    || c);",
4636                Style);
4637 }
4638 
4639 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4640   FormatStyle Style = getLLVMStyle();
4641   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4642   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4643                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4644                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4645                Style);
4646 }
4647 
4648 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4649   FormatStyle Style = getLLVMStyle();
4650   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4651   Style.BinPackArguments = false;
4652   Style.ColumnLimit = 40;
4653   verifyFormat("void test() {\n"
4654                "  someFunction(\n"
4655                "      this + argument + is + quite\n"
4656                "      + long + so + it + gets + wrapped\n"
4657                "      + but + remains + bin - packed);\n"
4658                "}",
4659                Style);
4660   verifyFormat("void test() {\n"
4661                "  someFunction(arg1,\n"
4662                "               this + argument + is\n"
4663                "                   + quite + long + so\n"
4664                "                   + it + gets + wrapped\n"
4665                "                   + but + remains + bin\n"
4666                "                   - packed,\n"
4667                "               arg3);\n"
4668                "}",
4669                Style);
4670   verifyFormat("void test() {\n"
4671                "  someFunction(\n"
4672                "      arg1,\n"
4673                "      this + argument + has\n"
4674                "          + anotherFunc(nested,\n"
4675                "                        calls + whose\n"
4676                "                            + arguments\n"
4677                "                            + are + also\n"
4678                "                            + wrapped,\n"
4679                "                        in + addition)\n"
4680                "          + to + being + bin - packed,\n"
4681                "      arg3);\n"
4682                "}",
4683                Style);
4684 
4685   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4686   verifyFormat("void test() {\n"
4687                "  someFunction(\n"
4688                "      arg1,\n"
4689                "      this + argument + has +\n"
4690                "          anotherFunc(nested,\n"
4691                "                      calls + whose +\n"
4692                "                          arguments +\n"
4693                "                          are + also +\n"
4694                "                          wrapped,\n"
4695                "                      in + addition) +\n"
4696                "          to + being + bin - packed,\n"
4697                "      arg3);\n"
4698                "}",
4699                Style);
4700 }
4701 
4702 TEST_F(FormatTest, ConstructorInitializers) {
4703   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4704   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4705                getLLVMStyleWithColumns(45));
4706   verifyFormat("Constructor()\n"
4707                "    : Inttializer(FitsOnTheLine) {}",
4708                getLLVMStyleWithColumns(44));
4709   verifyFormat("Constructor()\n"
4710                "    : Inttializer(FitsOnTheLine) {}",
4711                getLLVMStyleWithColumns(43));
4712 
4713   verifyFormat("template <typename T>\n"
4714                "Constructor() : Initializer(FitsOnTheLine) {}",
4715                getLLVMStyleWithColumns(45));
4716 
4717   verifyFormat(
4718       "SomeClass::Constructor()\n"
4719       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4720 
4721   verifyFormat(
4722       "SomeClass::Constructor()\n"
4723       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4724       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4725   verifyFormat(
4726       "SomeClass::Constructor()\n"
4727       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4728       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4729   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4730                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4731                "    : aaaaaaaaaa(aaaaaa) {}");
4732 
4733   verifyFormat("Constructor()\n"
4734                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4735                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4736                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4737                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4738 
4739   verifyFormat("Constructor()\n"
4740                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4741                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4742 
4743   verifyFormat("Constructor(int Parameter = 0)\n"
4744                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4745                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4746   verifyFormat("Constructor()\n"
4747                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4748                "}",
4749                getLLVMStyleWithColumns(60));
4750   verifyFormat("Constructor()\n"
4751                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4752                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4753 
4754   // Here a line could be saved by splitting the second initializer onto two
4755   // lines, but that is not desirable.
4756   verifyFormat("Constructor()\n"
4757                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4758                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4759                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4760 
4761   FormatStyle OnePerLine = getLLVMStyle();
4762   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4763   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4764   verifyFormat("SomeClass::Constructor()\n"
4765                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4766                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4767                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4768                OnePerLine);
4769   verifyFormat("SomeClass::Constructor()\n"
4770                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4771                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4772                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4773                OnePerLine);
4774   verifyFormat("MyClass::MyClass(int var)\n"
4775                "    : some_var_(var),            // 4 space indent\n"
4776                "      some_other_var_(var + 1) { // lined up\n"
4777                "}",
4778                OnePerLine);
4779   verifyFormat("Constructor()\n"
4780                "    : aaaaa(aaaaaa),\n"
4781                "      aaaaa(aaaaaa),\n"
4782                "      aaaaa(aaaaaa),\n"
4783                "      aaaaa(aaaaaa),\n"
4784                "      aaaaa(aaaaaa) {}",
4785                OnePerLine);
4786   verifyFormat("Constructor()\n"
4787                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4788                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4789                OnePerLine);
4790   OnePerLine.BinPackParameters = false;
4791   verifyFormat(
4792       "Constructor()\n"
4793       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4794       "          aaaaaaaaaaa().aaa(),\n"
4795       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4796       OnePerLine);
4797   OnePerLine.ColumnLimit = 60;
4798   verifyFormat("Constructor()\n"
4799                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4800                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4801                OnePerLine);
4802 
4803   EXPECT_EQ("Constructor()\n"
4804             "    : // Comment forcing unwanted break.\n"
4805             "      aaaa(aaaa) {}",
4806             format("Constructor() :\n"
4807                    "    // Comment forcing unwanted break.\n"
4808                    "    aaaa(aaaa) {}"));
4809 }
4810 
4811 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4812   FormatStyle Style = getLLVMStyle();
4813   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4814   Style.ColumnLimit = 60;
4815   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4816   Style.AllowAllConstructorInitializersOnNextLine = true;
4817   Style.BinPackParameters = false;
4818 
4819   for (int i = 0; i < 4; ++i) {
4820     // Test all combinations of parameters that should not have an effect.
4821     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4822     Style.AllowAllArgumentsOnNextLine = i & 2;
4823 
4824     Style.AllowAllConstructorInitializersOnNextLine = true;
4825     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4826     verifyFormat("Constructor()\n"
4827                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4828                  Style);
4829     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4830 
4831     Style.AllowAllConstructorInitializersOnNextLine = false;
4832     verifyFormat("Constructor()\n"
4833                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4834                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4835                  Style);
4836     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4837 
4838     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4839     Style.AllowAllConstructorInitializersOnNextLine = true;
4840     verifyFormat("Constructor()\n"
4841                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4842                  Style);
4843 
4844     Style.AllowAllConstructorInitializersOnNextLine = false;
4845     verifyFormat("Constructor()\n"
4846                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4847                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4848                  Style);
4849 
4850     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4851     Style.AllowAllConstructorInitializersOnNextLine = true;
4852     verifyFormat("Constructor() :\n"
4853                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4854                  Style);
4855 
4856     Style.AllowAllConstructorInitializersOnNextLine = false;
4857     verifyFormat("Constructor() :\n"
4858                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4859                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4860                  Style);
4861   }
4862 
4863   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4864   // AllowAllConstructorInitializersOnNextLine in all
4865   // BreakConstructorInitializers modes
4866   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4867   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4868   Style.AllowAllConstructorInitializersOnNextLine = false;
4869   verifyFormat("SomeClassWithALongName::Constructor(\n"
4870                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4871                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4872                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4873                Style);
4874 
4875   Style.AllowAllConstructorInitializersOnNextLine = true;
4876   verifyFormat("SomeClassWithALongName::Constructor(\n"
4877                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4878                "    int bbbbbbbbbbbbb,\n"
4879                "    int cccccccccccccccc)\n"
4880                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4881                Style);
4882 
4883   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4884   Style.AllowAllConstructorInitializersOnNextLine = false;
4885   verifyFormat("SomeClassWithALongName::Constructor(\n"
4886                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4887                "    int bbbbbbbbbbbbb)\n"
4888                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4889                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4890                Style);
4891 
4892   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4893 
4894   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4895   verifyFormat("SomeClassWithALongName::Constructor(\n"
4896                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4897                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4898                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4899                Style);
4900 
4901   Style.AllowAllConstructorInitializersOnNextLine = true;
4902   verifyFormat("SomeClassWithALongName::Constructor(\n"
4903                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4904                "    int bbbbbbbbbbbbb,\n"
4905                "    int cccccccccccccccc)\n"
4906                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4907                Style);
4908 
4909   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4910   Style.AllowAllConstructorInitializersOnNextLine = false;
4911   verifyFormat("SomeClassWithALongName::Constructor(\n"
4912                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4913                "    int bbbbbbbbbbbbb)\n"
4914                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4915                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4916                Style);
4917 
4918   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4919   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4920   verifyFormat("SomeClassWithALongName::Constructor(\n"
4921                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4922                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4923                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4924                Style);
4925 
4926   Style.AllowAllConstructorInitializersOnNextLine = true;
4927   verifyFormat("SomeClassWithALongName::Constructor(\n"
4928                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4929                "    int bbbbbbbbbbbbb,\n"
4930                "    int cccccccccccccccc) :\n"
4931                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4932                Style);
4933 
4934   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4935   Style.AllowAllConstructorInitializersOnNextLine = false;
4936   verifyFormat("SomeClassWithALongName::Constructor(\n"
4937                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4938                "    int bbbbbbbbbbbbb) :\n"
4939                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4940                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4941                Style);
4942 }
4943 
4944 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4945   FormatStyle Style = getLLVMStyle();
4946   Style.ColumnLimit = 60;
4947   Style.BinPackArguments = false;
4948   for (int i = 0; i < 4; ++i) {
4949     // Test all combinations of parameters that should not have an effect.
4950     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4951     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4952 
4953     Style.AllowAllArgumentsOnNextLine = true;
4954     verifyFormat("void foo() {\n"
4955                  "  FunctionCallWithReallyLongName(\n"
4956                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4957                  "}",
4958                  Style);
4959     Style.AllowAllArgumentsOnNextLine = false;
4960     verifyFormat("void foo() {\n"
4961                  "  FunctionCallWithReallyLongName(\n"
4962                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4963                  "      bbbbbbbbbbbb);\n"
4964                  "}",
4965                  Style);
4966 
4967     Style.AllowAllArgumentsOnNextLine = true;
4968     verifyFormat("void foo() {\n"
4969                  "  auto VariableWithReallyLongName = {\n"
4970                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4971                  "}",
4972                  Style);
4973     Style.AllowAllArgumentsOnNextLine = false;
4974     verifyFormat("void foo() {\n"
4975                  "  auto VariableWithReallyLongName = {\n"
4976                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4977                  "      bbbbbbbbbbbb};\n"
4978                  "}",
4979                  Style);
4980   }
4981 
4982   // This parameter should not affect declarations.
4983   Style.BinPackParameters = false;
4984   Style.AllowAllArgumentsOnNextLine = false;
4985   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4986   verifyFormat("void FunctionCallWithReallyLongName(\n"
4987                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
4988                Style);
4989   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4990   verifyFormat("void FunctionCallWithReallyLongName(\n"
4991                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
4992                "    int bbbbbbbbbbbb);",
4993                Style);
4994 }
4995 
4996 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
4997   FormatStyle Style = getLLVMStyle();
4998   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4999 
5000   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
5001   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
5002                getStyleWithColumns(Style, 45));
5003   verifyFormat("Constructor() :\n"
5004                "    Initializer(FitsOnTheLine) {}",
5005                getStyleWithColumns(Style, 44));
5006   verifyFormat("Constructor() :\n"
5007                "    Initializer(FitsOnTheLine) {}",
5008                getStyleWithColumns(Style, 43));
5009 
5010   verifyFormat("template <typename T>\n"
5011                "Constructor() : Initializer(FitsOnTheLine) {}",
5012                getStyleWithColumns(Style, 50));
5013   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5014   verifyFormat(
5015       "SomeClass::Constructor() :\n"
5016       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5017       Style);
5018 
5019   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
5020   verifyFormat(
5021       "SomeClass::Constructor() :\n"
5022       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5023       Style);
5024 
5025   verifyFormat(
5026       "SomeClass::Constructor() :\n"
5027       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5028       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5029       Style);
5030   verifyFormat(
5031       "SomeClass::Constructor() :\n"
5032       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5033       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5034       Style);
5035   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5036                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
5037                "    aaaaaaaaaa(aaaaaa) {}",
5038                Style);
5039 
5040   verifyFormat("Constructor() :\n"
5041                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5042                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5043                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5044                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
5045                Style);
5046 
5047   verifyFormat("Constructor() :\n"
5048                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5049                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5050                Style);
5051 
5052   verifyFormat("Constructor(int Parameter = 0) :\n"
5053                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
5054                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
5055                Style);
5056   verifyFormat("Constructor() :\n"
5057                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
5058                "}",
5059                getStyleWithColumns(Style, 60));
5060   verifyFormat("Constructor() :\n"
5061                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5062                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
5063                Style);
5064 
5065   // Here a line could be saved by splitting the second initializer onto two
5066   // lines, but that is not desirable.
5067   verifyFormat("Constructor() :\n"
5068                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
5069                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
5070                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5071                Style);
5072 
5073   FormatStyle OnePerLine = Style;
5074   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5075   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
5076   verifyFormat("SomeClass::Constructor() :\n"
5077                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5078                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5079                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5080                OnePerLine);
5081   verifyFormat("SomeClass::Constructor() :\n"
5082                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
5083                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5084                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5085                OnePerLine);
5086   verifyFormat("MyClass::MyClass(int var) :\n"
5087                "    some_var_(var),            // 4 space indent\n"
5088                "    some_other_var_(var + 1) { // lined up\n"
5089                "}",
5090                OnePerLine);
5091   verifyFormat("Constructor() :\n"
5092                "    aaaaa(aaaaaa),\n"
5093                "    aaaaa(aaaaaa),\n"
5094                "    aaaaa(aaaaaa),\n"
5095                "    aaaaa(aaaaaa),\n"
5096                "    aaaaa(aaaaaa) {}",
5097                OnePerLine);
5098   verifyFormat("Constructor() :\n"
5099                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5100                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
5101                OnePerLine);
5102   OnePerLine.BinPackParameters = false;
5103   verifyFormat("Constructor() :\n"
5104                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5105                "        aaaaaaaaaaa().aaa(),\n"
5106                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5107                OnePerLine);
5108   OnePerLine.ColumnLimit = 60;
5109   verifyFormat("Constructor() :\n"
5110                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
5111                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5112                OnePerLine);
5113 
5114   EXPECT_EQ("Constructor() :\n"
5115             "    // Comment forcing unwanted break.\n"
5116             "    aaaa(aaaa) {}",
5117             format("Constructor() :\n"
5118                    "    // Comment forcing unwanted break.\n"
5119                    "    aaaa(aaaa) {}",
5120                    Style));
5121 
5122   Style.ColumnLimit = 0;
5123   verifyFormat("SomeClass::Constructor() :\n"
5124                "    a(a) {}",
5125                Style);
5126   verifyFormat("SomeClass::Constructor() noexcept :\n"
5127                "    a(a) {}",
5128                Style);
5129   verifyFormat("SomeClass::Constructor() :\n"
5130                "    a(a), b(b), c(c) {}",
5131                Style);
5132   verifyFormat("SomeClass::Constructor() :\n"
5133                "    a(a) {\n"
5134                "  foo();\n"
5135                "  bar();\n"
5136                "}",
5137                Style);
5138 
5139   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5140   verifyFormat("SomeClass::Constructor() :\n"
5141                "    a(a), b(b), c(c) {\n"
5142                "}",
5143                Style);
5144   verifyFormat("SomeClass::Constructor() :\n"
5145                "    a(a) {\n"
5146                "}",
5147                Style);
5148 
5149   Style.ColumnLimit = 80;
5150   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5151   Style.ConstructorInitializerIndentWidth = 2;
5152   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5153   verifyFormat("SomeClass::Constructor() :\n"
5154                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5155                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5156                Style);
5157 
5158   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5159   // well
5160   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5161   verifyFormat(
5162       "class SomeClass\n"
5163       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5164       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5165       Style);
5166   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5167   verifyFormat(
5168       "class SomeClass\n"
5169       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5170       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5171       Style);
5172   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5173   verifyFormat(
5174       "class SomeClass :\n"
5175       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5176       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5177       Style);
5178 }
5179 
5180 #ifndef EXPENSIVE_CHECKS
5181 // Expensive checks enables libstdc++ checking which includes validating the
5182 // state of ranges used in std::priority_queue - this blows out the
5183 // runtime/scalability of the function and makes this test unacceptably slow.
5184 TEST_F(FormatTest, MemoizationTests) {
5185   // This breaks if the memoization lookup does not take \c Indent and
5186   // \c LastSpace into account.
5187   verifyFormat(
5188       "extern CFRunLoopTimerRef\n"
5189       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5190       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5191       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5192       "                     CFRunLoopTimerContext *context) {}");
5193 
5194   // Deep nesting somewhat works around our memoization.
5195   verifyFormat(
5196       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5197       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5198       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5199       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5200       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5201       getLLVMStyleWithColumns(65));
5202   verifyFormat(
5203       "aaaaa(\n"
5204       "    aaaaa,\n"
5205       "    aaaaa(\n"
5206       "        aaaaa,\n"
5207       "        aaaaa(\n"
5208       "            aaaaa,\n"
5209       "            aaaaa(\n"
5210       "                aaaaa,\n"
5211       "                aaaaa(\n"
5212       "                    aaaaa,\n"
5213       "                    aaaaa(\n"
5214       "                        aaaaa,\n"
5215       "                        aaaaa(\n"
5216       "                            aaaaa,\n"
5217       "                            aaaaa(\n"
5218       "                                aaaaa,\n"
5219       "                                aaaaa(\n"
5220       "                                    aaaaa,\n"
5221       "                                    aaaaa(\n"
5222       "                                        aaaaa,\n"
5223       "                                        aaaaa(\n"
5224       "                                            aaaaa,\n"
5225       "                                            aaaaa(\n"
5226       "                                                aaaaa,\n"
5227       "                                                aaaaa))))))))))));",
5228       getLLVMStyleWithColumns(65));
5229   verifyFormat(
5230       "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n"
5231       "                                  a),\n"
5232       "                                a),\n"
5233       "                              a),\n"
5234       "                            a),\n"
5235       "                          a),\n"
5236       "                        a),\n"
5237       "                      a),\n"
5238       "                    a),\n"
5239       "                  a),\n"
5240       "                a),\n"
5241       "              a),\n"
5242       "            a),\n"
5243       "          a),\n"
5244       "        a),\n"
5245       "      a),\n"
5246       "    a),\n"
5247       "  a)",
5248       getLLVMStyleWithColumns(65));
5249 
5250   // This test takes VERY long when memoization is broken.
5251   FormatStyle OnePerLine = getLLVMStyle();
5252   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5253   OnePerLine.BinPackParameters = false;
5254   std::string input = "Constructor()\n"
5255                       "    : aaaa(a,\n";
5256   for (unsigned i = 0, e = 80; i != e; ++i) {
5257     input += "           a,\n";
5258   }
5259   input += "           a) {}";
5260   verifyFormat(input, OnePerLine);
5261 }
5262 #endif
5263 
5264 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5265   verifyFormat(
5266       "void f() {\n"
5267       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5268       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5269       "    f();\n"
5270       "}");
5271   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5272                "    Intervals[i - 1].getRange().getLast()) {\n}");
5273 }
5274 
5275 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5276   // Principially, we break function declarations in a certain order:
5277   // 1) break amongst arguments.
5278   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5279                "                              Cccccccccccccc cccccccccccccc);");
5280   verifyFormat("template <class TemplateIt>\n"
5281                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5282                "                            TemplateIt *stop) {}");
5283 
5284   // 2) break after return type.
5285   verifyFormat(
5286       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5287       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5288       getGoogleStyle());
5289 
5290   // 3) break after (.
5291   verifyFormat(
5292       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5293       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5294       getGoogleStyle());
5295 
5296   // 4) break before after nested name specifiers.
5297   verifyFormat(
5298       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5299       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5300       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5301       getGoogleStyle());
5302 
5303   // However, there are exceptions, if a sufficient amount of lines can be
5304   // saved.
5305   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5306   // more adjusting.
5307   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5308                "                                  Cccccccccccccc cccccccccc,\n"
5309                "                                  Cccccccccccccc cccccccccc,\n"
5310                "                                  Cccccccccccccc cccccccccc,\n"
5311                "                                  Cccccccccccccc cccccccccc);");
5312   verifyFormat(
5313       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5314       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5315       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5316       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5317       getGoogleStyle());
5318   verifyFormat(
5319       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5320       "                                          Cccccccccccccc cccccccccc,\n"
5321       "                                          Cccccccccccccc cccccccccc,\n"
5322       "                                          Cccccccccccccc cccccccccc,\n"
5323       "                                          Cccccccccccccc cccccccccc,\n"
5324       "                                          Cccccccccccccc cccccccccc,\n"
5325       "                                          Cccccccccccccc cccccccccc);");
5326   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5327                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5328                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5329                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5330                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5331 
5332   // Break after multi-line parameters.
5333   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5334                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5335                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5336                "    bbbb bbbb);");
5337   verifyFormat("void SomeLoooooooooooongFunction(\n"
5338                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5339                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5340                "    int bbbbbbbbbbbbb);");
5341 
5342   // Treat overloaded operators like other functions.
5343   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5344                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5345   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5346                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5347   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5348                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5349   verifyGoogleFormat(
5350       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5351       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5352   verifyGoogleFormat(
5353       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5354       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5355   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5356                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5357   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5358                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5359   verifyGoogleFormat(
5360       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5361       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5362       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5363   verifyGoogleFormat("template <typename T>\n"
5364                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5365                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5366                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5367 
5368   FormatStyle Style = getLLVMStyle();
5369   Style.PointerAlignment = FormatStyle::PAS_Left;
5370   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5371                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5372                Style);
5373   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5374                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5375                Style);
5376 }
5377 
5378 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5379   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5380   // Prefer keeping `::` followed by `operator` together.
5381   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5382             "ccccccccc::operator++() {\n"
5383             "  stuff();\n"
5384             "}",
5385             format("const aaaa::bbbbbbb\n"
5386                    "&ccccccccc::operator++() { stuff(); }",
5387                    getLLVMStyleWithColumns(40)));
5388 }
5389 
5390 TEST_F(FormatTest, TrailingReturnType) {
5391   verifyFormat("auto foo() -> int;\n");
5392   // correct trailing return type spacing
5393   verifyFormat("auto operator->() -> int;\n");
5394   verifyFormat("auto operator++(int) -> int;\n");
5395 
5396   verifyFormat("struct S {\n"
5397                "  auto bar() const -> int;\n"
5398                "};");
5399   verifyFormat("template <size_t Order, typename T>\n"
5400                "auto load_img(const std::string &filename)\n"
5401                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5402   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5403                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5404   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5405   verifyFormat("template <typename T>\n"
5406                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5407                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5408 
5409   // Not trailing return types.
5410   verifyFormat("void f() { auto a = b->c(); }");
5411 }
5412 
5413 TEST_F(FormatTest, DeductionGuides) {
5414   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5415   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5416   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5417   verifyFormat(
5418       "template <class... T>\n"
5419       "array(T &&...t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5420   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5421   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5422   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5423   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5424   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5425   verifyFormat("template <class T> x() -> x<1>;");
5426   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5427 
5428   // Ensure not deduction guides.
5429   verifyFormat("c()->f<int>();");
5430   verifyFormat("x()->foo<1>;");
5431   verifyFormat("x = p->foo<3>();");
5432   verifyFormat("x()->x<1>();");
5433   verifyFormat("x()->x<1>;");
5434 }
5435 
5436 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5437   // Avoid breaking before trailing 'const' or other trailing annotations, if
5438   // they are not function-like.
5439   FormatStyle Style = getGoogleStyle();
5440   Style.ColumnLimit = 47;
5441   verifyFormat("void someLongFunction(\n"
5442                "    int someLoooooooooooooongParameter) const {\n}",
5443                getLLVMStyleWithColumns(47));
5444   verifyFormat("LoooooongReturnType\n"
5445                "someLoooooooongFunction() const {}",
5446                getLLVMStyleWithColumns(47));
5447   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5448                "    const {}",
5449                Style);
5450   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5451                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5452   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5453                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5454   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5455                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5456   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5457                "                   aaaaaaaaaaa aaaaa) const override;");
5458   verifyGoogleFormat(
5459       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5460       "    const override;");
5461 
5462   // Even if the first parameter has to be wrapped.
5463   verifyFormat("void someLongFunction(\n"
5464                "    int someLongParameter) const {}",
5465                getLLVMStyleWithColumns(46));
5466   verifyFormat("void someLongFunction(\n"
5467                "    int someLongParameter) const {}",
5468                Style);
5469   verifyFormat("void someLongFunction(\n"
5470                "    int someLongParameter) override {}",
5471                Style);
5472   verifyFormat("void someLongFunction(\n"
5473                "    int someLongParameter) OVERRIDE {}",
5474                Style);
5475   verifyFormat("void someLongFunction(\n"
5476                "    int someLongParameter) final {}",
5477                Style);
5478   verifyFormat("void someLongFunction(\n"
5479                "    int someLongParameter) FINAL {}",
5480                Style);
5481   verifyFormat("void someLongFunction(\n"
5482                "    int parameter) const override {}",
5483                Style);
5484 
5485   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5486   verifyFormat("void someLongFunction(\n"
5487                "    int someLongParameter) const\n"
5488                "{\n"
5489                "}",
5490                Style);
5491 
5492   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5493   verifyFormat("void someLongFunction(\n"
5494                "    int someLongParameter) const\n"
5495                "  {\n"
5496                "  }",
5497                Style);
5498 
5499   // Unless these are unknown annotations.
5500   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5501                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5502                "    LONG_AND_UGLY_ANNOTATION;");
5503 
5504   // Breaking before function-like trailing annotations is fine to keep them
5505   // close to their arguments.
5506   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5507                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5508   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5509                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5510   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5511                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5512   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5513                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5514   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5515 
5516   verifyFormat(
5517       "void aaaaaaaaaaaaaaaaaa()\n"
5518       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5519       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5520   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5521                "    __attribute__((unused));");
5522   verifyGoogleFormat(
5523       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5524       "    GUARDED_BY(aaaaaaaaaaaa);");
5525   verifyGoogleFormat(
5526       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5527       "    GUARDED_BY(aaaaaaaaaaaa);");
5528   verifyGoogleFormat(
5529       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5530       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5531   verifyGoogleFormat(
5532       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5533       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5534 }
5535 
5536 TEST_F(FormatTest, FunctionAnnotations) {
5537   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5538                "int OldFunction(const string &parameter) {}");
5539   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5540                "string OldFunction(const string &parameter) {}");
5541   verifyFormat("template <typename T>\n"
5542                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5543                "string OldFunction(const string &parameter) {}");
5544 
5545   // Not function annotations.
5546   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5547                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5548   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5549                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5550   verifyFormat("MACRO(abc).function() // wrap\n"
5551                "    << abc;");
5552   verifyFormat("MACRO(abc)->function() // wrap\n"
5553                "    << abc;");
5554   verifyFormat("MACRO(abc)::function() // wrap\n"
5555                "    << abc;");
5556 }
5557 
5558 TEST_F(FormatTest, BreaksDesireably) {
5559   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5560                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5561                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5562   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5563                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5564                "}");
5565 
5566   verifyFormat(
5567       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5568       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5569 
5570   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5571                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5572                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5573 
5574   verifyFormat(
5575       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5576       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5577       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5578       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5579       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5580 
5581   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5582                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5583 
5584   verifyFormat(
5585       "void f() {\n"
5586       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5587       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5588       "}");
5589   verifyFormat(
5590       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5591       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5592   verifyFormat(
5593       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5594       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5595   verifyFormat(
5596       "aaaaaa(aaa,\n"
5597       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5598       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5599       "       aaaa);");
5600   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5601                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5602                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5603 
5604   // Indent consistently independent of call expression and unary operator.
5605   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5606                "    dddddddddddddddddddddddddddddd));");
5607   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5608                "    dddddddddddddddddddddddddddddd));");
5609   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5610                "    dddddddddddddddddddddddddddddd));");
5611 
5612   // This test case breaks on an incorrect memoization, i.e. an optimization not
5613   // taking into account the StopAt value.
5614   verifyFormat(
5615       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5616       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5617       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5618       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5619 
5620   verifyFormat("{\n  {\n    {\n"
5621                "      Annotation.SpaceRequiredBefore =\n"
5622                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5623                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5624                "    }\n  }\n}");
5625 
5626   // Break on an outer level if there was a break on an inner level.
5627   EXPECT_EQ("f(g(h(a, // comment\n"
5628             "      b, c),\n"
5629             "    d, e),\n"
5630             "  x, y);",
5631             format("f(g(h(a, // comment\n"
5632                    "    b, c), d, e), x, y);"));
5633 
5634   // Prefer breaking similar line breaks.
5635   verifyFormat(
5636       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5637       "                             NSTrackingMouseEnteredAndExited |\n"
5638       "                             NSTrackingActiveAlways;");
5639 }
5640 
5641 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5642   FormatStyle NoBinPacking = getGoogleStyle();
5643   NoBinPacking.BinPackParameters = false;
5644   NoBinPacking.BinPackArguments = true;
5645   verifyFormat("void f() {\n"
5646                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5647                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5648                "}",
5649                NoBinPacking);
5650   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5651                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5652                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5653                NoBinPacking);
5654 
5655   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5656   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5657                "                        vector<int> bbbbbbbbbbbbbbb);",
5658                NoBinPacking);
5659   // FIXME: This behavior difference is probably not wanted. However, currently
5660   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5661   // template arguments from BreakBeforeParameter being set because of the
5662   // one-per-line formatting.
5663   verifyFormat(
5664       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5665       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5666       NoBinPacking);
5667   verifyFormat(
5668       "void fffffffffff(\n"
5669       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5670       "        aaaaaaaaaa);");
5671 }
5672 
5673 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5674   FormatStyle NoBinPacking = getGoogleStyle();
5675   NoBinPacking.BinPackParameters = false;
5676   NoBinPacking.BinPackArguments = false;
5677   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5678                "  aaaaaaaaaaaaaaaaaaaa,\n"
5679                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5680                NoBinPacking);
5681   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5682                "        aaaaaaaaaaaaa,\n"
5683                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5684                NoBinPacking);
5685   verifyFormat(
5686       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5687       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5688       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5689       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5690       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5691       NoBinPacking);
5692   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5693                "    .aaaaaaaaaaaaaaaaaa();",
5694                NoBinPacking);
5695   verifyFormat("void f() {\n"
5696                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5697                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5698                "}",
5699                NoBinPacking);
5700 
5701   verifyFormat(
5702       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5703       "             aaaaaaaaaaaa,\n"
5704       "             aaaaaaaaaaaa);",
5705       NoBinPacking);
5706   verifyFormat(
5707       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5708       "                               ddddddddddddddddddddddddddddd),\n"
5709       "             test);",
5710       NoBinPacking);
5711 
5712   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5713                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5714                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5715                "    aaaaaaaaaaaaaaaaaa;",
5716                NoBinPacking);
5717   verifyFormat("a(\"a\"\n"
5718                "  \"a\",\n"
5719                "  a);");
5720 
5721   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5722   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5723                "                aaaaaaaaa,\n"
5724                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5725                NoBinPacking);
5726   verifyFormat(
5727       "void f() {\n"
5728       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5729       "      .aaaaaaa();\n"
5730       "}",
5731       NoBinPacking);
5732   verifyFormat(
5733       "template <class SomeType, class SomeOtherType>\n"
5734       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5735       NoBinPacking);
5736 }
5737 
5738 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5739   FormatStyle Style = getLLVMStyleWithColumns(15);
5740   Style.ExperimentalAutoDetectBinPacking = true;
5741   EXPECT_EQ("aaa(aaaa,\n"
5742             "    aaaa,\n"
5743             "    aaaa);\n"
5744             "aaa(aaaa,\n"
5745             "    aaaa,\n"
5746             "    aaaa);",
5747             format("aaa(aaaa,\n" // one-per-line
5748                    "  aaaa,\n"
5749                    "    aaaa  );\n"
5750                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5751                    Style));
5752   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5753             "    aaaa);\n"
5754             "aaa(aaaa, aaaa,\n"
5755             "    aaaa);",
5756             format("aaa(aaaa,  aaaa,\n" // bin-packed
5757                    "    aaaa  );\n"
5758                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5759                    Style));
5760 }
5761 
5762 TEST_F(FormatTest, FormatsBuilderPattern) {
5763   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5764                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5765                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5766                "    .StartsWith(\".init\", ORDER_INIT)\n"
5767                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5768                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5769                "    .Default(ORDER_TEXT);\n");
5770 
5771   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5772                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5773   verifyFormat("aaaaaaa->aaaaaaa\n"
5774                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5775                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5776                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5777   verifyFormat(
5778       "aaaaaaa->aaaaaaa\n"
5779       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5780       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5781   verifyFormat(
5782       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5783       "    aaaaaaaaaaaaaa);");
5784   verifyFormat(
5785       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5786       "    aaaaaa->aaaaaaaaaaaa()\n"
5787       "        ->aaaaaaaaaaaaaaaa(\n"
5788       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5789       "        ->aaaaaaaaaaaaaaaaa();");
5790   verifyGoogleFormat(
5791       "void f() {\n"
5792       "  someo->Add((new util::filetools::Handler(dir))\n"
5793       "                 ->OnEvent1(NewPermanentCallback(\n"
5794       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5795       "                 ->OnEvent2(NewPermanentCallback(\n"
5796       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5797       "                 ->OnEvent3(NewPermanentCallback(\n"
5798       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5799       "                 ->OnEvent5(NewPermanentCallback(\n"
5800       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5801       "                 ->OnEvent6(NewPermanentCallback(\n"
5802       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5803       "}");
5804 
5805   verifyFormat(
5806       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5807   verifyFormat("aaaaaaaaaaaaaaa()\n"
5808                "    .aaaaaaaaaaaaaaa()\n"
5809                "    .aaaaaaaaaaaaaaa()\n"
5810                "    .aaaaaaaaaaaaaaa()\n"
5811                "    .aaaaaaaaaaaaaaa();");
5812   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5813                "    .aaaaaaaaaaaaaaa()\n"
5814                "    .aaaaaaaaaaaaaaa()\n"
5815                "    .aaaaaaaaaaaaaaa();");
5816   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5817                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5818                "    .aaaaaaaaaaaaaaa();");
5819   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5820                "    ->aaaaaaaaaaaaaae(0)\n"
5821                "    ->aaaaaaaaaaaaaaa();");
5822 
5823   // Don't linewrap after very short segments.
5824   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5825                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5826                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5827   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5828                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5829                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5830   verifyFormat("aaa()\n"
5831                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5832                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5833                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5834 
5835   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5836                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5837                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5838   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5839                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5840                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5841 
5842   // Prefer not to break after empty parentheses.
5843   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5844                "    First->LastNewlineOffset);");
5845 
5846   // Prefer not to create "hanging" indents.
5847   verifyFormat(
5848       "return !soooooooooooooome_map\n"
5849       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5850       "            .second;");
5851   verifyFormat(
5852       "return aaaaaaaaaaaaaaaa\n"
5853       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5854       "    .aaaa(aaaaaaaaaaaaaa);");
5855   // No hanging indent here.
5856   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5857                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5858   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5859                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5860   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5861                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5862                getLLVMStyleWithColumns(60));
5863   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5864                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5865                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5866                getLLVMStyleWithColumns(59));
5867   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5868                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5869                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5870 
5871   // Dont break if only closing statements before member call
5872   verifyFormat("test() {\n"
5873                "  ([]() -> {\n"
5874                "    int b = 32;\n"
5875                "    return 3;\n"
5876                "  }).foo();\n"
5877                "}");
5878   verifyFormat("test() {\n"
5879                "  (\n"
5880                "      []() -> {\n"
5881                "        int b = 32;\n"
5882                "        return 3;\n"
5883                "      },\n"
5884                "      foo, bar)\n"
5885                "      .foo();\n"
5886                "}");
5887   verifyFormat("test() {\n"
5888                "  ([]() -> {\n"
5889                "    int b = 32;\n"
5890                "    return 3;\n"
5891                "  })\n"
5892                "      .foo()\n"
5893                "      .bar();\n"
5894                "}");
5895   verifyFormat("test() {\n"
5896                "  ([]() -> {\n"
5897                "    int b = 32;\n"
5898                "    return 3;\n"
5899                "  })\n"
5900                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5901                "           \"bbbb\");\n"
5902                "}",
5903                getLLVMStyleWithColumns(30));
5904 }
5905 
5906 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5907   verifyFormat(
5908       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5909       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5910   verifyFormat(
5911       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5912       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5913 
5914   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5915                "    ccccccccccccccccccccccccc) {\n}");
5916   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5917                "    ccccccccccccccccccccccccc) {\n}");
5918 
5919   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5920                "    ccccccccccccccccccccccccc) {\n}");
5921   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5922                "    ccccccccccccccccccccccccc) {\n}");
5923 
5924   verifyFormat(
5925       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5926       "    ccccccccccccccccccccccccc) {\n}");
5927   verifyFormat(
5928       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5929       "    ccccccccccccccccccccccccc) {\n}");
5930 
5931   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5932                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5933                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5934                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5935   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5936                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5937                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5938                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5939 
5940   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5941                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5942                "    aaaaaaaaaaaaaaa != aa) {\n}");
5943   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5944                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5945                "    aaaaaaaaaaaaaaa != aa) {\n}");
5946 }
5947 
5948 TEST_F(FormatTest, BreaksAfterAssignments) {
5949   verifyFormat(
5950       "unsigned Cost =\n"
5951       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
5952       "                        SI->getPointerAddressSpaceee());\n");
5953   verifyFormat(
5954       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
5955       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
5956 
5957   verifyFormat(
5958       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
5959       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
5960   verifyFormat("unsigned OriginalStartColumn =\n"
5961                "    SourceMgr.getSpellingColumnNumber(\n"
5962                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
5963                "    1;");
5964 }
5965 
5966 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
5967   FormatStyle Style = getLLVMStyle();
5968   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5969                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
5970                Style);
5971 
5972   Style.PenaltyBreakAssignment = 20;
5973   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5974                "                                 cccccccccccccccccccccccccc;",
5975                Style);
5976 }
5977 
5978 TEST_F(FormatTest, AlignsAfterAssignments) {
5979   verifyFormat(
5980       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5981       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
5982   verifyFormat(
5983       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5984       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
5985   verifyFormat(
5986       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5987       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
5988   verifyFormat(
5989       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5990       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
5991   verifyFormat(
5992       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5993       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5994       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
5995 }
5996 
5997 TEST_F(FormatTest, AlignsAfterReturn) {
5998   verifyFormat(
5999       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6000       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
6001   verifyFormat(
6002       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6003       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
6004   verifyFormat(
6005       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
6006       "       aaaaaaaaaaaaaaaaaaaaaa();");
6007   verifyFormat(
6008       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
6009       "        aaaaaaaaaaaaaaaaaaaaaa());");
6010   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6011                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6012   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6013                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
6014                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6015   verifyFormat("return\n"
6016                "    // true if code is one of a or b.\n"
6017                "    code == a || code == b;");
6018 }
6019 
6020 TEST_F(FormatTest, AlignsAfterOpenBracket) {
6021   verifyFormat(
6022       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6023       "                                                aaaaaaaaa aaaaaaa) {}");
6024   verifyFormat(
6025       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6026       "                                               aaaaaaaaaaa aaaaaaaaa);");
6027   verifyFormat(
6028       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6029       "                                             aaaaaaaaaaaaaaaaaaaaa));");
6030   FormatStyle Style = getLLVMStyle();
6031   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6032   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6033                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
6034                Style);
6035   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6036                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
6037                Style);
6038   verifyFormat("SomeLongVariableName->someFunction(\n"
6039                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
6040                Style);
6041   verifyFormat(
6042       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6043       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6044       Style);
6045   verifyFormat(
6046       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6047       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6048       Style);
6049   verifyFormat(
6050       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6051       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6052       Style);
6053 
6054   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
6055                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
6056                "        b));",
6057                Style);
6058 
6059   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6060   Style.BinPackArguments = false;
6061   Style.BinPackParameters = false;
6062   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6063                "    aaaaaaaaaaa aaaaaaaa,\n"
6064                "    aaaaaaaaa aaaaaaa,\n"
6065                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6066                Style);
6067   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6068                "    aaaaaaaaaaa aaaaaaaaa,\n"
6069                "    aaaaaaaaaaa aaaaaaaaa,\n"
6070                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6071                Style);
6072   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
6073                "    aaaaaaaaaaaaaaa,\n"
6074                "    aaaaaaaaaaaaaaaaaaaaa,\n"
6075                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6076                Style);
6077   verifyFormat(
6078       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
6079       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6080       Style);
6081   verifyFormat(
6082       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
6083       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6084       Style);
6085   verifyFormat(
6086       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6087       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6088       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
6089       "    aaaaaaaaaaaaaaaa);",
6090       Style);
6091   verifyFormat(
6092       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6093       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6094       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
6095       "    aaaaaaaaaaaaaaaa);",
6096       Style);
6097 }
6098 
6099 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
6100   FormatStyle Style = getLLVMStyleWithColumns(40);
6101   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6102                "          bbbbbbbbbbbbbbbbbbbbbb);",
6103                Style);
6104   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6105   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6106   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6107                "          bbbbbbbbbbbbbbbbbbbbbb);",
6108                Style);
6109   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6110   Style.AlignOperands = FormatStyle::OAS_Align;
6111   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6112                "          bbbbbbbbbbbbbbbbbbbbbb);",
6113                Style);
6114   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6115   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6116   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6117                "    bbbbbbbbbbbbbbbbbbbbbb);",
6118                Style);
6119 }
6120 
6121 TEST_F(FormatTest, BreaksConditionalExpressions) {
6122   verifyFormat(
6123       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6124       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6125       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6126   verifyFormat(
6127       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6128       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6129       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6130   verifyFormat(
6131       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6132       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6133   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6134                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6135                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6136   verifyFormat(
6137       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6138       "                                                    : aaaaaaaaaaaaa);");
6139   verifyFormat(
6140       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6141       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6142       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6143       "                   aaaaaaaaaaaaa);");
6144   verifyFormat(
6145       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6146       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6147       "                   aaaaaaaaaaaaa);");
6148   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6149                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6150                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6151                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6152                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6153   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6154                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6155                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6156                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6157                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6158                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6159                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6160   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6161                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6162                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6163                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6164                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6165   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6166                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6167                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6168   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6169                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6170                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6171                "        : aaaaaaaaaaaaaaaa;");
6172   verifyFormat(
6173       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6174       "    ? aaaaaaaaaaaaaaa\n"
6175       "    : aaaaaaaaaaaaaaa;");
6176   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6177                "          aaaaaaaaa\n"
6178                "      ? b\n"
6179                "      : c);");
6180   verifyFormat("return aaaa == bbbb\n"
6181                "           // comment\n"
6182                "           ? aaaa\n"
6183                "           : bbbb;");
6184   verifyFormat("unsigned Indent =\n"
6185                "    format(TheLine.First,\n"
6186                "           IndentForLevel[TheLine.Level] >= 0\n"
6187                "               ? IndentForLevel[TheLine.Level]\n"
6188                "               : TheLine * 2,\n"
6189                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6190                getLLVMStyleWithColumns(60));
6191   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6192                "                  ? aaaaaaaaaaaaaaa\n"
6193                "                  : bbbbbbbbbbbbbbb //\n"
6194                "                        ? ccccccccccccccc\n"
6195                "                        : ddddddddddddddd;");
6196   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6197                "                  ? aaaaaaaaaaaaaaa\n"
6198                "                  : (bbbbbbbbbbbbbbb //\n"
6199                "                         ? ccccccccccccccc\n"
6200                "                         : ddddddddddddddd);");
6201   verifyFormat(
6202       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6203       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6204       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6205       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6206       "                                      : aaaaaaaaaa;");
6207   verifyFormat(
6208       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6209       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6210       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6211 
6212   FormatStyle NoBinPacking = getLLVMStyle();
6213   NoBinPacking.BinPackArguments = false;
6214   verifyFormat(
6215       "void f() {\n"
6216       "  g(aaa,\n"
6217       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6218       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6219       "        ? aaaaaaaaaaaaaaa\n"
6220       "        : aaaaaaaaaaaaaaa);\n"
6221       "}",
6222       NoBinPacking);
6223   verifyFormat(
6224       "void f() {\n"
6225       "  g(aaa,\n"
6226       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6227       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6228       "        ?: aaaaaaaaaaaaaaa);\n"
6229       "}",
6230       NoBinPacking);
6231 
6232   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6233                "             // comment.\n"
6234                "             ccccccccccccccccccccccccccccccccccccccc\n"
6235                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6236                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6237 
6238   // Assignments in conditional expressions. Apparently not uncommon :-(.
6239   verifyFormat("return a != b\n"
6240                "           // comment\n"
6241                "           ? a = b\n"
6242                "           : a = b;");
6243   verifyFormat("return a != b\n"
6244                "           // comment\n"
6245                "           ? a = a != b\n"
6246                "                     // comment\n"
6247                "                     ? a = b\n"
6248                "                     : a\n"
6249                "           : a;\n");
6250   verifyFormat("return a != b\n"
6251                "           // comment\n"
6252                "           ? a\n"
6253                "           : a = a != b\n"
6254                "                     // comment\n"
6255                "                     ? a = b\n"
6256                "                     : a;");
6257 
6258   // Chained conditionals
6259   FormatStyle Style = getLLVMStyle();
6260   Style.ColumnLimit = 70;
6261   Style.AlignOperands = FormatStyle::OAS_Align;
6262   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6263                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6264                "                        : 3333333333333333;",
6265                Style);
6266   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6267                "       : bbbbbbbbbb     ? 2222222222222222\n"
6268                "                        : 3333333333333333;",
6269                Style);
6270   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6271                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6272                "                          : 3333333333333333;",
6273                Style);
6274   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6275                "       : bbbbbbbbbbbbbb ? 222222\n"
6276                "                        : 333333;",
6277                Style);
6278   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6279                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6280                "       : cccccccccccccc ? 3333333333333333\n"
6281                "                        : 4444444444444444;",
6282                Style);
6283   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6284                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6285                "                        : 3333333333333333;",
6286                Style);
6287   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6288                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6289                "                        : (aaa ? bbb : ccc);",
6290                Style);
6291   verifyFormat(
6292       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6293       "                                             : cccccccccccccccccc)\n"
6294       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6295       "                        : 3333333333333333;",
6296       Style);
6297   verifyFormat(
6298       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6299       "                                             : cccccccccccccccccc)\n"
6300       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6301       "                        : 3333333333333333;",
6302       Style);
6303   verifyFormat(
6304       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6305       "                                             : dddddddddddddddddd)\n"
6306       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6307       "                        : 3333333333333333;",
6308       Style);
6309   verifyFormat(
6310       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6311       "                                             : dddddddddddddddddd)\n"
6312       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6313       "                        : 3333333333333333;",
6314       Style);
6315   verifyFormat(
6316       "return aaaaaaaaa        ? 1111111111111111\n"
6317       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6318       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6319       "                                             : dddddddddddddddddd)\n",
6320       Style);
6321   verifyFormat(
6322       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6323       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6324       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6325       "                                             : cccccccccccccccccc);",
6326       Style);
6327   verifyFormat(
6328       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6329       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6330       "                                             : eeeeeeeeeeeeeeeeee)\n"
6331       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6332       "                        : 3333333333333333;",
6333       Style);
6334   verifyFormat(
6335       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6336       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6337       "                                             : eeeeeeeeeeeeeeeeee)\n"
6338       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6339       "                        : 3333333333333333;",
6340       Style);
6341   verifyFormat(
6342       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6343       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6344       "                                             : eeeeeeeeeeeeeeeeee)\n"
6345       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6346       "                        : 3333333333333333;",
6347       Style);
6348   verifyFormat(
6349       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6350       "                                             : cccccccccccccccccc\n"
6351       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6352       "                        : 3333333333333333;",
6353       Style);
6354   verifyFormat(
6355       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6356       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6357       "                                             : eeeeeeeeeeeeeeeeee\n"
6358       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6359       "                        : 3333333333333333;",
6360       Style);
6361   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6362                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6363                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6364                "                                   : eeeeeeeeeeeeeeeeee)\n"
6365                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6366                "                             : 3333333333333333;",
6367                Style);
6368   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6369                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6370                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6371                "                                : eeeeeeeeeeeeeeeeee\n"
6372                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6373                "                                 : 3333333333333333;",
6374                Style);
6375 
6376   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6377   Style.BreakBeforeTernaryOperators = false;
6378   // FIXME: Aligning the question marks is weird given DontAlign.
6379   // Consider disabling this alignment in this case. Also check whether this
6380   // will render the adjustment from https://reviews.llvm.org/D82199
6381   // unnecessary.
6382   verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
6383                "    bbbb                ? cccccccccccccccccc :\n"
6384                "                          ddddd;\n",
6385                Style);
6386 }
6387 
6388 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6389   FormatStyle Style = getLLVMStyle();
6390   Style.BreakBeforeTernaryOperators = false;
6391   Style.ColumnLimit = 70;
6392   verifyFormat(
6393       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6394       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6395       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6396       Style);
6397   verifyFormat(
6398       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6399       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6400       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6401       Style);
6402   verifyFormat(
6403       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6404       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6405       Style);
6406   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6407                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6408                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6409                Style);
6410   verifyFormat(
6411       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6412       "                                                      aaaaaaaaaaaaa);",
6413       Style);
6414   verifyFormat(
6415       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6416       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6417       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6418       "                   aaaaaaaaaaaaa);",
6419       Style);
6420   verifyFormat(
6421       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6422       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6423       "                   aaaaaaaaaaaaa);",
6424       Style);
6425   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6426                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6427                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6428                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6429                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6430                Style);
6431   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6432                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6433                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6434                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6435                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6436                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6437                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6438                Style);
6439   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6440                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6441                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6442                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6443                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6444                Style);
6445   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6446                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6447                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6448                Style);
6449   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6450                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6451                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6452                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6453                Style);
6454   verifyFormat(
6455       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6456       "    aaaaaaaaaaaaaaa :\n"
6457       "    aaaaaaaaaaaaaaa;",
6458       Style);
6459   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6460                "          aaaaaaaaa ?\n"
6461                "      b :\n"
6462                "      c);",
6463                Style);
6464   verifyFormat("unsigned Indent =\n"
6465                "    format(TheLine.First,\n"
6466                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6467                "               IndentForLevel[TheLine.Level] :\n"
6468                "               TheLine * 2,\n"
6469                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6470                Style);
6471   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6472                "                  aaaaaaaaaaaaaaa :\n"
6473                "                  bbbbbbbbbbbbbbb ? //\n"
6474                "                      ccccccccccccccc :\n"
6475                "                      ddddddddddddddd;",
6476                Style);
6477   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6478                "                  aaaaaaaaaaaaaaa :\n"
6479                "                  (bbbbbbbbbbbbbbb ? //\n"
6480                "                       ccccccccccccccc :\n"
6481                "                       ddddddddddddddd);",
6482                Style);
6483   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6484                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6485                "            ccccccccccccccccccccccccccc;",
6486                Style);
6487   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6488                "           aaaaa :\n"
6489                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6490                Style);
6491 
6492   // Chained conditionals
6493   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6494                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6495                "                          3333333333333333;",
6496                Style);
6497   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6498                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6499                "                          3333333333333333;",
6500                Style);
6501   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6502                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6503                "                          3333333333333333;",
6504                Style);
6505   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6506                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6507                "                          333333;",
6508                Style);
6509   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6510                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6511                "       cccccccccccccccc ? 3333333333333333 :\n"
6512                "                          4444444444444444;",
6513                Style);
6514   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6515                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6516                "                          3333333333333333;",
6517                Style);
6518   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6519                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6520                "                          (aaa ? bbb : ccc);",
6521                Style);
6522   verifyFormat(
6523       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6524       "                                               cccccccccccccccccc) :\n"
6525       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6526       "                          3333333333333333;",
6527       Style);
6528   verifyFormat(
6529       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6530       "                                               cccccccccccccccccc) :\n"
6531       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6532       "                          3333333333333333;",
6533       Style);
6534   verifyFormat(
6535       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6536       "                                               dddddddddddddddddd) :\n"
6537       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6538       "                          3333333333333333;",
6539       Style);
6540   verifyFormat(
6541       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6542       "                                               dddddddddddddddddd) :\n"
6543       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6544       "                          3333333333333333;",
6545       Style);
6546   verifyFormat(
6547       "return aaaaaaaaa        ? 1111111111111111 :\n"
6548       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6549       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6550       "                                               dddddddddddddddddd)\n",
6551       Style);
6552   verifyFormat(
6553       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6554       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6555       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6556       "                                               cccccccccccccccccc);",
6557       Style);
6558   verifyFormat(
6559       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6560       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6561       "                                               eeeeeeeeeeeeeeeeee) :\n"
6562       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6563       "                          3333333333333333;",
6564       Style);
6565   verifyFormat(
6566       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6567       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6568       "                                               eeeeeeeeeeeeeeeeee) :\n"
6569       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6570       "                          3333333333333333;",
6571       Style);
6572   verifyFormat(
6573       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6574       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6575       "                                               eeeeeeeeeeeeeeeeee) :\n"
6576       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6577       "                          3333333333333333;",
6578       Style);
6579   verifyFormat(
6580       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6581       "                                               cccccccccccccccccc :\n"
6582       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6583       "                          3333333333333333;",
6584       Style);
6585   verifyFormat(
6586       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6587       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6588       "                                               eeeeeeeeeeeeeeeeee :\n"
6589       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6590       "                          3333333333333333;",
6591       Style);
6592   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6593                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6594                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6595                "                                 eeeeeeeeeeeeeeeeee) :\n"
6596                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6597                "                               3333333333333333;",
6598                Style);
6599   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6600                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6601                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6602                "                                  eeeeeeeeeeeeeeeeee :\n"
6603                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6604                "                               3333333333333333;",
6605                Style);
6606 }
6607 
6608 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6609   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6610                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6611   verifyFormat("bool a = true, b = false;");
6612 
6613   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6614                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6615                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6616                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6617   verifyFormat(
6618       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6619       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6620       "     d = e && f;");
6621   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6622                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6623   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6624                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6625   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6626                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6627 
6628   FormatStyle Style = getGoogleStyle();
6629   Style.PointerAlignment = FormatStyle::PAS_Left;
6630   Style.DerivePointerAlignment = false;
6631   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6632                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6633                "    *b = bbbbbbbbbbbbbbbbbbb;",
6634                Style);
6635   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6636                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6637                Style);
6638   verifyFormat("vector<int*> a, b;", Style);
6639   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6640 }
6641 
6642 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6643   verifyFormat("arr[foo ? bar : baz];");
6644   verifyFormat("f()[foo ? bar : baz];");
6645   verifyFormat("(a + b)[foo ? bar : baz];");
6646   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6647 }
6648 
6649 TEST_F(FormatTest, AlignsStringLiterals) {
6650   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6651                "                                      \"short literal\");");
6652   verifyFormat(
6653       "looooooooooooooooooooooooongFunction(\n"
6654       "    \"short literal\"\n"
6655       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6656   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6657                "             \" string literals\",\n"
6658                "             and, other, parameters);");
6659   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6660             "      \"5678\";",
6661             format("fun + \"1243\" /* comment */\n"
6662                    "    \"5678\";",
6663                    getLLVMStyleWithColumns(28)));
6664   EXPECT_EQ(
6665       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6666       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6667       "         \"aaaaaaaaaaaaaaaa\";",
6668       format("aaaaaa ="
6669              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6670              "aaaaaaaaaaaaaaaaaaaaa\" "
6671              "\"aaaaaaaaaaaaaaaa\";"));
6672   verifyFormat("a = a + \"a\"\n"
6673                "        \"a\"\n"
6674                "        \"a\";");
6675   verifyFormat("f(\"a\", \"b\"\n"
6676                "       \"c\");");
6677 
6678   verifyFormat(
6679       "#define LL_FORMAT \"ll\"\n"
6680       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6681       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6682 
6683   verifyFormat("#define A(X)          \\\n"
6684                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6685                "  \"ccccc\"",
6686                getLLVMStyleWithColumns(23));
6687   verifyFormat("#define A \"def\"\n"
6688                "f(\"abc\" A \"ghi\"\n"
6689                "  \"jkl\");");
6690 
6691   verifyFormat("f(L\"a\"\n"
6692                "  L\"b\");");
6693   verifyFormat("#define A(X)            \\\n"
6694                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6695                "  L\"ccccc\"",
6696                getLLVMStyleWithColumns(25));
6697 
6698   verifyFormat("f(@\"a\"\n"
6699                "  @\"b\");");
6700   verifyFormat("NSString s = @\"a\"\n"
6701                "             @\"b\"\n"
6702                "             @\"c\";");
6703   verifyFormat("NSString s = @\"a\"\n"
6704                "              \"b\"\n"
6705                "              \"c\";");
6706 }
6707 
6708 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6709   FormatStyle Style = getLLVMStyle();
6710   // No declarations or definitions should be moved to own line.
6711   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6712   verifyFormat("class A {\n"
6713                "  int f() { return 1; }\n"
6714                "  int g();\n"
6715                "};\n"
6716                "int f() { return 1; }\n"
6717                "int g();\n",
6718                Style);
6719 
6720   // All declarations and definitions should have the return type moved to its
6721   // own line.
6722   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6723   Style.TypenameMacros = {"LIST"};
6724   verifyFormat("SomeType\n"
6725                "funcdecl(LIST(uint64_t));",
6726                Style);
6727   verifyFormat("class E {\n"
6728                "  int\n"
6729                "  f() {\n"
6730                "    return 1;\n"
6731                "  }\n"
6732                "  int\n"
6733                "  g();\n"
6734                "};\n"
6735                "int\n"
6736                "f() {\n"
6737                "  return 1;\n"
6738                "}\n"
6739                "int\n"
6740                "g();\n",
6741                Style);
6742 
6743   // Top-level definitions, and no kinds of declarations should have the
6744   // return type moved to its own line.
6745   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6746   verifyFormat("class B {\n"
6747                "  int f() { return 1; }\n"
6748                "  int g();\n"
6749                "};\n"
6750                "int\n"
6751                "f() {\n"
6752                "  return 1;\n"
6753                "}\n"
6754                "int g();\n",
6755                Style);
6756 
6757   // Top-level definitions and declarations should have the return type moved
6758   // to its own line.
6759   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6760   verifyFormat("class C {\n"
6761                "  int f() { return 1; }\n"
6762                "  int g();\n"
6763                "};\n"
6764                "int\n"
6765                "f() {\n"
6766                "  return 1;\n"
6767                "}\n"
6768                "int\n"
6769                "g();\n",
6770                Style);
6771 
6772   // All definitions should have the return type moved to its own line, but no
6773   // kinds of declarations.
6774   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6775   verifyFormat("class D {\n"
6776                "  int\n"
6777                "  f() {\n"
6778                "    return 1;\n"
6779                "  }\n"
6780                "  int g();\n"
6781                "};\n"
6782                "int\n"
6783                "f() {\n"
6784                "  return 1;\n"
6785                "}\n"
6786                "int g();\n",
6787                Style);
6788   verifyFormat("const char *\n"
6789                "f(void) {\n" // Break here.
6790                "  return \"\";\n"
6791                "}\n"
6792                "const char *bar(void);\n", // No break here.
6793                Style);
6794   verifyFormat("template <class T>\n"
6795                "T *\n"
6796                "f(T &c) {\n" // Break here.
6797                "  return NULL;\n"
6798                "}\n"
6799                "template <class T> T *f(T &c);\n", // No break here.
6800                Style);
6801   verifyFormat("class C {\n"
6802                "  int\n"
6803                "  operator+() {\n"
6804                "    return 1;\n"
6805                "  }\n"
6806                "  int\n"
6807                "  operator()() {\n"
6808                "    return 1;\n"
6809                "  }\n"
6810                "};\n",
6811                Style);
6812   verifyFormat("void\n"
6813                "A::operator()() {}\n"
6814                "void\n"
6815                "A::operator>>() {}\n"
6816                "void\n"
6817                "A::operator+() {}\n"
6818                "void\n"
6819                "A::operator*() {}\n"
6820                "void\n"
6821                "A::operator->() {}\n"
6822                "void\n"
6823                "A::operator void *() {}\n"
6824                "void\n"
6825                "A::operator void &() {}\n"
6826                "void\n"
6827                "A::operator void &&() {}\n"
6828                "void\n"
6829                "A::operator char *() {}\n"
6830                "void\n"
6831                "A::operator[]() {}\n"
6832                "void\n"
6833                "A::operator!() {}\n"
6834                "void\n"
6835                "A::operator**() {}\n"
6836                "void\n"
6837                "A::operator<Foo> *() {}\n"
6838                "void\n"
6839                "A::operator<Foo> **() {}\n"
6840                "void\n"
6841                "A::operator<Foo> &() {}\n"
6842                "void\n"
6843                "A::operator void **() {}\n",
6844                Style);
6845   verifyFormat("constexpr auto\n"
6846                "operator()() const -> reference {}\n"
6847                "constexpr auto\n"
6848                "operator>>() const -> reference {}\n"
6849                "constexpr auto\n"
6850                "operator+() const -> reference {}\n"
6851                "constexpr auto\n"
6852                "operator*() const -> reference {}\n"
6853                "constexpr auto\n"
6854                "operator->() const -> reference {}\n"
6855                "constexpr auto\n"
6856                "operator++() const -> reference {}\n"
6857                "constexpr auto\n"
6858                "operator void *() const -> reference {}\n"
6859                "constexpr auto\n"
6860                "operator void **() const -> reference {}\n"
6861                "constexpr auto\n"
6862                "operator void *() const -> reference {}\n"
6863                "constexpr auto\n"
6864                "operator void &() const -> reference {}\n"
6865                "constexpr auto\n"
6866                "operator void &&() const -> reference {}\n"
6867                "constexpr auto\n"
6868                "operator char *() const -> reference {}\n"
6869                "constexpr auto\n"
6870                "operator!() const -> reference {}\n"
6871                "constexpr auto\n"
6872                "operator[]() const -> reference {}\n",
6873                Style);
6874   verifyFormat("void *operator new(std::size_t s);", // No break here.
6875                Style);
6876   verifyFormat("void *\n"
6877                "operator new(std::size_t s) {}",
6878                Style);
6879   verifyFormat("void *\n"
6880                "operator delete[](void *ptr) {}",
6881                Style);
6882   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6883   verifyFormat("const char *\n"
6884                "f(void)\n" // Break here.
6885                "{\n"
6886                "  return \"\";\n"
6887                "}\n"
6888                "const char *bar(void);\n", // No break here.
6889                Style);
6890   verifyFormat("template <class T>\n"
6891                "T *\n"     // Problem here: no line break
6892                "f(T &c)\n" // Break here.
6893                "{\n"
6894                "  return NULL;\n"
6895                "}\n"
6896                "template <class T> T *f(T &c);\n", // No break here.
6897                Style);
6898   verifyFormat("int\n"
6899                "foo(A<bool> a)\n"
6900                "{\n"
6901                "  return a;\n"
6902                "}\n",
6903                Style);
6904   verifyFormat("int\n"
6905                "foo(A<8> a)\n"
6906                "{\n"
6907                "  return a;\n"
6908                "}\n",
6909                Style);
6910   verifyFormat("int\n"
6911                "foo(A<B<bool>, 8> a)\n"
6912                "{\n"
6913                "  return a;\n"
6914                "}\n",
6915                Style);
6916   verifyFormat("int\n"
6917                "foo(A<B<8>, bool> a)\n"
6918                "{\n"
6919                "  return a;\n"
6920                "}\n",
6921                Style);
6922   verifyFormat("int\n"
6923                "foo(A<B<bool>, bool> a)\n"
6924                "{\n"
6925                "  return a;\n"
6926                "}\n",
6927                Style);
6928   verifyFormat("int\n"
6929                "foo(A<B<8>, 8> a)\n"
6930                "{\n"
6931                "  return a;\n"
6932                "}\n",
6933                Style);
6934 
6935   Style = getGNUStyle();
6936 
6937   // Test for comments at the end of function declarations.
6938   verifyFormat("void\n"
6939                "foo (int a, /*abc*/ int b) // def\n"
6940                "{\n"
6941                "}\n",
6942                Style);
6943 
6944   verifyFormat("void\n"
6945                "foo (int a, /* abc */ int b) /* def */\n"
6946                "{\n"
6947                "}\n",
6948                Style);
6949 
6950   // Definitions that should not break after return type
6951   verifyFormat("void foo (int a, int b); // def\n", Style);
6952   verifyFormat("void foo (int a, int b); /* def */\n", Style);
6953   verifyFormat("void foo (int a, int b);\n", Style);
6954 }
6955 
6956 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
6957   FormatStyle NoBreak = getLLVMStyle();
6958   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
6959   FormatStyle Break = getLLVMStyle();
6960   Break.AlwaysBreakBeforeMultilineStrings = true;
6961   verifyFormat("aaaa = \"bbbb\"\n"
6962                "       \"cccc\";",
6963                NoBreak);
6964   verifyFormat("aaaa =\n"
6965                "    \"bbbb\"\n"
6966                "    \"cccc\";",
6967                Break);
6968   verifyFormat("aaaa(\"bbbb\"\n"
6969                "     \"cccc\");",
6970                NoBreak);
6971   verifyFormat("aaaa(\n"
6972                "    \"bbbb\"\n"
6973                "    \"cccc\");",
6974                Break);
6975   verifyFormat("aaaa(qqq, \"bbbb\"\n"
6976                "          \"cccc\");",
6977                NoBreak);
6978   verifyFormat("aaaa(qqq,\n"
6979                "     \"bbbb\"\n"
6980                "     \"cccc\");",
6981                Break);
6982   verifyFormat("aaaa(qqq,\n"
6983                "     L\"bbbb\"\n"
6984                "     L\"cccc\");",
6985                Break);
6986   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6987                "                      \"bbbb\"));",
6988                Break);
6989   verifyFormat("string s = someFunction(\n"
6990                "    \"abc\"\n"
6991                "    \"abc\");",
6992                Break);
6993 
6994   // As we break before unary operators, breaking right after them is bad.
6995   verifyFormat("string foo = abc ? \"x\"\n"
6996                "                   \"blah blah blah blah blah blah\"\n"
6997                "                 : \"y\";",
6998                Break);
6999 
7000   // Don't break if there is no column gain.
7001   verifyFormat("f(\"aaaa\"\n"
7002                "  \"bbbb\");",
7003                Break);
7004 
7005   // Treat literals with escaped newlines like multi-line string literals.
7006   EXPECT_EQ("x = \"a\\\n"
7007             "b\\\n"
7008             "c\";",
7009             format("x = \"a\\\n"
7010                    "b\\\n"
7011                    "c\";",
7012                    NoBreak));
7013   EXPECT_EQ("xxxx =\n"
7014             "    \"a\\\n"
7015             "b\\\n"
7016             "c\";",
7017             format("xxxx = \"a\\\n"
7018                    "b\\\n"
7019                    "c\";",
7020                    Break));
7021 
7022   EXPECT_EQ("NSString *const kString =\n"
7023             "    @\"aaaa\"\n"
7024             "    @\"bbbb\";",
7025             format("NSString *const kString = @\"aaaa\"\n"
7026                    "@\"bbbb\";",
7027                    Break));
7028 
7029   Break.ColumnLimit = 0;
7030   verifyFormat("const char *hello = \"hello llvm\";", Break);
7031 }
7032 
7033 TEST_F(FormatTest, AlignsPipes) {
7034   verifyFormat(
7035       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7036       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7037       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7038   verifyFormat(
7039       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
7040       "                     << aaaaaaaaaaaaaaaaaaaa;");
7041   verifyFormat(
7042       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7043       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7044   verifyFormat(
7045       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7046       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7047   verifyFormat(
7048       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
7049       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
7050       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
7051   verifyFormat(
7052       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7053       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7054       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7055   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7056                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7057                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7058                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7059   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
7060                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
7061   verifyFormat(
7062       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7063       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7064   verifyFormat(
7065       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
7066       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
7067 
7068   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
7069                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
7070   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7071                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7072                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
7073                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
7074   verifyFormat("LOG_IF(aaa == //\n"
7075                "       bbb)\n"
7076                "    << a << b;");
7077 
7078   // But sometimes, breaking before the first "<<" is desirable.
7079   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7080                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
7081   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
7082                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7083                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7084   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
7085                "    << BEF << IsTemplate << Description << E->getType();");
7086   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7087                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7088                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7089   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7090                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7091                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7092                "    << aaa;");
7093 
7094   verifyFormat(
7095       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7096       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7097 
7098   // Incomplete string literal.
7099   EXPECT_EQ("llvm::errs() << \"\n"
7100             "             << a;",
7101             format("llvm::errs() << \"\n<<a;"));
7102 
7103   verifyFormat("void f() {\n"
7104                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
7105                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
7106                "}");
7107 
7108   // Handle 'endl'.
7109   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
7110                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7111   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7112 
7113   // Handle '\n'.
7114   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
7115                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7116   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
7117                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
7118   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
7119                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7120   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7121 }
7122 
7123 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7124   verifyFormat("return out << \"somepacket = {\\n\"\n"
7125                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7126                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7127                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7128                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7129                "           << \"}\";");
7130 
7131   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7132                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7133                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7134   verifyFormat(
7135       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7136       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7137       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7138       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7139       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7140   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7141                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7142   verifyFormat(
7143       "void f() {\n"
7144       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7145       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7146       "}");
7147 
7148   // Breaking before the first "<<" is generally not desirable.
7149   verifyFormat(
7150       "llvm::errs()\n"
7151       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7152       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7153       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7154       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7155       getLLVMStyleWithColumns(70));
7156   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7157                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7158                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7159                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7160                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7161                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7162                getLLVMStyleWithColumns(70));
7163 
7164   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7165                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7166                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7167   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7168                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7169                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7170   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7171                "           (aaaa + aaaa);",
7172                getLLVMStyleWithColumns(40));
7173   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7174                "                  (aaaaaaa + aaaaa));",
7175                getLLVMStyleWithColumns(40));
7176   verifyFormat(
7177       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7178       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7179       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7180 }
7181 
7182 TEST_F(FormatTest, UnderstandsEquals) {
7183   verifyFormat(
7184       "aaaaaaaaaaaaaaaaa =\n"
7185       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7186   verifyFormat(
7187       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7188       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7189   verifyFormat(
7190       "if (a) {\n"
7191       "  f();\n"
7192       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7193       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7194       "}");
7195 
7196   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7197                "        100000000 + 10000000) {\n}");
7198 }
7199 
7200 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7201   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7202                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7203 
7204   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7205                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7206 
7207   verifyFormat(
7208       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7209       "                                                          Parameter2);");
7210 
7211   verifyFormat(
7212       "ShortObject->shortFunction(\n"
7213       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7214       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7215 
7216   verifyFormat("loooooooooooooongFunction(\n"
7217                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7218 
7219   verifyFormat(
7220       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7221       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7222 
7223   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7224                "    .WillRepeatedly(Return(SomeValue));");
7225   verifyFormat("void f() {\n"
7226                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7227                "      .Times(2)\n"
7228                "      .WillRepeatedly(Return(SomeValue));\n"
7229                "}");
7230   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7231                "    ccccccccccccccccccccccc);");
7232   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7233                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7234                "          .aaaaa(aaaaa),\n"
7235                "      aaaaaaaaaaaaaaaaaaaaa);");
7236   verifyFormat("void f() {\n"
7237                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7238                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7239                "}");
7240   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7241                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7242                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7243                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7244                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7245   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7246                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7247                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7248                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7249                "}");
7250 
7251   // Here, it is not necessary to wrap at "." or "->".
7252   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7253                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7254   verifyFormat(
7255       "aaaaaaaaaaa->aaaaaaaaa(\n"
7256       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7257       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7258 
7259   verifyFormat(
7260       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7261       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7262   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7263                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7264   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7265                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7266 
7267   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7268                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7269                "    .a();");
7270 
7271   FormatStyle NoBinPacking = getLLVMStyle();
7272   NoBinPacking.BinPackParameters = false;
7273   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7274                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7275                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7276                "                         aaaaaaaaaaaaaaaaaaa,\n"
7277                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7278                NoBinPacking);
7279 
7280   // If there is a subsequent call, change to hanging indentation.
7281   verifyFormat(
7282       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7283       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7284       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7285   verifyFormat(
7286       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7287       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7288   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7289                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7290                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7291   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7292                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7293                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7294 }
7295 
7296 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7297   verifyFormat("template <typename T>\n"
7298                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7299   verifyFormat("template <typename T>\n"
7300                "// T should be one of {A, B}.\n"
7301                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7302   verifyFormat(
7303       "template <typename T>\n"
7304       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7305   verifyFormat("template <typename T>\n"
7306                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7307                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7308   verifyFormat(
7309       "template <typename T>\n"
7310       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7311       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7312   verifyFormat(
7313       "template <typename T>\n"
7314       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7315       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7316       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7317   verifyFormat("template <typename T>\n"
7318                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7319                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7320   verifyFormat(
7321       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7322       "          typename T4 = char>\n"
7323       "void f();");
7324   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7325                "          template <typename> class cccccccccccccccccccccc,\n"
7326                "          typename ddddddddddddd>\n"
7327                "class C {};");
7328   verifyFormat(
7329       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7330       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7331 
7332   verifyFormat("void f() {\n"
7333                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7334                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7335                "}");
7336 
7337   verifyFormat("template <typename T> class C {};");
7338   verifyFormat("template <typename T> void f();");
7339   verifyFormat("template <typename T> void f() {}");
7340   verifyFormat(
7341       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7342       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7343       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7344       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7345       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7346       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7347       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7348       getLLVMStyleWithColumns(72));
7349   EXPECT_EQ("static_cast<A< //\n"
7350             "    B> *>(\n"
7351             "\n"
7352             ");",
7353             format("static_cast<A<//\n"
7354                    "    B>*>(\n"
7355                    "\n"
7356                    "    );"));
7357   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7358                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7359 
7360   FormatStyle AlwaysBreak = getLLVMStyle();
7361   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7362   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7363   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7364   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7365   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7366                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7367                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7368   verifyFormat("template <template <typename> class Fooooooo,\n"
7369                "          template <typename> class Baaaaaaar>\n"
7370                "struct C {};",
7371                AlwaysBreak);
7372   verifyFormat("template <typename T> // T can be A, B or C.\n"
7373                "struct C {};",
7374                AlwaysBreak);
7375   verifyFormat("template <enum E> class A {\n"
7376                "public:\n"
7377                "  E *f();\n"
7378                "};");
7379 
7380   FormatStyle NeverBreak = getLLVMStyle();
7381   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7382   verifyFormat("template <typename T> class C {};", NeverBreak);
7383   verifyFormat("template <typename T> void f();", NeverBreak);
7384   verifyFormat("template <typename T> void f() {}", NeverBreak);
7385   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7386                "bbbbbbbbbbbbbbbbbbbb) {}",
7387                NeverBreak);
7388   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7389                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7390                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7391                NeverBreak);
7392   verifyFormat("template <template <typename> class Fooooooo,\n"
7393                "          template <typename> class Baaaaaaar>\n"
7394                "struct C {};",
7395                NeverBreak);
7396   verifyFormat("template <typename T> // T can be A, B or C.\n"
7397                "struct C {};",
7398                NeverBreak);
7399   verifyFormat("template <enum E> class A {\n"
7400                "public:\n"
7401                "  E *f();\n"
7402                "};",
7403                NeverBreak);
7404   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7405   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7406                "bbbbbbbbbbbbbbbbbbbb) {}",
7407                NeverBreak);
7408 }
7409 
7410 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7411   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7412   Style.ColumnLimit = 60;
7413   EXPECT_EQ("// Baseline - no comments.\n"
7414             "template <\n"
7415             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7416             "void f() {}",
7417             format("// Baseline - no comments.\n"
7418                    "template <\n"
7419                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7420                    "void f() {}",
7421                    Style));
7422 
7423   EXPECT_EQ("template <\n"
7424             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7425             "void f() {}",
7426             format("template <\n"
7427                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7428                    "void f() {}",
7429                    Style));
7430 
7431   EXPECT_EQ(
7432       "template <\n"
7433       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7434       "void f() {}",
7435       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7436              "void f() {}",
7437              Style));
7438 
7439   EXPECT_EQ(
7440       "template <\n"
7441       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7442       "                                               // multiline\n"
7443       "void f() {}",
7444       format("template <\n"
7445              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7446              "                                              // multiline\n"
7447              "void f() {}",
7448              Style));
7449 
7450   EXPECT_EQ(
7451       "template <typename aaaaaaaaaa<\n"
7452       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7453       "void f() {}",
7454       format(
7455           "template <\n"
7456           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7457           "void f() {}",
7458           Style));
7459 }
7460 
7461 TEST_F(FormatTest, WrapsTemplateParameters) {
7462   FormatStyle Style = getLLVMStyle();
7463   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7464   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7465   verifyFormat(
7466       "template <typename... a> struct q {};\n"
7467       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7468       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7469       "    y;",
7470       Style);
7471   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7472   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7473   verifyFormat(
7474       "template <typename... a> struct r {};\n"
7475       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7476       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7477       "    y;",
7478       Style);
7479   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7480   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7481   verifyFormat("template <typename... a> struct s {};\n"
7482                "extern s<\n"
7483                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7484                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7485                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7486                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7487                "    y;",
7488                Style);
7489   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7490   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7491   verifyFormat("template <typename... a> struct t {};\n"
7492                "extern t<\n"
7493                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7494                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7495                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7496                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7497                "    y;",
7498                Style);
7499 }
7500 
7501 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7502   verifyFormat(
7503       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7504       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7505   verifyFormat(
7506       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7507       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7508       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7509 
7510   // FIXME: Should we have the extra indent after the second break?
7511   verifyFormat(
7512       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7513       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7514       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7515 
7516   verifyFormat(
7517       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7518       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7519 
7520   // Breaking at nested name specifiers is generally not desirable.
7521   verifyFormat(
7522       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7523       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7524 
7525   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7526                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7527                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7528                "                   aaaaaaaaaaaaaaaaaaaaa);",
7529                getLLVMStyleWithColumns(74));
7530 
7531   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7532                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7533                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7534 }
7535 
7536 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7537   verifyFormat("A<int> a;");
7538   verifyFormat("A<A<A<int>>> a;");
7539   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7540   verifyFormat("bool x = a < 1 || 2 > a;");
7541   verifyFormat("bool x = 5 < f<int>();");
7542   verifyFormat("bool x = f<int>() > 5;");
7543   verifyFormat("bool x = 5 < a<int>::x;");
7544   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7545   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7546 
7547   verifyGoogleFormat("A<A<int>> a;");
7548   verifyGoogleFormat("A<A<A<int>>> a;");
7549   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7550   verifyGoogleFormat("A<A<int> > a;");
7551   verifyGoogleFormat("A<A<A<int> > > a;");
7552   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7553   verifyGoogleFormat("A<::A<int>> a;");
7554   verifyGoogleFormat("A<::A> a;");
7555   verifyGoogleFormat("A< ::A> a;");
7556   verifyGoogleFormat("A< ::A<int> > a;");
7557   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7558   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7559   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7560   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7561   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7562             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7563 
7564   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7565 
7566   // template closer followed by a token that starts with > or =
7567   verifyFormat("bool b = a<1> > 1;");
7568   verifyFormat("bool b = a<1> >= 1;");
7569   verifyFormat("int i = a<1> >> 1;");
7570   FormatStyle Style = getLLVMStyle();
7571   Style.SpaceBeforeAssignmentOperators = false;
7572   verifyFormat("bool b= a<1> == 1;", Style);
7573   verifyFormat("a<int> = 1;", Style);
7574   verifyFormat("a<int> >>= 1;", Style);
7575 
7576   verifyFormat("test >> a >> b;");
7577   verifyFormat("test << a >> b;");
7578 
7579   verifyFormat("f<int>();");
7580   verifyFormat("template <typename T> void f() {}");
7581   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7582   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7583                "sizeof(char)>::type>;");
7584   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7585   verifyFormat("f(a.operator()<A>());");
7586   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7587                "      .template operator()<A>());",
7588                getLLVMStyleWithColumns(35));
7589 
7590   // Not template parameters.
7591   verifyFormat("return a < b && c > d;");
7592   verifyFormat("void f() {\n"
7593                "  while (a < b && c > d) {\n"
7594                "  }\n"
7595                "}");
7596   verifyFormat("template <typename... Types>\n"
7597                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7598 
7599   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7600                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7601                getLLVMStyleWithColumns(60));
7602   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7603   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7604   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7605   verifyFormat("some_templated_type<decltype([](int i) { return i; })>");
7606 }
7607 
7608 TEST_F(FormatTest, UnderstandsShiftOperators) {
7609   verifyFormat("if (i < x >> 1)");
7610   verifyFormat("while (i < x >> 1)");
7611   verifyFormat("for (unsigned i = 0; i < i; ++i, v = v >> 1)");
7612   verifyFormat("for (unsigned i = 0; i < x >> 1; ++i, v = v >> 1)");
7613   verifyFormat(
7614       "for (std::vector<int>::iterator i = 0; i < x >> 1; ++i, v = v >> 1)");
7615   verifyFormat("Foo.call<Bar<Function>>()");
7616   verifyFormat("if (Foo.call<Bar<Function>>() == 0)");
7617   verifyFormat("for (std::vector<std::pair<int>>::iterator i = 0; i < x >> 1; "
7618                "++i, v = v >> 1)");
7619   verifyFormat("if (w<u<v<x>>, 1>::t)");
7620 }
7621 
7622 TEST_F(FormatTest, BitshiftOperatorWidth) {
7623   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7624             "                   bar */",
7625             format("int    a=1<<2;  /* foo\n"
7626                    "                   bar */"));
7627 
7628   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7629             "                     bar */",
7630             format("int  b  =256>>1 ;  /* foo\n"
7631                    "                      bar */"));
7632 }
7633 
7634 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7635   verifyFormat("COMPARE(a, ==, b);");
7636   verifyFormat("auto s = sizeof...(Ts) - 1;");
7637 }
7638 
7639 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7640   verifyFormat("int A::*x;");
7641   verifyFormat("int (S::*func)(void *);");
7642   verifyFormat("void f() { int (S::*func)(void *); }");
7643   verifyFormat("typedef bool *(Class::*Member)() const;");
7644   verifyFormat("void f() {\n"
7645                "  (a->*f)();\n"
7646                "  a->*x;\n"
7647                "  (a.*f)();\n"
7648                "  ((*a).*f)();\n"
7649                "  a.*x;\n"
7650                "}");
7651   verifyFormat("void f() {\n"
7652                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7653                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7654                "}");
7655   verifyFormat(
7656       "(aaaaaaaaaa->*bbbbbbb)(\n"
7657       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7658   FormatStyle Style = getLLVMStyle();
7659   Style.PointerAlignment = FormatStyle::PAS_Left;
7660   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7661 }
7662 
7663 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7664   verifyFormat("int a = -2;");
7665   verifyFormat("f(-1, -2, -3);");
7666   verifyFormat("a[-1] = 5;");
7667   verifyFormat("int a = 5 + -2;");
7668   verifyFormat("if (i == -1) {\n}");
7669   verifyFormat("if (i != -1) {\n}");
7670   verifyFormat("if (i > -1) {\n}");
7671   verifyFormat("if (i < -1) {\n}");
7672   verifyFormat("++(a->f());");
7673   verifyFormat("--(a->f());");
7674   verifyFormat("(a->f())++;");
7675   verifyFormat("a[42]++;");
7676   verifyFormat("if (!(a->f())) {\n}");
7677   verifyFormat("if (!+i) {\n}");
7678   verifyFormat("~&a;");
7679 
7680   verifyFormat("a-- > b;");
7681   verifyFormat("b ? -a : c;");
7682   verifyFormat("n * sizeof char16;");
7683   verifyFormat("n * alignof char16;", getGoogleStyle());
7684   verifyFormat("sizeof(char);");
7685   verifyFormat("alignof(char);", getGoogleStyle());
7686 
7687   verifyFormat("return -1;");
7688   verifyFormat("throw -1;");
7689   verifyFormat("switch (a) {\n"
7690                "case -1:\n"
7691                "  break;\n"
7692                "}");
7693   verifyFormat("#define X -1");
7694   verifyFormat("#define X -kConstant");
7695 
7696   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7697   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7698 
7699   verifyFormat("int a = /* confusing comment */ -1;");
7700   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7701   verifyFormat("int a = i /* confusing comment */++;");
7702 
7703   verifyFormat("co_yield -1;");
7704   verifyFormat("co_return -1;");
7705 }
7706 
7707 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7708   verifyFormat("if (!aaaaaaaaaa( // break\n"
7709                "        aaaaa)) {\n"
7710                "}");
7711   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7712                "    aaaaa));");
7713   verifyFormat("*aaa = aaaaaaa( // break\n"
7714                "    bbbbbb);");
7715 }
7716 
7717 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7718   verifyFormat("bool operator<();");
7719   verifyFormat("bool operator>();");
7720   verifyFormat("bool operator=();");
7721   verifyFormat("bool operator==();");
7722   verifyFormat("bool operator!=();");
7723   verifyFormat("int operator+();");
7724   verifyFormat("int operator++();");
7725   verifyFormat("int operator++(int) volatile noexcept;");
7726   verifyFormat("bool operator,();");
7727   verifyFormat("bool operator();");
7728   verifyFormat("bool operator()();");
7729   verifyFormat("bool operator[]();");
7730   verifyFormat("operator bool();");
7731   verifyFormat("operator int();");
7732   verifyFormat("operator void *();");
7733   verifyFormat("operator SomeType<int>();");
7734   verifyFormat("operator SomeType<int, int>();");
7735   verifyFormat("operator SomeType<SomeType<int>>();");
7736   verifyFormat("void *operator new(std::size_t size);");
7737   verifyFormat("void *operator new[](std::size_t size);");
7738   verifyFormat("void operator delete(void *ptr);");
7739   verifyFormat("void operator delete[](void *ptr);");
7740   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7741                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7742   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7743                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7744 
7745   verifyFormat(
7746       "ostream &operator<<(ostream &OutputStream,\n"
7747       "                    SomeReallyLongType WithSomeReallyLongValue);");
7748   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7749                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7750                "  return left.group < right.group;\n"
7751                "}");
7752   verifyFormat("SomeType &operator=(const SomeType &S);");
7753   verifyFormat("f.template operator()<int>();");
7754 
7755   verifyGoogleFormat("operator void*();");
7756   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7757   verifyGoogleFormat("operator ::A();");
7758 
7759   verifyFormat("using A::operator+;");
7760   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7761                "int i;");
7762 }
7763 
7764 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7765   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7766   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7767   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7768   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7769   verifyFormat("Deleted &operator=(const Deleted &) &;");
7770   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7771   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7772   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7773   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7774   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7775   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7776   verifyFormat("void Fn(T const &) const &;");
7777   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7778   verifyFormat("template <typename T>\n"
7779                "void F(T) && = delete;",
7780                getGoogleStyle());
7781 
7782   FormatStyle AlignLeft = getLLVMStyle();
7783   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7784   verifyFormat("void A::b() && {}", AlignLeft);
7785   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7786   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7787                AlignLeft);
7788   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7789   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7790   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7791   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7792   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7793   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7794   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7795   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7796 
7797   FormatStyle Spaces = getLLVMStyle();
7798   Spaces.SpacesInCStyleCastParentheses = true;
7799   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7800   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7801   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7802   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7803 
7804   Spaces.SpacesInCStyleCastParentheses = false;
7805   Spaces.SpacesInParentheses = true;
7806   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7807   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7808                Spaces);
7809   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7810   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7811 
7812   FormatStyle BreakTemplate = getLLVMStyle();
7813   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7814 
7815   verifyFormat("struct f {\n"
7816                "  template <class T>\n"
7817                "  int &foo(const std::string &str) &noexcept {}\n"
7818                "};",
7819                BreakTemplate);
7820 
7821   verifyFormat("struct f {\n"
7822                "  template <class T>\n"
7823                "  int &foo(const std::string &str) &&noexcept {}\n"
7824                "};",
7825                BreakTemplate);
7826 
7827   verifyFormat("struct f {\n"
7828                "  template <class T>\n"
7829                "  int &foo(const std::string &str) const &noexcept {}\n"
7830                "};",
7831                BreakTemplate);
7832 
7833   verifyFormat("struct f {\n"
7834                "  template <class T>\n"
7835                "  int &foo(const std::string &str) const &noexcept {}\n"
7836                "};",
7837                BreakTemplate);
7838 
7839   verifyFormat("struct f {\n"
7840                "  template <class T>\n"
7841                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7842                "};",
7843                BreakTemplate);
7844 
7845   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7846   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7847       FormatStyle::BTDS_Yes;
7848   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7849 
7850   verifyFormat("struct f {\n"
7851                "  template <class T>\n"
7852                "  int& foo(const std::string& str) & noexcept {}\n"
7853                "};",
7854                AlignLeftBreakTemplate);
7855 
7856   verifyFormat("struct f {\n"
7857                "  template <class T>\n"
7858                "  int& foo(const std::string& str) && noexcept {}\n"
7859                "};",
7860                AlignLeftBreakTemplate);
7861 
7862   verifyFormat("struct f {\n"
7863                "  template <class T>\n"
7864                "  int& foo(const std::string& str) const& noexcept {}\n"
7865                "};",
7866                AlignLeftBreakTemplate);
7867 
7868   verifyFormat("struct f {\n"
7869                "  template <class T>\n"
7870                "  int& foo(const std::string& str) const&& noexcept {}\n"
7871                "};",
7872                AlignLeftBreakTemplate);
7873 
7874   verifyFormat("struct f {\n"
7875                "  template <class T>\n"
7876                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7877                "};",
7878                AlignLeftBreakTemplate);
7879 
7880   // The `&` in `Type&` should not be confused with a trailing `&` of
7881   // DEPRECATED(reason) member function.
7882   verifyFormat("struct f {\n"
7883                "  template <class T>\n"
7884                "  DEPRECATED(reason)\n"
7885                "  Type &foo(arguments) {}\n"
7886                "};",
7887                BreakTemplate);
7888 
7889   verifyFormat("struct f {\n"
7890                "  template <class T>\n"
7891                "  DEPRECATED(reason)\n"
7892                "  Type& foo(arguments) {}\n"
7893                "};",
7894                AlignLeftBreakTemplate);
7895 
7896   verifyFormat("void (*foopt)(int) = &func;");
7897 }
7898 
7899 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7900   verifyFormat("void f() {\n"
7901                "  A *a = new A;\n"
7902                "  A *a = new (placement) A;\n"
7903                "  delete a;\n"
7904                "  delete (A *)a;\n"
7905                "}");
7906   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7907                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7908   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7909                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7910                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7911   verifyFormat("delete[] h->p;");
7912 }
7913 
7914 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7915   verifyFormat("int *f(int *a) {}");
7916   verifyFormat("int main(int argc, char **argv) {}");
7917   verifyFormat("Test::Test(int b) : a(b * b) {}");
7918   verifyIndependentOfContext("f(a, *a);");
7919   verifyFormat("void g() { f(*a); }");
7920   verifyIndependentOfContext("int a = b * 10;");
7921   verifyIndependentOfContext("int a = 10 * b;");
7922   verifyIndependentOfContext("int a = b * c;");
7923   verifyIndependentOfContext("int a += b * c;");
7924   verifyIndependentOfContext("int a -= b * c;");
7925   verifyIndependentOfContext("int a *= b * c;");
7926   verifyIndependentOfContext("int a /= b * c;");
7927   verifyIndependentOfContext("int a = *b;");
7928   verifyIndependentOfContext("int a = *b * c;");
7929   verifyIndependentOfContext("int a = b * *c;");
7930   verifyIndependentOfContext("int a = b * (10);");
7931   verifyIndependentOfContext("S << b * (10);");
7932   verifyIndependentOfContext("return 10 * b;");
7933   verifyIndependentOfContext("return *b * *c;");
7934   verifyIndependentOfContext("return a & ~b;");
7935   verifyIndependentOfContext("f(b ? *c : *d);");
7936   verifyIndependentOfContext("int a = b ? *c : *d;");
7937   verifyIndependentOfContext("*b = a;");
7938   verifyIndependentOfContext("a * ~b;");
7939   verifyIndependentOfContext("a * !b;");
7940   verifyIndependentOfContext("a * +b;");
7941   verifyIndependentOfContext("a * -b;");
7942   verifyIndependentOfContext("a * ++b;");
7943   verifyIndependentOfContext("a * --b;");
7944   verifyIndependentOfContext("a[4] * b;");
7945   verifyIndependentOfContext("a[a * a] = 1;");
7946   verifyIndependentOfContext("f() * b;");
7947   verifyIndependentOfContext("a * [self dostuff];");
7948   verifyIndependentOfContext("int x = a * (a + b);");
7949   verifyIndependentOfContext("(a *)(a + b);");
7950   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
7951   verifyIndependentOfContext("int *pa = (int *)&a;");
7952   verifyIndependentOfContext("return sizeof(int **);");
7953   verifyIndependentOfContext("return sizeof(int ******);");
7954   verifyIndependentOfContext("return (int **&)a;");
7955   verifyIndependentOfContext("f((*PointerToArray)[10]);");
7956   verifyFormat("void f(Type (*parameter)[10]) {}");
7957   verifyFormat("void f(Type (&parameter)[10]) {}");
7958   verifyGoogleFormat("return sizeof(int**);");
7959   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
7960   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
7961   verifyFormat("auto a = [](int **&, int ***) {};");
7962   verifyFormat("auto PointerBinding = [](const char *S) {};");
7963   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7964   verifyFormat("[](const decltype(*a) &value) {}");
7965   verifyFormat("[](const typeof(*a) &value) {}");
7966   verifyFormat("[](const _Atomic(a *) &value) {}");
7967   verifyFormat("[](const __underlying_type(a) &value) {}");
7968   verifyFormat("decltype(a * b) F();");
7969   verifyFormat("typeof(a * b) F();");
7970   verifyFormat("#define MACRO() [](A *a) { return 1; }");
7971   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7972   verifyIndependentOfContext("typedef void (*f)(int *a);");
7973   verifyIndependentOfContext("int i{a * b};");
7974   verifyIndependentOfContext("aaa && aaa->f();");
7975   verifyIndependentOfContext("int x = ~*p;");
7976   verifyFormat("Constructor() : a(a), area(width * height) {}");
7977   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7978   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
7979   verifyFormat("void f() { f(a, c * d); }");
7980   verifyFormat("void f() { f(new a(), c * d); }");
7981   verifyFormat("void f(const MyOverride &override);");
7982   verifyFormat("void f(const MyFinal &final);");
7983   verifyIndependentOfContext("bool a = f() && override.f();");
7984   verifyIndependentOfContext("bool a = f() && final.f();");
7985 
7986   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
7987 
7988   verifyIndependentOfContext("A<int *> a;");
7989   verifyIndependentOfContext("A<int **> a;");
7990   verifyIndependentOfContext("A<int *, int *> a;");
7991   verifyIndependentOfContext("A<int *[]> a;");
7992   verifyIndependentOfContext(
7993       "const char *const p = reinterpret_cast<const char *const>(q);");
7994   verifyIndependentOfContext("A<int **, int **> a;");
7995   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
7996   verifyFormat("for (char **a = b; *a; ++a) {\n}");
7997   verifyFormat("for (; a && b;) {\n}");
7998   verifyFormat("bool foo = true && [] { return false; }();");
7999 
8000   verifyFormat(
8001       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8002       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8003 
8004   verifyGoogleFormat("int const* a = &b;");
8005   verifyGoogleFormat("**outparam = 1;");
8006   verifyGoogleFormat("*outparam = a * b;");
8007   verifyGoogleFormat("int main(int argc, char** argv) {}");
8008   verifyGoogleFormat("A<int*> a;");
8009   verifyGoogleFormat("A<int**> a;");
8010   verifyGoogleFormat("A<int*, int*> a;");
8011   verifyGoogleFormat("A<int**, int**> a;");
8012   verifyGoogleFormat("f(b ? *c : *d);");
8013   verifyGoogleFormat("int a = b ? *c : *d;");
8014   verifyGoogleFormat("Type* t = **x;");
8015   verifyGoogleFormat("Type* t = *++*x;");
8016   verifyGoogleFormat("*++*x;");
8017   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
8018   verifyGoogleFormat("Type* t = x++ * y;");
8019   verifyGoogleFormat(
8020       "const char* const p = reinterpret_cast<const char* const>(q);");
8021   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
8022   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
8023   verifyGoogleFormat("template <typename T>\n"
8024                      "void f(int i = 0, SomeType** temps = NULL);");
8025 
8026   FormatStyle Left = getLLVMStyle();
8027   Left.PointerAlignment = FormatStyle::PAS_Left;
8028   verifyFormat("x = *a(x) = *a(y);", Left);
8029   verifyFormat("for (;; *a = b) {\n}", Left);
8030   verifyFormat("return *this += 1;", Left);
8031   verifyFormat("throw *x;", Left);
8032   verifyFormat("delete *x;", Left);
8033   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
8034   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
8035   verifyFormat("[](const typeof(*a)* ptr) {}", Left);
8036   verifyFormat("[](const _Atomic(a*)* ptr) {}", Left);
8037   verifyFormat("[](const __underlying_type(a)* ptr) {}", Left);
8038   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
8039   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
8040   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
8041   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
8042 
8043   verifyIndependentOfContext("a = *(x + y);");
8044   verifyIndependentOfContext("a = &(x + y);");
8045   verifyIndependentOfContext("*(x + y).call();");
8046   verifyIndependentOfContext("&(x + y)->call();");
8047   verifyFormat("void f() { &(*I).first; }");
8048 
8049   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
8050   verifyFormat(
8051       "int *MyValues = {\n"
8052       "    *A, // Operator detection might be confused by the '{'\n"
8053       "    *BB // Operator detection might be confused by previous comment\n"
8054       "};");
8055 
8056   verifyIndependentOfContext("if (int *a = &b)");
8057   verifyIndependentOfContext("if (int &a = *b)");
8058   verifyIndependentOfContext("if (a & b[i])");
8059   verifyIndependentOfContext("if constexpr (a & b[i])");
8060   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
8061   verifyIndependentOfContext("if (a * (b * c))");
8062   verifyIndependentOfContext("if constexpr (a * (b * c))");
8063   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
8064   verifyIndependentOfContext("if (a::b::c::d & b[i])");
8065   verifyIndependentOfContext("if (*b[i])");
8066   verifyIndependentOfContext("if (int *a = (&b))");
8067   verifyIndependentOfContext("while (int *a = &b)");
8068   verifyIndependentOfContext("while (a * (b * c))");
8069   verifyIndependentOfContext("size = sizeof *a;");
8070   verifyIndependentOfContext("if (a && (b = c))");
8071   verifyFormat("void f() {\n"
8072                "  for (const int &v : Values) {\n"
8073                "  }\n"
8074                "}");
8075   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
8076   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
8077   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
8078 
8079   verifyFormat("#define A (!a * b)");
8080   verifyFormat("#define MACRO     \\\n"
8081                "  int *i = a * b; \\\n"
8082                "  void f(a *b);",
8083                getLLVMStyleWithColumns(19));
8084 
8085   verifyIndependentOfContext("A = new SomeType *[Length];");
8086   verifyIndependentOfContext("A = new SomeType *[Length]();");
8087   verifyIndependentOfContext("T **t = new T *;");
8088   verifyIndependentOfContext("T **t = new T *();");
8089   verifyGoogleFormat("A = new SomeType*[Length]();");
8090   verifyGoogleFormat("A = new SomeType*[Length];");
8091   verifyGoogleFormat("T** t = new T*;");
8092   verifyGoogleFormat("T** t = new T*();");
8093 
8094   verifyFormat("STATIC_ASSERT((a & b) == 0);");
8095   verifyFormat("STATIC_ASSERT(0 == (a & b));");
8096   verifyFormat("template <bool a, bool b> "
8097                "typename t::if<x && y>::type f() {}");
8098   verifyFormat("template <int *y> f() {}");
8099   verifyFormat("vector<int *> v;");
8100   verifyFormat("vector<int *const> v;");
8101   verifyFormat("vector<int *const **const *> v;");
8102   verifyFormat("vector<int *volatile> v;");
8103   verifyFormat("vector<a *_Nonnull> v;");
8104   verifyFormat("vector<a *_Nullable> v;");
8105   verifyFormat("vector<a *_Null_unspecified> v;");
8106   verifyFormat("vector<a *__ptr32> v;");
8107   verifyFormat("vector<a *__ptr64> v;");
8108   verifyFormat("vector<a *__capability> v;");
8109   FormatStyle TypeMacros = getLLVMStyle();
8110   TypeMacros.TypenameMacros = {"LIST"};
8111   verifyFormat("vector<LIST(uint64_t)> v;", TypeMacros);
8112   verifyFormat("vector<LIST(uint64_t) *> v;", TypeMacros);
8113   verifyFormat("vector<LIST(uint64_t) **> v;", TypeMacros);
8114   verifyFormat("vector<LIST(uint64_t) *attr> v;", TypeMacros);
8115   verifyFormat("vector<A(uint64_t) * attr> v;", TypeMacros); // multiplication
8116 
8117   FormatStyle CustomQualifier = getLLVMStyle();
8118   // Add indentifers that should not be parsed as a qualifier by default.
8119   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8120   CustomQualifier.AttributeMacros.push_back("_My_qualifier");
8121   CustomQualifier.AttributeMacros.push_back("my_other_qualifier");
8122   verifyFormat("vector<a * __my_qualifier> parse_as_multiply;");
8123   verifyFormat("vector<a *__my_qualifier> v;", CustomQualifier);
8124   verifyFormat("vector<a * _My_qualifier> parse_as_multiply;");
8125   verifyFormat("vector<a *_My_qualifier> v;", CustomQualifier);
8126   verifyFormat("vector<a * my_other_qualifier> parse_as_multiply;");
8127   verifyFormat("vector<a *my_other_qualifier> v;", CustomQualifier);
8128   verifyFormat("vector<a * _NotAQualifier> v;");
8129   verifyFormat("vector<a * __not_a_qualifier> v;");
8130   verifyFormat("vector<a * b> v;");
8131   verifyFormat("foo<b && false>();");
8132   verifyFormat("foo<b & 1>();");
8133   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
8134   verifyFormat("typeof(*::std::declval<const T &>()) void F();");
8135   verifyFormat("_Atomic(*::std::declval<const T &>()) void F();");
8136   verifyFormat("__underlying_type(*::std::declval<const T &>()) void F();");
8137   verifyFormat(
8138       "template <class T, class = typename std::enable_if<\n"
8139       "                       std::is_integral<T>::value &&\n"
8140       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
8141       "void F();",
8142       getLLVMStyleWithColumns(70));
8143   verifyFormat("template <class T,\n"
8144                "          class = typename std::enable_if<\n"
8145                "              std::is_integral<T>::value &&\n"
8146                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
8147                "          class U>\n"
8148                "void F();",
8149                getLLVMStyleWithColumns(70));
8150   verifyFormat(
8151       "template <class T,\n"
8152       "          class = typename ::std::enable_if<\n"
8153       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
8154       "void F();",
8155       getGoogleStyleWithColumns(68));
8156 
8157   verifyIndependentOfContext("MACRO(int *i);");
8158   verifyIndependentOfContext("MACRO(auto *a);");
8159   verifyIndependentOfContext("MACRO(const A *a);");
8160   verifyIndependentOfContext("MACRO(_Atomic(A) *a);");
8161   verifyIndependentOfContext("MACRO(decltype(A) *a);");
8162   verifyIndependentOfContext("MACRO(typeof(A) *a);");
8163   verifyIndependentOfContext("MACRO(__underlying_type(A) *a);");
8164   verifyIndependentOfContext("MACRO(A *const a);");
8165   verifyIndependentOfContext("MACRO(A *restrict a);");
8166   verifyIndependentOfContext("MACRO(A *__restrict__ a);");
8167   verifyIndependentOfContext("MACRO(A *__restrict a);");
8168   verifyIndependentOfContext("MACRO(A *volatile a);");
8169   verifyIndependentOfContext("MACRO(A *__volatile a);");
8170   verifyIndependentOfContext("MACRO(A *__volatile__ a);");
8171   verifyIndependentOfContext("MACRO(A *_Nonnull a);");
8172   verifyIndependentOfContext("MACRO(A *_Nullable a);");
8173   verifyIndependentOfContext("MACRO(A *_Null_unspecified a);");
8174   verifyIndependentOfContext("MACRO(A *__attribute__((foo)) a);");
8175   verifyIndependentOfContext("MACRO(A *__attribute((foo)) a);");
8176   verifyIndependentOfContext("MACRO(A *[[clang::attr]] a);");
8177   verifyIndependentOfContext("MACRO(A *[[clang::attr(\"foo\")]] a);");
8178   verifyIndependentOfContext("MACRO(A *__ptr32 a);");
8179   verifyIndependentOfContext("MACRO(A *__ptr64 a);");
8180   verifyIndependentOfContext("MACRO(A *__capability);");
8181   verifyIndependentOfContext("MACRO(A &__capability);");
8182   verifyFormat("MACRO(A *__my_qualifier);");               // type declaration
8183   verifyFormat("void f() { MACRO(A * __my_qualifier); }"); // multiplication
8184   // If we add __my_qualifier to AttributeMacros it should always be parsed as
8185   // a type declaration:
8186   verifyFormat("MACRO(A *__my_qualifier);", CustomQualifier);
8187   verifyFormat("void f() { MACRO(A *__my_qualifier); }", CustomQualifier);
8188   // Also check that TypenameMacros prevents parsing it as multiplication:
8189   verifyIndependentOfContext("MACRO(LIST(uint64_t) * a);"); // multiplication
8190   verifyIndependentOfContext("MACRO(LIST(uint64_t) *a);", TypeMacros); // type
8191 
8192   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
8193   verifyFormat("void f() { f(float{1}, a * a); }");
8194   // FIXME: Is there a way to make this work?
8195   // verifyIndependentOfContext("MACRO(A *a);");
8196   verifyFormat("MACRO(A &B);");
8197   verifyFormat("MACRO(A *B);");
8198   verifyFormat("void f() { MACRO(A * B); }");
8199   verifyFormat("void f() { MACRO(A & B); }");
8200 
8201   verifyFormat("DatumHandle const *operator->() const { return input_; }");
8202   verifyFormat("return options != nullptr && operator==(*options);");
8203 
8204   EXPECT_EQ("#define OP(x)                                    \\\n"
8205             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
8206             "    return s << a.DebugString();                 \\\n"
8207             "  }",
8208             format("#define OP(x) \\\n"
8209                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
8210                    "    return s << a.DebugString(); \\\n"
8211                    "  }",
8212                    getLLVMStyleWithColumns(50)));
8213 
8214   // FIXME: We cannot handle this case yet; we might be able to figure out that
8215   // foo<x> d > v; doesn't make sense.
8216   verifyFormat("foo<a<b && c> d> v;");
8217 
8218   FormatStyle PointerMiddle = getLLVMStyle();
8219   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8220   verifyFormat("delete *x;", PointerMiddle);
8221   verifyFormat("int * x;", PointerMiddle);
8222   verifyFormat("int *[] x;", PointerMiddle);
8223   verifyFormat("template <int * y> f() {}", PointerMiddle);
8224   verifyFormat("int * f(int * a) {}", PointerMiddle);
8225   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8226   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8227   verifyFormat("A<int *> a;", PointerMiddle);
8228   verifyFormat("A<int **> a;", PointerMiddle);
8229   verifyFormat("A<int *, int *> a;", PointerMiddle);
8230   verifyFormat("A<int *[]> a;", PointerMiddle);
8231   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8232   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8233   verifyFormat("T ** t = new T *;", PointerMiddle);
8234 
8235   // Member function reference qualifiers aren't binary operators.
8236   verifyFormat("string // break\n"
8237                "operator()() & {}");
8238   verifyFormat("string // break\n"
8239                "operator()() && {}");
8240   verifyGoogleFormat("template <typename T>\n"
8241                      "auto x() & -> int {}");
8242 }
8243 
8244 TEST_F(FormatTest, UnderstandsAttributes) {
8245   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8246   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8247                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8248   FormatStyle AfterType = getLLVMStyle();
8249   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
8250   verifyFormat("__attribute__((nodebug)) void\n"
8251                "foo() {}\n",
8252                AfterType);
8253   verifyFormat("__unused void\n"
8254                "foo() {}",
8255                AfterType);
8256 
8257   FormatStyle CustomAttrs = getLLVMStyle();
8258   CustomAttrs.AttributeMacros.push_back("__unused");
8259   CustomAttrs.AttributeMacros.push_back("__attr1");
8260   CustomAttrs.AttributeMacros.push_back("__attr2");
8261   CustomAttrs.AttributeMacros.push_back("no_underscore_attr");
8262   verifyFormat("vector<SomeType *__attribute((foo))> v;");
8263   verifyFormat("vector<SomeType *__attribute__((foo))> v;");
8264   verifyFormat("vector<SomeType * __not_attribute__((foo))> v;");
8265   // Check that it is parsed as a multiplication without AttributeMacros and
8266   // as a pointer qualifier when we add __attr1/__attr2 to AttributeMacros.
8267   verifyFormat("vector<SomeType * __attr1> v;");
8268   verifyFormat("vector<SomeType __attr1 *> v;");
8269   verifyFormat("vector<SomeType __attr1 *const> v;");
8270   verifyFormat("vector<SomeType __attr1 * __attr2> v;");
8271   verifyFormat("vector<SomeType *__attr1> v;", CustomAttrs);
8272   verifyFormat("vector<SomeType *__attr2> v;", CustomAttrs);
8273   verifyFormat("vector<SomeType *no_underscore_attr> v;", CustomAttrs);
8274   verifyFormat("vector<SomeType __attr1 *> v;", CustomAttrs);
8275   verifyFormat("vector<SomeType __attr1 *const> v;", CustomAttrs);
8276   verifyFormat("vector<SomeType __attr1 *__attr2> v;", CustomAttrs);
8277   verifyFormat("vector<SomeType __attr1 *no_underscore_attr> v;", CustomAttrs);
8278 
8279   // Check that these are not parsed as function declarations:
8280   CustomAttrs.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8281   CustomAttrs.BreakBeforeBraces = FormatStyle::BS_Allman;
8282   verifyFormat("SomeType s(InitValue);", CustomAttrs);
8283   verifyFormat("SomeType s{InitValue};", CustomAttrs);
8284   verifyFormat("SomeType *__unused s(InitValue);", CustomAttrs);
8285   verifyFormat("SomeType *__unused s{InitValue};", CustomAttrs);
8286   verifyFormat("SomeType s __unused(InitValue);", CustomAttrs);
8287   verifyFormat("SomeType s __unused{InitValue};", CustomAttrs);
8288   verifyFormat("SomeType *__capability s(InitValue);", CustomAttrs);
8289   verifyFormat("SomeType *__capability s{InitValue};", CustomAttrs);
8290 }
8291 
8292 TEST_F(FormatTest, UnderstandsPointerQualifiersInCast) {
8293   // Check that qualifiers on pointers don't break parsing of casts.
8294   verifyFormat("x = (foo *const)*v;");
8295   verifyFormat("x = (foo *volatile)*v;");
8296   verifyFormat("x = (foo *restrict)*v;");
8297   verifyFormat("x = (foo *__attribute__((foo)))*v;");
8298   verifyFormat("x = (foo *_Nonnull)*v;");
8299   verifyFormat("x = (foo *_Nullable)*v;");
8300   verifyFormat("x = (foo *_Null_unspecified)*v;");
8301   verifyFormat("x = (foo *_Nonnull)*v;");
8302   verifyFormat("x = (foo *[[clang::attr]])*v;");
8303   verifyFormat("x = (foo *[[clang::attr(\"foo\")]])*v;");
8304   verifyFormat("x = (foo *__ptr32)*v;");
8305   verifyFormat("x = (foo *__ptr64)*v;");
8306   verifyFormat("x = (foo *__capability)*v;");
8307 
8308   // Check that we handle multiple trailing qualifiers and skip them all to
8309   // determine that the expression is a cast to a pointer type.
8310   FormatStyle LongPointerRight = getLLVMStyleWithColumns(999);
8311   FormatStyle LongPointerLeft = getLLVMStyleWithColumns(999);
8312   LongPointerLeft.PointerAlignment = FormatStyle::PAS_Left;
8313   StringRef AllQualifiers =
8314       "const volatile restrict __attribute__((foo)) _Nonnull _Null_unspecified "
8315       "_Nonnull [[clang::attr]] __ptr32 __ptr64 __capability";
8316   verifyFormat(("x = (foo *" + AllQualifiers + ")*v;").str(), LongPointerRight);
8317   verifyFormat(("x = (foo* " + AllQualifiers + ")*v;").str(), LongPointerLeft);
8318 
8319   // Also check that address-of is not parsed as a binary bitwise-and:
8320   verifyFormat("x = (foo *const)&v;");
8321   verifyFormat(("x = (foo *" + AllQualifiers + ")&v;").str(), LongPointerRight);
8322   verifyFormat(("x = (foo* " + AllQualifiers + ")&v;").str(), LongPointerLeft);
8323 
8324   // Check custom qualifiers:
8325   FormatStyle CustomQualifier = getLLVMStyleWithColumns(999);
8326   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8327   verifyFormat("x = (foo * __my_qualifier) * v;"); // not parsed as qualifier.
8328   verifyFormat("x = (foo *__my_qualifier)*v;", CustomQualifier);
8329   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)*v;").str(),
8330                CustomQualifier);
8331   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)&v;").str(),
8332                CustomQualifier);
8333 
8334   // Check that unknown identifiers result in binary operator parsing:
8335   verifyFormat("x = (foo * __unknown_qualifier) * v;");
8336   verifyFormat("x = (foo * __unknown_qualifier) & v;");
8337 }
8338 
8339 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8340   verifyFormat("SomeType s [[unused]] (InitValue);");
8341   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8342   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8343   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8344   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8345   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8346                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8347   verifyFormat("[[nodiscard]] bool f() { return false; }");
8348   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8349   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8350   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8351 
8352   // Make sure we do not mistake attributes for array subscripts.
8353   verifyFormat("int a() {}\n"
8354                "[[unused]] int b() {}\n");
8355   verifyFormat("NSArray *arr;\n"
8356                "arr[[Foo() bar]];");
8357 
8358   // On the other hand, we still need to correctly find array subscripts.
8359   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8360 
8361   // Make sure that we do not mistake Objective-C method inside array literals
8362   // as attributes, even if those method names are also keywords.
8363   verifyFormat("@[ [foo bar] ];");
8364   verifyFormat("@[ [NSArray class] ];");
8365   verifyFormat("@[ [foo enum] ];");
8366 
8367   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8368 
8369   // Make sure we do not parse attributes as lambda introducers.
8370   FormatStyle MultiLineFunctions = getLLVMStyle();
8371   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8372   verifyFormat("[[unused]] int b() {\n"
8373                "  return 42;\n"
8374                "}\n",
8375                MultiLineFunctions);
8376 }
8377 
8378 TEST_F(FormatTest, AttributeClass) {
8379   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8380   verifyFormat("class S {\n"
8381                "  S(S&&) = default;\n"
8382                "};",
8383                Style);
8384   verifyFormat("class [[nodiscard]] S {\n"
8385                "  S(S&&) = default;\n"
8386                "};",
8387                Style);
8388   verifyFormat("class __attribute((maybeunused)) S {\n"
8389                "  S(S&&) = default;\n"
8390                "};",
8391                Style);
8392   verifyFormat("struct S {\n"
8393                "  S(S&&) = default;\n"
8394                "};",
8395                Style);
8396   verifyFormat("struct [[nodiscard]] S {\n"
8397                "  S(S&&) = default;\n"
8398                "};",
8399                Style);
8400 }
8401 
8402 TEST_F(FormatTest, AttributesAfterMacro) {
8403   FormatStyle Style = getLLVMStyle();
8404   verifyFormat("MACRO;\n"
8405                "__attribute__((maybe_unused)) int foo() {\n"
8406                "  //...\n"
8407                "}");
8408 
8409   verifyFormat("MACRO;\n"
8410                "[[nodiscard]] int foo() {\n"
8411                "  //...\n"
8412                "}");
8413 
8414   EXPECT_EQ("MACRO\n\n"
8415             "__attribute__((maybe_unused)) int foo() {\n"
8416             "  //...\n"
8417             "}",
8418             format("MACRO\n\n"
8419                    "__attribute__((maybe_unused)) int foo() {\n"
8420                    "  //...\n"
8421                    "}"));
8422 
8423   EXPECT_EQ("MACRO\n\n"
8424             "[[nodiscard]] int foo() {\n"
8425             "  //...\n"
8426             "}",
8427             format("MACRO\n\n"
8428                    "[[nodiscard]] int foo() {\n"
8429                    "  //...\n"
8430                    "}"));
8431 }
8432 
8433 TEST_F(FormatTest, AttributePenaltyBreaking) {
8434   FormatStyle Style = getLLVMStyle();
8435   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8436                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8437                Style);
8438   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8439                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8440                Style);
8441   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8442                "shared_ptr<ALongTypeName> &C d) {\n}",
8443                Style);
8444 }
8445 
8446 TEST_F(FormatTest, UnderstandsEllipsis) {
8447   FormatStyle Style = getLLVMStyle();
8448   verifyFormat("int printf(const char *fmt, ...);");
8449   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8450   verifyFormat("template <class... Ts> void Foo(Ts *...ts) {}");
8451 
8452   verifyFormat("template <int *...PP> a;", Style);
8453 
8454   Style.PointerAlignment = FormatStyle::PAS_Left;
8455   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", Style);
8456 
8457   verifyFormat("template <int*... PP> a;", Style);
8458 
8459   Style.PointerAlignment = FormatStyle::PAS_Middle;
8460   verifyFormat("template <int *... PP> a;", Style);
8461 }
8462 
8463 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8464   EXPECT_EQ("int *a;\n"
8465             "int *a;\n"
8466             "int *a;",
8467             format("int *a;\n"
8468                    "int* a;\n"
8469                    "int *a;",
8470                    getGoogleStyle()));
8471   EXPECT_EQ("int* a;\n"
8472             "int* a;\n"
8473             "int* a;",
8474             format("int* a;\n"
8475                    "int* a;\n"
8476                    "int *a;",
8477                    getGoogleStyle()));
8478   EXPECT_EQ("int *a;\n"
8479             "int *a;\n"
8480             "int *a;",
8481             format("int *a;\n"
8482                    "int * a;\n"
8483                    "int *  a;",
8484                    getGoogleStyle()));
8485   EXPECT_EQ("auto x = [] {\n"
8486             "  int *a;\n"
8487             "  int *a;\n"
8488             "  int *a;\n"
8489             "};",
8490             format("auto x=[]{int *a;\n"
8491                    "int * a;\n"
8492                    "int *  a;};",
8493                    getGoogleStyle()));
8494 }
8495 
8496 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8497   verifyFormat("int f(int &&a) {}");
8498   verifyFormat("int f(int a, char &&b) {}");
8499   verifyFormat("void f() { int &&a = b; }");
8500   verifyGoogleFormat("int f(int a, char&& b) {}");
8501   verifyGoogleFormat("void f() { int&& a = b; }");
8502 
8503   verifyIndependentOfContext("A<int &&> a;");
8504   verifyIndependentOfContext("A<int &&, int &&> a;");
8505   verifyGoogleFormat("A<int&&> a;");
8506   verifyGoogleFormat("A<int&&, int&&> a;");
8507 
8508   // Not rvalue references:
8509   verifyFormat("template <bool B, bool C> class A {\n"
8510                "  static_assert(B && C, \"Something is wrong\");\n"
8511                "};");
8512   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8513   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8514   verifyFormat("#define A(a, b) (a && b)");
8515 }
8516 
8517 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8518   verifyFormat("void f() {\n"
8519                "  x[aaaaaaaaa -\n"
8520                "    b] = 23;\n"
8521                "}",
8522                getLLVMStyleWithColumns(15));
8523 }
8524 
8525 TEST_F(FormatTest, FormatsCasts) {
8526   verifyFormat("Type *A = static_cast<Type *>(P);");
8527   verifyFormat("Type *A = (Type *)P;");
8528   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8529   verifyFormat("int a = (int)(2.0f);");
8530   verifyFormat("int a = (int)2.0f;");
8531   verifyFormat("x[(int32)y];");
8532   verifyFormat("x = (int32)y;");
8533   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8534   verifyFormat("int a = (int)*b;");
8535   verifyFormat("int a = (int)2.0f;");
8536   verifyFormat("int a = (int)~0;");
8537   verifyFormat("int a = (int)++a;");
8538   verifyFormat("int a = (int)sizeof(int);");
8539   verifyFormat("int a = (int)+2;");
8540   verifyFormat("my_int a = (my_int)2.0f;");
8541   verifyFormat("my_int a = (my_int)sizeof(int);");
8542   verifyFormat("return (my_int)aaa;");
8543   verifyFormat("#define x ((int)-1)");
8544   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8545   verifyFormat("#define p(q) ((int *)&q)");
8546   verifyFormat("fn(a)(b) + 1;");
8547 
8548   verifyFormat("void f() { my_int a = (my_int)*b; }");
8549   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8550   verifyFormat("my_int a = (my_int)~0;");
8551   verifyFormat("my_int a = (my_int)++a;");
8552   verifyFormat("my_int a = (my_int)-2;");
8553   verifyFormat("my_int a = (my_int)1;");
8554   verifyFormat("my_int a = (my_int *)1;");
8555   verifyFormat("my_int a = (const my_int)-1;");
8556   verifyFormat("my_int a = (const my_int *)-1;");
8557   verifyFormat("my_int a = (my_int)(my_int)-1;");
8558   verifyFormat("my_int a = (ns::my_int)-2;");
8559   verifyFormat("case (my_int)ONE:");
8560   verifyFormat("auto x = (X)this;");
8561   // Casts in Obj-C style calls used to not be recognized as such.
8562   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8563 
8564   // FIXME: single value wrapped with paren will be treated as cast.
8565   verifyFormat("void f(int i = (kValue)*kMask) {}");
8566 
8567   verifyFormat("{ (void)F; }");
8568 
8569   // Don't break after a cast's
8570   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8571                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8572                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8573 
8574   // These are not casts.
8575   verifyFormat("void f(int *) {}");
8576   verifyFormat("f(foo)->b;");
8577   verifyFormat("f(foo).b;");
8578   verifyFormat("f(foo)(b);");
8579   verifyFormat("f(foo)[b];");
8580   verifyFormat("[](foo) { return 4; }(bar);");
8581   verifyFormat("(*funptr)(foo)[4];");
8582   verifyFormat("funptrs[4](foo)[4];");
8583   verifyFormat("void f(int *);");
8584   verifyFormat("void f(int *) = 0;");
8585   verifyFormat("void f(SmallVector<int>) {}");
8586   verifyFormat("void f(SmallVector<int>);");
8587   verifyFormat("void f(SmallVector<int>) = 0;");
8588   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8589   verifyFormat("int a = sizeof(int) * b;");
8590   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8591   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8592   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8593   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8594 
8595   // These are not casts, but at some point were confused with casts.
8596   verifyFormat("virtual void foo(int *) override;");
8597   verifyFormat("virtual void foo(char &) const;");
8598   verifyFormat("virtual void foo(int *a, char *) const;");
8599   verifyFormat("int a = sizeof(int *) + b;");
8600   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8601   verifyFormat("bool b = f(g<int>) && c;");
8602   verifyFormat("typedef void (*f)(int i) func;");
8603   verifyFormat("void operator++(int) noexcept;");
8604   verifyFormat("void operator++(int &) noexcept;");
8605   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8606                "&) noexcept;");
8607   verifyFormat(
8608       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8609   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8610   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8611   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8612   verifyFormat("void operator delete(foo &) noexcept;");
8613   verifyFormat("void operator delete(foo) noexcept;");
8614   verifyFormat("void operator delete(int) noexcept;");
8615   verifyFormat("void operator delete(int &) noexcept;");
8616   verifyFormat("void operator delete(int &) volatile noexcept;");
8617   verifyFormat("void operator delete(int &) const");
8618   verifyFormat("void operator delete(int &) = default");
8619   verifyFormat("void operator delete(int &) = delete");
8620   verifyFormat("void operator delete(int &) [[noreturn]]");
8621   verifyFormat("void operator delete(int &) throw();");
8622   verifyFormat("void operator delete(int &) throw(int);");
8623   verifyFormat("auto operator delete(int &) -> int;");
8624   verifyFormat("auto operator delete(int &) override");
8625   verifyFormat("auto operator delete(int &) final");
8626 
8627   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8628                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8629   // FIXME: The indentation here is not ideal.
8630   verifyFormat(
8631       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8632       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8633       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8634 }
8635 
8636 TEST_F(FormatTest, FormatsFunctionTypes) {
8637   verifyFormat("A<bool()> a;");
8638   verifyFormat("A<SomeType()> a;");
8639   verifyFormat("A<void (*)(int, std::string)> a;");
8640   verifyFormat("A<void *(int)>;");
8641   verifyFormat("void *(*a)(int *, SomeType *);");
8642   verifyFormat("int (*func)(void *);");
8643   verifyFormat("void f() { int (*func)(void *); }");
8644   verifyFormat("template <class CallbackClass>\n"
8645                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8646 
8647   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8648   verifyGoogleFormat("void* (*a)(int);");
8649   verifyGoogleFormat(
8650       "template <class CallbackClass>\n"
8651       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8652 
8653   // Other constructs can look somewhat like function types:
8654   verifyFormat("A<sizeof(*x)> a;");
8655   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8656   verifyFormat("some_var = function(*some_pointer_var)[0];");
8657   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8658   verifyFormat("int x = f(&h)();");
8659   verifyFormat("returnsFunction(&param1, &param2)(param);");
8660   verifyFormat("std::function<\n"
8661                "    LooooooooooongTemplatedType<\n"
8662                "        SomeType>*(\n"
8663                "        LooooooooooooooooongType type)>\n"
8664                "    function;",
8665                getGoogleStyleWithColumns(40));
8666 }
8667 
8668 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8669   verifyFormat("A (*foo_)[6];");
8670   verifyFormat("vector<int> (*foo_)[6];");
8671 }
8672 
8673 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8674   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8675                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8676   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8677                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8678   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8679                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8680 
8681   // Different ways of ()-initializiation.
8682   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8683                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8684   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8685                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8686   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8687                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8688   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8689                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8690 
8691   // Lambdas should not confuse the variable declaration heuristic.
8692   verifyFormat("LooooooooooooooooongType\n"
8693                "    variable(nullptr, [](A *a) {});",
8694                getLLVMStyleWithColumns(40));
8695 }
8696 
8697 TEST_F(FormatTest, BreaksLongDeclarations) {
8698   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8699                "    AnotherNameForTheLongType;");
8700   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8701                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8702   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8703                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8704   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8705                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8706   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8707                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8708   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8709                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8710   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8711                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8712   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8713                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8714   verifyFormat("typeof(LoooooooooooooooooooooooooooooooooooooooooongName)\n"
8715                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8716   verifyFormat("_Atomic(LooooooooooooooooooooooooooooooooooooooooongName)\n"
8717                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8718   verifyFormat("__underlying_type(LooooooooooooooooooooooooooooooongName)\n"
8719                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8720   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8721                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8722   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8723                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8724   FormatStyle Indented = getLLVMStyle();
8725   Indented.IndentWrappedFunctionNames = true;
8726   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8727                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8728                Indented);
8729   verifyFormat(
8730       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8731       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8732       Indented);
8733   verifyFormat(
8734       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8735       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8736       Indented);
8737   verifyFormat(
8738       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8739       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8740       Indented);
8741 
8742   // FIXME: Without the comment, this breaks after "(".
8743   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8744                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8745                getGoogleStyle());
8746 
8747   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8748                "                  int LoooooooooooooooooooongParam2) {}");
8749   verifyFormat(
8750       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8751       "                                   SourceLocation L, IdentifierIn *II,\n"
8752       "                                   Type *T) {}");
8753   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8754                "ReallyReaaallyLongFunctionName(\n"
8755                "    const std::string &SomeParameter,\n"
8756                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8757                "        &ReallyReallyLongParameterName,\n"
8758                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8759                "        &AnotherLongParameterName) {}");
8760   verifyFormat("template <typename A>\n"
8761                "SomeLoooooooooooooooooooooongType<\n"
8762                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8763                "Function() {}");
8764 
8765   verifyGoogleFormat(
8766       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8767       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8768   verifyGoogleFormat(
8769       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8770       "                                   SourceLocation L) {}");
8771   verifyGoogleFormat(
8772       "some_namespace::LongReturnType\n"
8773       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8774       "    int first_long_parameter, int second_parameter) {}");
8775 
8776   verifyGoogleFormat("template <typename T>\n"
8777                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8778                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8779   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8780                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8781 
8782   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8783                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8784                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8785   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8786                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8787                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8788   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8789                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8790                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8791                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8792 
8793   verifyFormat("template <typename T> // Templates on own line.\n"
8794                "static int            // Some comment.\n"
8795                "MyFunction(int a);",
8796                getLLVMStyle());
8797 }
8798 
8799 TEST_F(FormatTest, FormatsArrays) {
8800   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8801                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8802   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8803                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8804   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8805                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8806   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8807                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8808   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8809                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8810   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8811                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8812                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8813   verifyFormat(
8814       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8815       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8816       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8817   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8818                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8819 
8820   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8821                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8822   verifyFormat(
8823       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8824       "                                  .aaaaaaa[0]\n"
8825       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8826   verifyFormat("a[::b::c];");
8827 
8828   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8829 
8830   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8831   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8832 }
8833 
8834 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8835   verifyFormat("(a)->b();");
8836   verifyFormat("--a;");
8837 }
8838 
8839 TEST_F(FormatTest, HandlesIncludeDirectives) {
8840   verifyFormat("#include <string>\n"
8841                "#include <a/b/c.h>\n"
8842                "#include \"a/b/string\"\n"
8843                "#include \"string.h\"\n"
8844                "#include \"string.h\"\n"
8845                "#include <a-a>\n"
8846                "#include < path with space >\n"
8847                "#include_next <test.h>"
8848                "#include \"abc.h\" // this is included for ABC\n"
8849                "#include \"some long include\" // with a comment\n"
8850                "#include \"some very long include path\"\n"
8851                "#include <some/very/long/include/path>\n",
8852                getLLVMStyleWithColumns(35));
8853   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8854   EXPECT_EQ("#include <a>", format("#include<a>"));
8855 
8856   verifyFormat("#import <string>");
8857   verifyFormat("#import <a/b/c.h>");
8858   verifyFormat("#import \"a/b/string\"");
8859   verifyFormat("#import \"string.h\"");
8860   verifyFormat("#import \"string.h\"");
8861   verifyFormat("#if __has_include(<strstream>)\n"
8862                "#include <strstream>\n"
8863                "#endif");
8864 
8865   verifyFormat("#define MY_IMPORT <a/b>");
8866 
8867   verifyFormat("#if __has_include(<a/b>)");
8868   verifyFormat("#if __has_include_next(<a/b>)");
8869   verifyFormat("#define F __has_include(<a/b>)");
8870   verifyFormat("#define F __has_include_next(<a/b>)");
8871 
8872   // Protocol buffer definition or missing "#".
8873   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8874                getLLVMStyleWithColumns(30));
8875 
8876   FormatStyle Style = getLLVMStyle();
8877   Style.AlwaysBreakBeforeMultilineStrings = true;
8878   Style.ColumnLimit = 0;
8879   verifyFormat("#import \"abc.h\"", Style);
8880 
8881   // But 'import' might also be a regular C++ namespace.
8882   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8883                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8884 }
8885 
8886 //===----------------------------------------------------------------------===//
8887 // Error recovery tests.
8888 //===----------------------------------------------------------------------===//
8889 
8890 TEST_F(FormatTest, IncompleteParameterLists) {
8891   FormatStyle NoBinPacking = getLLVMStyle();
8892   NoBinPacking.BinPackParameters = false;
8893   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8894                "                        double *min_x,\n"
8895                "                        double *max_x,\n"
8896                "                        double *min_y,\n"
8897                "                        double *max_y,\n"
8898                "                        double *min_z,\n"
8899                "                        double *max_z, ) {}",
8900                NoBinPacking);
8901 }
8902 
8903 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8904   verifyFormat("void f() { return; }\n42");
8905   verifyFormat("void f() {\n"
8906                "  if (0)\n"
8907                "    return;\n"
8908                "}\n"
8909                "42");
8910   verifyFormat("void f() { return }\n42");
8911   verifyFormat("void f() {\n"
8912                "  if (0)\n"
8913                "    return\n"
8914                "}\n"
8915                "42");
8916 }
8917 
8918 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8919   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8920   EXPECT_EQ("void f() {\n"
8921             "  if (a)\n"
8922             "    return\n"
8923             "}",
8924             format("void  f  (  )  {  if  ( a )  return  }"));
8925   EXPECT_EQ("namespace N {\n"
8926             "void f()\n"
8927             "}",
8928             format("namespace  N  {  void f()  }"));
8929   EXPECT_EQ("namespace N {\n"
8930             "void f() {}\n"
8931             "void g()\n"
8932             "} // namespace N",
8933             format("namespace N  { void f( ) { } void g( ) }"));
8934 }
8935 
8936 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8937   verifyFormat("int aaaaaaaa =\n"
8938                "    // Overlylongcomment\n"
8939                "    b;",
8940                getLLVMStyleWithColumns(20));
8941   verifyFormat("function(\n"
8942                "    ShortArgument,\n"
8943                "    LoooooooooooongArgument);\n",
8944                getLLVMStyleWithColumns(20));
8945 }
8946 
8947 TEST_F(FormatTest, IncorrectAccessSpecifier) {
8948   verifyFormat("public:");
8949   verifyFormat("class A {\n"
8950                "public\n"
8951                "  void f() {}\n"
8952                "};");
8953   verifyFormat("public\n"
8954                "int qwerty;");
8955   verifyFormat("public\n"
8956                "B {}");
8957   verifyFormat("public\n"
8958                "{}");
8959   verifyFormat("public\n"
8960                "B { int x; }");
8961 }
8962 
8963 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
8964   verifyFormat("{");
8965   verifyFormat("#})");
8966   verifyNoCrash("(/**/[:!] ?[).");
8967 }
8968 
8969 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
8970   // Found by oss-fuzz:
8971   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
8972   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8973   Style.ColumnLimit = 60;
8974   verifyNoCrash(
8975       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
8976       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
8977       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
8978       Style);
8979 }
8980 
8981 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
8982   verifyFormat("do {\n}");
8983   verifyFormat("do {\n}\n"
8984                "f();");
8985   verifyFormat("do {\n}\n"
8986                "wheeee(fun);");
8987   verifyFormat("do {\n"
8988                "  f();\n"
8989                "}");
8990 }
8991 
8992 TEST_F(FormatTest, IncorrectCodeMissingParens) {
8993   verifyFormat("if {\n  foo;\n  foo();\n}");
8994   verifyFormat("switch {\n  foo;\n  foo();\n}");
8995   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
8996   verifyFormat("while {\n  foo;\n  foo();\n}");
8997   verifyFormat("do {\n  foo;\n  foo();\n} while;");
8998 }
8999 
9000 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
9001   verifyIncompleteFormat("namespace {\n"
9002                          "class Foo { Foo (\n"
9003                          "};\n"
9004                          "} // namespace");
9005 }
9006 
9007 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
9008   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
9009   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
9010   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
9011   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
9012 
9013   EXPECT_EQ("{\n"
9014             "  {\n"
9015             "    breakme(\n"
9016             "        qwe);\n"
9017             "  }\n",
9018             format("{\n"
9019                    "    {\n"
9020                    " breakme(qwe);\n"
9021                    "}\n",
9022                    getLLVMStyleWithColumns(10)));
9023 }
9024 
9025 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
9026   verifyFormat("int x = {\n"
9027                "    avariable,\n"
9028                "    b(alongervariable)};",
9029                getLLVMStyleWithColumns(25));
9030 }
9031 
9032 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
9033   verifyFormat("return (a)(b){1, 2, 3};");
9034 }
9035 
9036 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
9037   verifyFormat("vector<int> x{1, 2, 3, 4};");
9038   verifyFormat("vector<int> x{\n"
9039                "    1,\n"
9040                "    2,\n"
9041                "    3,\n"
9042                "    4,\n"
9043                "};");
9044   verifyFormat("vector<T> x{{}, {}, {}, {}};");
9045   verifyFormat("f({1, 2});");
9046   verifyFormat("auto v = Foo{-1};");
9047   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
9048   verifyFormat("Class::Class : member{1, 2, 3} {}");
9049   verifyFormat("new vector<int>{1, 2, 3};");
9050   verifyFormat("new int[3]{1, 2, 3};");
9051   verifyFormat("new int{1};");
9052   verifyFormat("return {arg1, arg2};");
9053   verifyFormat("return {arg1, SomeType{parameter}};");
9054   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
9055   verifyFormat("new T{arg1, arg2};");
9056   verifyFormat("f(MyMap[{composite, key}]);");
9057   verifyFormat("class Class {\n"
9058                "  T member = {arg1, arg2};\n"
9059                "};");
9060   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
9061   verifyFormat("const struct A a = {.a = 1, .b = 2};");
9062   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
9063   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
9064   verifyFormat("int a = std::is_integral<int>{} + 0;");
9065 
9066   verifyFormat("int foo(int i) { return fo1{}(i); }");
9067   verifyFormat("int foo(int i) { return fo1{}(i); }");
9068   verifyFormat("auto i = decltype(x){};");
9069   verifyFormat("auto i = typeof(x){};");
9070   verifyFormat("auto i = _Atomic(x){};");
9071   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
9072   verifyFormat("Node n{1, Node{1000}, //\n"
9073                "       2};");
9074   verifyFormat("Aaaa aaaaaaa{\n"
9075                "    {\n"
9076                "        aaaa,\n"
9077                "    },\n"
9078                "};");
9079   verifyFormat("class C : public D {\n"
9080                "  SomeClass SC{2};\n"
9081                "};");
9082   verifyFormat("class C : public A {\n"
9083                "  class D : public B {\n"
9084                "    void f() { int i{2}; }\n"
9085                "  };\n"
9086                "};");
9087   verifyFormat("#define A {a, a},");
9088 
9089   // Avoid breaking between equal sign and opening brace
9090   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
9091   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
9092   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
9093                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
9094                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
9095                "     {\"ccccccccccccccccccccc\", 2}};",
9096                AvoidBreakingFirstArgument);
9097 
9098   // Binpacking only if there is no trailing comma
9099   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
9100                "                      cccccccccc, dddddddddd};",
9101                getLLVMStyleWithColumns(50));
9102   verifyFormat("const Aaaaaa aaaaa = {\n"
9103                "    aaaaaaaaaaa,\n"
9104                "    bbbbbbbbbbb,\n"
9105                "    ccccccccccc,\n"
9106                "    ddddddddddd,\n"
9107                "};",
9108                getLLVMStyleWithColumns(50));
9109 
9110   // Cases where distinguising braced lists and blocks is hard.
9111   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
9112   verifyFormat("void f() {\n"
9113                "  return; // comment\n"
9114                "}\n"
9115                "SomeType t;");
9116   verifyFormat("void f() {\n"
9117                "  if (a) {\n"
9118                "    f();\n"
9119                "  }\n"
9120                "}\n"
9121                "SomeType t;");
9122 
9123   // In combination with BinPackArguments = false.
9124   FormatStyle NoBinPacking = getLLVMStyle();
9125   NoBinPacking.BinPackArguments = false;
9126   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
9127                "                      bbbbb,\n"
9128                "                      ccccc,\n"
9129                "                      ddddd,\n"
9130                "                      eeeee,\n"
9131                "                      ffffff,\n"
9132                "                      ggggg,\n"
9133                "                      hhhhhh,\n"
9134                "                      iiiiii,\n"
9135                "                      jjjjjj,\n"
9136                "                      kkkkkk};",
9137                NoBinPacking);
9138   verifyFormat("const Aaaaaa aaaaa = {\n"
9139                "    aaaaa,\n"
9140                "    bbbbb,\n"
9141                "    ccccc,\n"
9142                "    ddddd,\n"
9143                "    eeeee,\n"
9144                "    ffffff,\n"
9145                "    ggggg,\n"
9146                "    hhhhhh,\n"
9147                "    iiiiii,\n"
9148                "    jjjjjj,\n"
9149                "    kkkkkk,\n"
9150                "};",
9151                NoBinPacking);
9152   verifyFormat(
9153       "const Aaaaaa aaaaa = {\n"
9154       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
9155       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
9156       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
9157       "};",
9158       NoBinPacking);
9159 
9160   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
9161   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
9162             "    CDDDP83848_BMCR_REGISTER,\n"
9163             "    CDDDP83848_BMSR_REGISTER,\n"
9164             "    CDDDP83848_RBR_REGISTER};",
9165             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
9166                    "                                CDDDP83848_BMSR_REGISTER,\n"
9167                    "                                CDDDP83848_RBR_REGISTER};",
9168                    NoBinPacking));
9169 
9170   // FIXME: The alignment of these trailing comments might be bad. Then again,
9171   // this might be utterly useless in real code.
9172   verifyFormat("Constructor::Constructor()\n"
9173                "    : some_value{         //\n"
9174                "                 aaaaaaa, //\n"
9175                "                 bbbbbbb} {}");
9176 
9177   // In braced lists, the first comment is always assumed to belong to the
9178   // first element. Thus, it can be moved to the next or previous line as
9179   // appropriate.
9180   EXPECT_EQ("function({// First element:\n"
9181             "          1,\n"
9182             "          // Second element:\n"
9183             "          2});",
9184             format("function({\n"
9185                    "    // First element:\n"
9186                    "    1,\n"
9187                    "    // Second element:\n"
9188                    "    2});"));
9189   EXPECT_EQ("std::vector<int> MyNumbers{\n"
9190             "    // First element:\n"
9191             "    1,\n"
9192             "    // Second element:\n"
9193             "    2};",
9194             format("std::vector<int> MyNumbers{// First element:\n"
9195                    "                           1,\n"
9196                    "                           // Second element:\n"
9197                    "                           2};",
9198                    getLLVMStyleWithColumns(30)));
9199   // A trailing comma should still lead to an enforced line break and no
9200   // binpacking.
9201   EXPECT_EQ("vector<int> SomeVector = {\n"
9202             "    // aaa\n"
9203             "    1,\n"
9204             "    2,\n"
9205             "};",
9206             format("vector<int> SomeVector = { // aaa\n"
9207                    "    1, 2, };"));
9208 
9209   // C++11 brace initializer list l-braces should not be treated any differently
9210   // when breaking before lambda bodies is enabled
9211   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
9212   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
9213   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
9214   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
9215   verifyFormat(
9216       "std::runtime_error{\n"
9217       "    \"Long string which will force a break onto the next line...\"};",
9218       BreakBeforeLambdaBody);
9219 
9220   FormatStyle ExtraSpaces = getLLVMStyle();
9221   ExtraSpaces.Cpp11BracedListStyle = false;
9222   ExtraSpaces.ColumnLimit = 75;
9223   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
9224   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
9225   verifyFormat("f({ 1, 2 });", ExtraSpaces);
9226   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
9227   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
9228   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
9229   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
9230   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
9231   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
9232   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
9233   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
9234   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
9235   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
9236   verifyFormat("class Class {\n"
9237                "  T member = { arg1, arg2 };\n"
9238                "};",
9239                ExtraSpaces);
9240   verifyFormat(
9241       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9242       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
9243       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
9244       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
9245       ExtraSpaces);
9246   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
9247   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
9248                ExtraSpaces);
9249   verifyFormat(
9250       "someFunction(OtherParam,\n"
9251       "             BracedList{ // comment 1 (Forcing interesting break)\n"
9252       "                         param1, param2,\n"
9253       "                         // comment 2\n"
9254       "                         param3, param4 });",
9255       ExtraSpaces);
9256   verifyFormat(
9257       "std::this_thread::sleep_for(\n"
9258       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
9259       ExtraSpaces);
9260   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
9261                "    aaaaaaa,\n"
9262                "    aaaaaaaaaa,\n"
9263                "    aaaaa,\n"
9264                "    aaaaaaaaaaaaaaa,\n"
9265                "    aaa,\n"
9266                "    aaaaaaaaaa,\n"
9267                "    a,\n"
9268                "    aaaaaaaaaaaaaaaaaaaaa,\n"
9269                "    aaaaaaaaaaaa,\n"
9270                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
9271                "    aaaaaaa,\n"
9272                "    a};");
9273   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
9274   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
9275   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
9276 
9277   // Avoid breaking between initializer/equal sign and opening brace
9278   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
9279   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9280                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9281                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9282                "  { \"ccccccccccccccccccccc\", 2 }\n"
9283                "};",
9284                ExtraSpaces);
9285   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9286                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9287                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9288                "  { \"ccccccccccccccccccccc\", 2 }\n"
9289                "};",
9290                ExtraSpaces);
9291 
9292   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9293   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9294   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9295   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9296 
9297   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9298   SpaceBetweenBraces.SpacesInAngles = true;
9299   SpaceBetweenBraces.SpacesInParentheses = true;
9300   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9301   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9302   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9303   verifyFormat("vector< int > x{ // comment 1\n"
9304                "                 1, 2, 3, 4 };",
9305                SpaceBetweenBraces);
9306   SpaceBetweenBraces.ColumnLimit = 20;
9307   EXPECT_EQ("vector< int > x{\n"
9308             "    1, 2, 3, 4 };",
9309             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9310   SpaceBetweenBraces.ColumnLimit = 24;
9311   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9312             "                 3, 4 };",
9313             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9314   EXPECT_EQ("vector< int > x{\n"
9315             "    1,\n"
9316             "    2,\n"
9317             "    3,\n"
9318             "    4,\n"
9319             "};",
9320             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9321   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9322   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9323   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9324 }
9325 
9326 TEST_F(FormatTest, FormatSpacesInAngles) {
9327   FormatStyle SpaceInAngles = getLLVMStyle();
9328   SpaceInAngles.SpacesInAngles = true;
9329   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9330   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9331   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9332 
9333   SpaceInAngles.SpacesInAngles = false;
9334   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9335   verifyFormat("vector<int> x5;", SpaceInAngles);
9336   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9337   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9338 }
9339 
9340 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9341   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9342                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9343                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9344                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9345                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9346                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9347   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9348                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9349                "                 1, 22, 333, 4444, 55555, //\n"
9350                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9351                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9352   verifyFormat(
9353       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9354       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9355       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9356       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9357       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9358       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9359       "                 7777777};");
9360   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9361                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9362                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9363   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9364                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9365                "    // Separating comment.\n"
9366                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9367   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9368                "    // Leading comment\n"
9369                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9370                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9371   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9372                "                 1, 1, 1, 1};",
9373                getLLVMStyleWithColumns(39));
9374   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9375                "                 1, 1, 1, 1};",
9376                getLLVMStyleWithColumns(38));
9377   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9378                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9379                getLLVMStyleWithColumns(43));
9380   verifyFormat(
9381       "static unsigned SomeValues[10][3] = {\n"
9382       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9383       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9384   verifyFormat("static auto fields = new vector<string>{\n"
9385                "    \"aaaaaaaaaaaaa\",\n"
9386                "    \"aaaaaaaaaaaaa\",\n"
9387                "    \"aaaaaaaaaaaa\",\n"
9388                "    \"aaaaaaaaaaaaaa\",\n"
9389                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9390                "    \"aaaaaaaaaaaa\",\n"
9391                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9392                "};");
9393   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9394   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9395                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9396                "                 3, cccccccccccccccccccccc};",
9397                getLLVMStyleWithColumns(60));
9398 
9399   // Trailing commas.
9400   verifyFormat("vector<int> x = {\n"
9401                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9402                "};",
9403                getLLVMStyleWithColumns(39));
9404   verifyFormat("vector<int> x = {\n"
9405                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9406                "};",
9407                getLLVMStyleWithColumns(39));
9408   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9409                "                 1, 1, 1, 1,\n"
9410                "                 /**/ /**/};",
9411                getLLVMStyleWithColumns(39));
9412 
9413   // Trailing comment in the first line.
9414   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9415                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9416                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9417                "    11111111,   22222222,   333333333,   44444444};");
9418   // Trailing comment in the last line.
9419   verifyFormat("int aaaaa[] = {\n"
9420                "    1, 2, 3, // comment\n"
9421                "    4, 5, 6  // comment\n"
9422                "};");
9423 
9424   // With nested lists, we should either format one item per line or all nested
9425   // lists one on line.
9426   // FIXME: For some nested lists, we can do better.
9427   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9428                "        {aaaaaaaaaaaaaaaaaaa},\n"
9429                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9430                "        {aaaaaaaaaaaaaaaaa}};",
9431                getLLVMStyleWithColumns(60));
9432   verifyFormat(
9433       "SomeStruct my_struct_array = {\n"
9434       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9435       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9436       "    {aaa, aaa},\n"
9437       "    {aaa, aaa},\n"
9438       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9439       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9440       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9441 
9442   // No column layout should be used here.
9443   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9444                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9445 
9446   verifyNoCrash("a<,");
9447 
9448   // No braced initializer here.
9449   verifyFormat("void f() {\n"
9450                "  struct Dummy {};\n"
9451                "  f(v);\n"
9452                "}");
9453 
9454   // Long lists should be formatted in columns even if they are nested.
9455   verifyFormat(
9456       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9457       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9458       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9459       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9460       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9461       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9462 
9463   // Allow "single-column" layout even if that violates the column limit. There
9464   // isn't going to be a better way.
9465   verifyFormat("std::vector<int> a = {\n"
9466                "    aaaaaaaa,\n"
9467                "    aaaaaaaa,\n"
9468                "    aaaaaaaa,\n"
9469                "    aaaaaaaa,\n"
9470                "    aaaaaaaaaa,\n"
9471                "    aaaaaaaa,\n"
9472                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9473                getLLVMStyleWithColumns(30));
9474   verifyFormat("vector<int> aaaa = {\n"
9475                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9476                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9477                "    aaaaaa.aaaaaaa,\n"
9478                "    aaaaaa.aaaaaaa,\n"
9479                "    aaaaaa.aaaaaaa,\n"
9480                "    aaaaaa.aaaaaaa,\n"
9481                "};");
9482 
9483   // Don't create hanging lists.
9484   verifyFormat("someFunction(Param, {List1, List2,\n"
9485                "                     List3});",
9486                getLLVMStyleWithColumns(35));
9487   verifyFormat("someFunction(Param, Param,\n"
9488                "             {List1, List2,\n"
9489                "              List3});",
9490                getLLVMStyleWithColumns(35));
9491   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9492                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9493 }
9494 
9495 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9496   FormatStyle DoNotMerge = getLLVMStyle();
9497   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9498 
9499   verifyFormat("void f() { return 42; }");
9500   verifyFormat("void f() {\n"
9501                "  return 42;\n"
9502                "}",
9503                DoNotMerge);
9504   verifyFormat("void f() {\n"
9505                "  // Comment\n"
9506                "}");
9507   verifyFormat("{\n"
9508                "#error {\n"
9509                "  int a;\n"
9510                "}");
9511   verifyFormat("{\n"
9512                "  int a;\n"
9513                "#error {\n"
9514                "}");
9515   verifyFormat("void f() {} // comment");
9516   verifyFormat("void f() { int a; } // comment");
9517   verifyFormat("void f() {\n"
9518                "} // comment",
9519                DoNotMerge);
9520   verifyFormat("void f() {\n"
9521                "  int a;\n"
9522                "} // comment",
9523                DoNotMerge);
9524   verifyFormat("void f() {\n"
9525                "} // comment",
9526                getLLVMStyleWithColumns(15));
9527 
9528   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9529   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9530 
9531   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9532   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9533   verifyFormat("class C {\n"
9534                "  C()\n"
9535                "      : iiiiiiii(nullptr),\n"
9536                "        kkkkkkk(nullptr),\n"
9537                "        mmmmmmm(nullptr),\n"
9538                "        nnnnnnn(nullptr) {}\n"
9539                "};",
9540                getGoogleStyle());
9541 
9542   FormatStyle NoColumnLimit = getLLVMStyle();
9543   NoColumnLimit.ColumnLimit = 0;
9544   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9545   EXPECT_EQ("class C {\n"
9546             "  A() : b(0) {}\n"
9547             "};",
9548             format("class C{A():b(0){}};", NoColumnLimit));
9549   EXPECT_EQ("A()\n"
9550             "    : b(0) {\n"
9551             "}",
9552             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9553 
9554   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9555   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9556       FormatStyle::SFS_None;
9557   EXPECT_EQ("A()\n"
9558             "    : b(0) {\n"
9559             "}",
9560             format("A():b(0){}", DoNotMergeNoColumnLimit));
9561   EXPECT_EQ("A()\n"
9562             "    : b(0) {\n"
9563             "}",
9564             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9565 
9566   verifyFormat("#define A          \\\n"
9567                "  void f() {       \\\n"
9568                "    int i;         \\\n"
9569                "  }",
9570                getLLVMStyleWithColumns(20));
9571   verifyFormat("#define A           \\\n"
9572                "  void f() { int i; }",
9573                getLLVMStyleWithColumns(21));
9574   verifyFormat("#define A            \\\n"
9575                "  void f() {         \\\n"
9576                "    int i;           \\\n"
9577                "  }                  \\\n"
9578                "  int j;",
9579                getLLVMStyleWithColumns(22));
9580   verifyFormat("#define A             \\\n"
9581                "  void f() { int i; } \\\n"
9582                "  int j;",
9583                getLLVMStyleWithColumns(23));
9584 }
9585 
9586 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9587   FormatStyle MergeEmptyOnly = getLLVMStyle();
9588   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9589   verifyFormat("class C {\n"
9590                "  int f() {}\n"
9591                "};",
9592                MergeEmptyOnly);
9593   verifyFormat("class C {\n"
9594                "  int f() {\n"
9595                "    return 42;\n"
9596                "  }\n"
9597                "};",
9598                MergeEmptyOnly);
9599   verifyFormat("int f() {}", MergeEmptyOnly);
9600   verifyFormat("int f() {\n"
9601                "  return 42;\n"
9602                "}",
9603                MergeEmptyOnly);
9604 
9605   // Also verify behavior when BraceWrapping.AfterFunction = true
9606   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9607   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9608   verifyFormat("int f() {}", MergeEmptyOnly);
9609   verifyFormat("class C {\n"
9610                "  int f() {}\n"
9611                "};",
9612                MergeEmptyOnly);
9613 }
9614 
9615 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9616   FormatStyle MergeInlineOnly = getLLVMStyle();
9617   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9618   verifyFormat("class C {\n"
9619                "  int f() { return 42; }\n"
9620                "};",
9621                MergeInlineOnly);
9622   verifyFormat("int f() {\n"
9623                "  return 42;\n"
9624                "}",
9625                MergeInlineOnly);
9626 
9627   // SFS_Inline implies SFS_Empty
9628   verifyFormat("class C {\n"
9629                "  int f() {}\n"
9630                "};",
9631                MergeInlineOnly);
9632   verifyFormat("int f() {}", MergeInlineOnly);
9633 
9634   // Also verify behavior when BraceWrapping.AfterFunction = true
9635   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9636   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9637   verifyFormat("class C {\n"
9638                "  int f() { return 42; }\n"
9639                "};",
9640                MergeInlineOnly);
9641   verifyFormat("int f()\n"
9642                "{\n"
9643                "  return 42;\n"
9644                "}",
9645                MergeInlineOnly);
9646 
9647   // SFS_Inline implies SFS_Empty
9648   verifyFormat("int f() {}", MergeInlineOnly);
9649   verifyFormat("class C {\n"
9650                "  int f() {}\n"
9651                "};",
9652                MergeInlineOnly);
9653 }
9654 
9655 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9656   FormatStyle MergeInlineOnly = getLLVMStyle();
9657   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9658       FormatStyle::SFS_InlineOnly;
9659   verifyFormat("class C {\n"
9660                "  int f() { return 42; }\n"
9661                "};",
9662                MergeInlineOnly);
9663   verifyFormat("int f() {\n"
9664                "  return 42;\n"
9665                "}",
9666                MergeInlineOnly);
9667 
9668   // SFS_InlineOnly does not imply SFS_Empty
9669   verifyFormat("class C {\n"
9670                "  int f() {}\n"
9671                "};",
9672                MergeInlineOnly);
9673   verifyFormat("int f() {\n"
9674                "}",
9675                MergeInlineOnly);
9676 
9677   // Also verify behavior when BraceWrapping.AfterFunction = true
9678   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9679   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9680   verifyFormat("class C {\n"
9681                "  int f() { return 42; }\n"
9682                "};",
9683                MergeInlineOnly);
9684   verifyFormat("int f()\n"
9685                "{\n"
9686                "  return 42;\n"
9687                "}",
9688                MergeInlineOnly);
9689 
9690   // SFS_InlineOnly does not imply SFS_Empty
9691   verifyFormat("int f()\n"
9692                "{\n"
9693                "}",
9694                MergeInlineOnly);
9695   verifyFormat("class C {\n"
9696                "  int f() {}\n"
9697                "};",
9698                MergeInlineOnly);
9699 }
9700 
9701 TEST_F(FormatTest, SplitEmptyFunction) {
9702   FormatStyle Style = getLLVMStyle();
9703   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9704   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9705   Style.BraceWrapping.AfterFunction = true;
9706   Style.BraceWrapping.SplitEmptyFunction = false;
9707   Style.ColumnLimit = 40;
9708 
9709   verifyFormat("int f()\n"
9710                "{}",
9711                Style);
9712   verifyFormat("int f()\n"
9713                "{\n"
9714                "  return 42;\n"
9715                "}",
9716                Style);
9717   verifyFormat("int f()\n"
9718                "{\n"
9719                "  // some comment\n"
9720                "}",
9721                Style);
9722 
9723   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9724   verifyFormat("int f() {}", Style);
9725   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9726                "{}",
9727                Style);
9728   verifyFormat("int f()\n"
9729                "{\n"
9730                "  return 0;\n"
9731                "}",
9732                Style);
9733 
9734   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9735   verifyFormat("class Foo {\n"
9736                "  int f() {}\n"
9737                "};\n",
9738                Style);
9739   verifyFormat("class Foo {\n"
9740                "  int f() { return 0; }\n"
9741                "};\n",
9742                Style);
9743   verifyFormat("class Foo {\n"
9744                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9745                "  {}\n"
9746                "};\n",
9747                Style);
9748   verifyFormat("class Foo {\n"
9749                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9750                "  {\n"
9751                "    return 0;\n"
9752                "  }\n"
9753                "};\n",
9754                Style);
9755 
9756   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9757   verifyFormat("int f() {}", Style);
9758   verifyFormat("int f() { return 0; }", Style);
9759   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9760                "{}",
9761                Style);
9762   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9763                "{\n"
9764                "  return 0;\n"
9765                "}",
9766                Style);
9767 }
9768 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9769   FormatStyle Style = getLLVMStyle();
9770   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9771   verifyFormat("#ifdef A\n"
9772                "int f() {}\n"
9773                "#else\n"
9774                "int g() {}\n"
9775                "#endif",
9776                Style);
9777 }
9778 
9779 TEST_F(FormatTest, SplitEmptyClass) {
9780   FormatStyle Style = getLLVMStyle();
9781   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9782   Style.BraceWrapping.AfterClass = true;
9783   Style.BraceWrapping.SplitEmptyRecord = false;
9784 
9785   verifyFormat("class Foo\n"
9786                "{};",
9787                Style);
9788   verifyFormat("/* something */ class Foo\n"
9789                "{};",
9790                Style);
9791   verifyFormat("template <typename X> class Foo\n"
9792                "{};",
9793                Style);
9794   verifyFormat("class Foo\n"
9795                "{\n"
9796                "  Foo();\n"
9797                "};",
9798                Style);
9799   verifyFormat("typedef class Foo\n"
9800                "{\n"
9801                "} Foo_t;",
9802                Style);
9803 }
9804 
9805 TEST_F(FormatTest, SplitEmptyStruct) {
9806   FormatStyle Style = getLLVMStyle();
9807   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9808   Style.BraceWrapping.AfterStruct = true;
9809   Style.BraceWrapping.SplitEmptyRecord = false;
9810 
9811   verifyFormat("struct Foo\n"
9812                "{};",
9813                Style);
9814   verifyFormat("/* something */ struct Foo\n"
9815                "{};",
9816                Style);
9817   verifyFormat("template <typename X> struct Foo\n"
9818                "{};",
9819                Style);
9820   verifyFormat("struct Foo\n"
9821                "{\n"
9822                "  Foo();\n"
9823                "};",
9824                Style);
9825   verifyFormat("typedef struct Foo\n"
9826                "{\n"
9827                "} Foo_t;",
9828                Style);
9829   // typedef struct Bar {} Bar_t;
9830 }
9831 
9832 TEST_F(FormatTest, SplitEmptyUnion) {
9833   FormatStyle Style = getLLVMStyle();
9834   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9835   Style.BraceWrapping.AfterUnion = true;
9836   Style.BraceWrapping.SplitEmptyRecord = false;
9837 
9838   verifyFormat("union Foo\n"
9839                "{};",
9840                Style);
9841   verifyFormat("/* something */ union Foo\n"
9842                "{};",
9843                Style);
9844   verifyFormat("union Foo\n"
9845                "{\n"
9846                "  A,\n"
9847                "};",
9848                Style);
9849   verifyFormat("typedef union Foo\n"
9850                "{\n"
9851                "} Foo_t;",
9852                Style);
9853 }
9854 
9855 TEST_F(FormatTest, SplitEmptyNamespace) {
9856   FormatStyle Style = getLLVMStyle();
9857   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9858   Style.BraceWrapping.AfterNamespace = true;
9859   Style.BraceWrapping.SplitEmptyNamespace = false;
9860 
9861   verifyFormat("namespace Foo\n"
9862                "{};",
9863                Style);
9864   verifyFormat("/* something */ namespace Foo\n"
9865                "{};",
9866                Style);
9867   verifyFormat("inline namespace Foo\n"
9868                "{};",
9869                Style);
9870   verifyFormat("/* something */ inline namespace Foo\n"
9871                "{};",
9872                Style);
9873   verifyFormat("export namespace Foo\n"
9874                "{};",
9875                Style);
9876   verifyFormat("namespace Foo\n"
9877                "{\n"
9878                "void Bar();\n"
9879                "};",
9880                Style);
9881 }
9882 
9883 TEST_F(FormatTest, NeverMergeShortRecords) {
9884   FormatStyle Style = getLLVMStyle();
9885 
9886   verifyFormat("class Foo {\n"
9887                "  Foo();\n"
9888                "};",
9889                Style);
9890   verifyFormat("typedef class Foo {\n"
9891                "  Foo();\n"
9892                "} Foo_t;",
9893                Style);
9894   verifyFormat("struct Foo {\n"
9895                "  Foo();\n"
9896                "};",
9897                Style);
9898   verifyFormat("typedef struct Foo {\n"
9899                "  Foo();\n"
9900                "} Foo_t;",
9901                Style);
9902   verifyFormat("union Foo {\n"
9903                "  A,\n"
9904                "};",
9905                Style);
9906   verifyFormat("typedef union Foo {\n"
9907                "  A,\n"
9908                "} Foo_t;",
9909                Style);
9910   verifyFormat("namespace Foo {\n"
9911                "void Bar();\n"
9912                "};",
9913                Style);
9914 
9915   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9916   Style.BraceWrapping.AfterClass = true;
9917   Style.BraceWrapping.AfterStruct = true;
9918   Style.BraceWrapping.AfterUnion = true;
9919   Style.BraceWrapping.AfterNamespace = true;
9920   verifyFormat("class Foo\n"
9921                "{\n"
9922                "  Foo();\n"
9923                "};",
9924                Style);
9925   verifyFormat("typedef class Foo\n"
9926                "{\n"
9927                "  Foo();\n"
9928                "} Foo_t;",
9929                Style);
9930   verifyFormat("struct Foo\n"
9931                "{\n"
9932                "  Foo();\n"
9933                "};",
9934                Style);
9935   verifyFormat("typedef struct Foo\n"
9936                "{\n"
9937                "  Foo();\n"
9938                "} Foo_t;",
9939                Style);
9940   verifyFormat("union Foo\n"
9941                "{\n"
9942                "  A,\n"
9943                "};",
9944                Style);
9945   verifyFormat("typedef union Foo\n"
9946                "{\n"
9947                "  A,\n"
9948                "} Foo_t;",
9949                Style);
9950   verifyFormat("namespace Foo\n"
9951                "{\n"
9952                "void Bar();\n"
9953                "};",
9954                Style);
9955 }
9956 
9957 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
9958   // Elaborate type variable declarations.
9959   verifyFormat("struct foo a = {bar};\nint n;");
9960   verifyFormat("class foo a = {bar};\nint n;");
9961   verifyFormat("union foo a = {bar};\nint n;");
9962 
9963   // Elaborate types inside function definitions.
9964   verifyFormat("struct foo f() {}\nint n;");
9965   verifyFormat("class foo f() {}\nint n;");
9966   verifyFormat("union foo f() {}\nint n;");
9967 
9968   // Templates.
9969   verifyFormat("template <class X> void f() {}\nint n;");
9970   verifyFormat("template <struct X> void f() {}\nint n;");
9971   verifyFormat("template <union X> void f() {}\nint n;");
9972 
9973   // Actual definitions...
9974   verifyFormat("struct {\n} n;");
9975   verifyFormat(
9976       "template <template <class T, class Y>, class Z> class X {\n} n;");
9977   verifyFormat("union Z {\n  int n;\n} x;");
9978   verifyFormat("class MACRO Z {\n} n;");
9979   verifyFormat("class MACRO(X) Z {\n} n;");
9980   verifyFormat("class __attribute__(X) Z {\n} n;");
9981   verifyFormat("class __declspec(X) Z {\n} n;");
9982   verifyFormat("class A##B##C {\n} n;");
9983   verifyFormat("class alignas(16) Z {\n} n;");
9984   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
9985   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
9986 
9987   // Redefinition from nested context:
9988   verifyFormat("class A::B::C {\n} n;");
9989 
9990   // Template definitions.
9991   verifyFormat(
9992       "template <typename F>\n"
9993       "Matcher(const Matcher<F> &Other,\n"
9994       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
9995       "                             !is_same<F, T>::value>::type * = 0)\n"
9996       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
9997 
9998   // FIXME: This is still incorrectly handled at the formatter side.
9999   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
10000   verifyFormat("int i = SomeFunction(a<b, a> b);");
10001 
10002   // FIXME:
10003   // This now gets parsed incorrectly as class definition.
10004   // verifyFormat("class A<int> f() {\n}\nint n;");
10005 
10006   // Elaborate types where incorrectly parsing the structural element would
10007   // break the indent.
10008   verifyFormat("if (true)\n"
10009                "  class X x;\n"
10010                "else\n"
10011                "  f();\n");
10012 
10013   // This is simply incomplete. Formatting is not important, but must not crash.
10014   verifyFormat("class A:");
10015 }
10016 
10017 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
10018   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
10019             format("#error Leave     all         white!!!!! space* alone!\n"));
10020   EXPECT_EQ(
10021       "#warning Leave     all         white!!!!! space* alone!\n",
10022       format("#warning Leave     all         white!!!!! space* alone!\n"));
10023   EXPECT_EQ("#error 1", format("  #  error   1"));
10024   EXPECT_EQ("#warning 1", format("  #  warning 1"));
10025 }
10026 
10027 TEST_F(FormatTest, FormatHashIfExpressions) {
10028   verifyFormat("#if AAAA && BBBB");
10029   verifyFormat("#if (AAAA && BBBB)");
10030   verifyFormat("#elif (AAAA && BBBB)");
10031   // FIXME: Come up with a better indentation for #elif.
10032   verifyFormat(
10033       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
10034       "    defined(BBBBBBBB)\n"
10035       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
10036       "    defined(BBBBBBBB)\n"
10037       "#endif",
10038       getLLVMStyleWithColumns(65));
10039 }
10040 
10041 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
10042   FormatStyle AllowsMergedIf = getGoogleStyle();
10043   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
10044       FormatStyle::SIS_WithoutElse;
10045   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
10046   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
10047   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
10048   EXPECT_EQ("if (true) return 42;",
10049             format("if (true)\nreturn 42;", AllowsMergedIf));
10050   FormatStyle ShortMergedIf = AllowsMergedIf;
10051   ShortMergedIf.ColumnLimit = 25;
10052   verifyFormat("#define A \\\n"
10053                "  if (true) return 42;",
10054                ShortMergedIf);
10055   verifyFormat("#define A \\\n"
10056                "  f();    \\\n"
10057                "  if (true)\n"
10058                "#define B",
10059                ShortMergedIf);
10060   verifyFormat("#define A \\\n"
10061                "  f();    \\\n"
10062                "  if (true)\n"
10063                "g();",
10064                ShortMergedIf);
10065   verifyFormat("{\n"
10066                "#ifdef A\n"
10067                "  // Comment\n"
10068                "  if (true) continue;\n"
10069                "#endif\n"
10070                "  // Comment\n"
10071                "  if (true) continue;\n"
10072                "}",
10073                ShortMergedIf);
10074   ShortMergedIf.ColumnLimit = 33;
10075   verifyFormat("#define A \\\n"
10076                "  if constexpr (true) return 42;",
10077                ShortMergedIf);
10078   verifyFormat("#define A \\\n"
10079                "  if CONSTEXPR (true) return 42;",
10080                ShortMergedIf);
10081   ShortMergedIf.ColumnLimit = 29;
10082   verifyFormat("#define A                   \\\n"
10083                "  if (aaaaaaaaaa) return 1; \\\n"
10084                "  return 2;",
10085                ShortMergedIf);
10086   ShortMergedIf.ColumnLimit = 28;
10087   verifyFormat("#define A         \\\n"
10088                "  if (aaaaaaaaaa) \\\n"
10089                "    return 1;     \\\n"
10090                "  return 2;",
10091                ShortMergedIf);
10092   verifyFormat("#define A                \\\n"
10093                "  if constexpr (aaaaaaa) \\\n"
10094                "    return 1;            \\\n"
10095                "  return 2;",
10096                ShortMergedIf);
10097   verifyFormat("#define A                \\\n"
10098                "  if CONSTEXPR (aaaaaaa) \\\n"
10099                "    return 1;            \\\n"
10100                "  return 2;",
10101                ShortMergedIf);
10102 }
10103 
10104 TEST_F(FormatTest, FormatStarDependingOnContext) {
10105   verifyFormat("void f(int *a);");
10106   verifyFormat("void f() { f(fint * b); }");
10107   verifyFormat("class A {\n  void f(int *a);\n};");
10108   verifyFormat("class A {\n  int *a;\n};");
10109   verifyFormat("namespace a {\n"
10110                "namespace b {\n"
10111                "class A {\n"
10112                "  void f() {}\n"
10113                "  int *a;\n"
10114                "};\n"
10115                "} // namespace b\n"
10116                "} // namespace a");
10117 }
10118 
10119 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
10120   verifyFormat("while");
10121   verifyFormat("operator");
10122 }
10123 
10124 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
10125   // This code would be painfully slow to format if we didn't skip it.
10126   std::string Code("A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" // 20x
10127                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10128                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10129                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10130                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10131                    "A(1, 1)\n"
10132                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
10133                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10134                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10135                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10136                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10137                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10138                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10139                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10140                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10141                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
10142   // Deeply nested part is untouched, rest is formatted.
10143   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
10144             format(std::string("int    i;\n") + Code + "int    j;\n",
10145                    getLLVMStyle(), SC_ExpectIncomplete));
10146 }
10147 
10148 //===----------------------------------------------------------------------===//
10149 // Objective-C tests.
10150 //===----------------------------------------------------------------------===//
10151 
10152 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
10153   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
10154   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
10155             format("-(NSUInteger)indexOfObject:(id)anObject;"));
10156   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
10157   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
10158   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
10159             format("-(NSInteger)Method3:(id)anObject;"));
10160   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
10161             format("-(NSInteger)Method4:(id)anObject;"));
10162   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
10163             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
10164   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
10165             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
10166   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10167             "forAllCells:(BOOL)flag;",
10168             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10169                    "forAllCells:(BOOL)flag;"));
10170 
10171   // Very long objectiveC method declaration.
10172   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
10173                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
10174   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
10175                "                    inRange:(NSRange)range\n"
10176                "                   outRange:(NSRange)out_range\n"
10177                "                  outRange1:(NSRange)out_range1\n"
10178                "                  outRange2:(NSRange)out_range2\n"
10179                "                  outRange3:(NSRange)out_range3\n"
10180                "                  outRange4:(NSRange)out_range4\n"
10181                "                  outRange5:(NSRange)out_range5\n"
10182                "                  outRange6:(NSRange)out_range6\n"
10183                "                  outRange7:(NSRange)out_range7\n"
10184                "                  outRange8:(NSRange)out_range8\n"
10185                "                  outRange9:(NSRange)out_range9;");
10186 
10187   // When the function name has to be wrapped.
10188   FormatStyle Style = getLLVMStyle();
10189   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
10190   // and always indents instead.
10191   Style.IndentWrappedFunctionNames = false;
10192   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10193                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
10194                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
10195                "}",
10196                Style);
10197   Style.IndentWrappedFunctionNames = true;
10198   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10199                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
10200                "               anotherName:(NSString)dddddddddddddd {\n"
10201                "}",
10202                Style);
10203 
10204   verifyFormat("- (int)sum:(vector<int>)numbers;");
10205   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
10206   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
10207   // protocol lists (but not for template classes):
10208   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
10209 
10210   verifyFormat("- (int (*)())foo:(int (*)())f;");
10211   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
10212 
10213   // If there's no return type (very rare in practice!), LLVM and Google style
10214   // agree.
10215   verifyFormat("- foo;");
10216   verifyFormat("- foo:(int)f;");
10217   verifyGoogleFormat("- foo:(int)foo;");
10218 }
10219 
10220 TEST_F(FormatTest, BreaksStringLiterals) {
10221   EXPECT_EQ("\"some text \"\n"
10222             "\"other\";",
10223             format("\"some text other\";", getLLVMStyleWithColumns(12)));
10224   EXPECT_EQ("\"some text \"\n"
10225             "\"other\";",
10226             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
10227   EXPECT_EQ(
10228       "#define A  \\\n"
10229       "  \"some \"  \\\n"
10230       "  \"text \"  \\\n"
10231       "  \"other\";",
10232       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
10233   EXPECT_EQ(
10234       "#define A  \\\n"
10235       "  \"so \"    \\\n"
10236       "  \"text \"  \\\n"
10237       "  \"other\";",
10238       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
10239 
10240   EXPECT_EQ("\"some text\"",
10241             format("\"some text\"", getLLVMStyleWithColumns(1)));
10242   EXPECT_EQ("\"some text\"",
10243             format("\"some text\"", getLLVMStyleWithColumns(11)));
10244   EXPECT_EQ("\"some \"\n"
10245             "\"text\"",
10246             format("\"some text\"", getLLVMStyleWithColumns(10)));
10247   EXPECT_EQ("\"some \"\n"
10248             "\"text\"",
10249             format("\"some text\"", getLLVMStyleWithColumns(7)));
10250   EXPECT_EQ("\"some\"\n"
10251             "\" tex\"\n"
10252             "\"t\"",
10253             format("\"some text\"", getLLVMStyleWithColumns(6)));
10254   EXPECT_EQ("\"some\"\n"
10255             "\" tex\"\n"
10256             "\" and\"",
10257             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
10258   EXPECT_EQ("\"some\"\n"
10259             "\"/tex\"\n"
10260             "\"/and\"",
10261             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
10262 
10263   EXPECT_EQ("variable =\n"
10264             "    \"long string \"\n"
10265             "    \"literal\";",
10266             format("variable = \"long string literal\";",
10267                    getLLVMStyleWithColumns(20)));
10268 
10269   EXPECT_EQ("variable = f(\n"
10270             "    \"long string \"\n"
10271             "    \"literal\",\n"
10272             "    short,\n"
10273             "    loooooooooooooooooooong);",
10274             format("variable = f(\"long string literal\", short, "
10275                    "loooooooooooooooooooong);",
10276                    getLLVMStyleWithColumns(20)));
10277 
10278   EXPECT_EQ(
10279       "f(g(\"long string \"\n"
10280       "    \"literal\"),\n"
10281       "  b);",
10282       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10283   EXPECT_EQ("f(g(\"long string \"\n"
10284             "    \"literal\",\n"
10285             "    a),\n"
10286             "  b);",
10287             format("f(g(\"long string literal\", a), b);",
10288                    getLLVMStyleWithColumns(20)));
10289   EXPECT_EQ(
10290       "f(\"one two\".split(\n"
10291       "    variable));",
10292       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10293   EXPECT_EQ("f(\"one two three four five six \"\n"
10294             "  \"seven\".split(\n"
10295             "      really_looooong_variable));",
10296             format("f(\"one two three four five six seven\"."
10297                    "split(really_looooong_variable));",
10298                    getLLVMStyleWithColumns(33)));
10299 
10300   EXPECT_EQ("f(\"some \"\n"
10301             "  \"text\",\n"
10302             "  other);",
10303             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10304 
10305   // Only break as a last resort.
10306   verifyFormat(
10307       "aaaaaaaaaaaaaaaaaaaa(\n"
10308       "    aaaaaaaaaaaaaaaaaaaa,\n"
10309       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10310 
10311   EXPECT_EQ("\"splitmea\"\n"
10312             "\"trandomp\"\n"
10313             "\"oint\"",
10314             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10315 
10316   EXPECT_EQ("\"split/\"\n"
10317             "\"pathat/\"\n"
10318             "\"slashes\"",
10319             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10320 
10321   EXPECT_EQ("\"split/\"\n"
10322             "\"pathat/\"\n"
10323             "\"slashes\"",
10324             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10325   EXPECT_EQ("\"split at \"\n"
10326             "\"spaces/at/\"\n"
10327             "\"slashes.at.any$\"\n"
10328             "\"non-alphanumeric%\"\n"
10329             "\"1111111111characte\"\n"
10330             "\"rs\"",
10331             format("\"split at "
10332                    "spaces/at/"
10333                    "slashes.at."
10334                    "any$non-"
10335                    "alphanumeric%"
10336                    "1111111111characte"
10337                    "rs\"",
10338                    getLLVMStyleWithColumns(20)));
10339 
10340   // Verify that splitting the strings understands
10341   // Style::AlwaysBreakBeforeMultilineStrings.
10342   EXPECT_EQ("aaaaaaaaaaaa(\n"
10343             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10344             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10345             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10346                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10347                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10348                    getGoogleStyle()));
10349   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10350             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10351             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10352                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10353                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10354                    getGoogleStyle()));
10355   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10356             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10357             format("llvm::outs() << "
10358                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10359                    "aaaaaaaaaaaaaaaaaaa\";"));
10360   EXPECT_EQ("ffff(\n"
10361             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10362             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10363             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10364                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10365                    getGoogleStyle()));
10366 
10367   FormatStyle Style = getLLVMStyleWithColumns(12);
10368   Style.BreakStringLiterals = false;
10369   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10370 
10371   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10372   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10373   EXPECT_EQ("#define A \\\n"
10374             "  \"some \" \\\n"
10375             "  \"text \" \\\n"
10376             "  \"other\";",
10377             format("#define A \"some text other\";", AlignLeft));
10378 }
10379 
10380 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10381   EXPECT_EQ("C a = \"some more \"\n"
10382             "      \"text\";",
10383             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10384 }
10385 
10386 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10387   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10388   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10389   EXPECT_EQ("int i = a(b());",
10390             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10391 }
10392 
10393 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10394   EXPECT_EQ(
10395       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10396       "(\n"
10397       "    \"x\t\");",
10398       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10399              "aaaaaaa("
10400              "\"x\t\");"));
10401 }
10402 
10403 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10404   EXPECT_EQ(
10405       "u8\"utf8 string \"\n"
10406       "u8\"literal\";",
10407       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10408   EXPECT_EQ(
10409       "u\"utf16 string \"\n"
10410       "u\"literal\";",
10411       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10412   EXPECT_EQ(
10413       "U\"utf32 string \"\n"
10414       "U\"literal\";",
10415       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10416   EXPECT_EQ("L\"wide string \"\n"
10417             "L\"literal\";",
10418             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10419   EXPECT_EQ("@\"NSString \"\n"
10420             "@\"literal\";",
10421             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10422   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10423 
10424   // This input makes clang-format try to split the incomplete unicode escape
10425   // sequence, which used to lead to a crasher.
10426   verifyNoCrash(
10427       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10428       getLLVMStyleWithColumns(60));
10429 }
10430 
10431 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10432   FormatStyle Style = getGoogleStyleWithColumns(15);
10433   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10434   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10435   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10436   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10437   EXPECT_EQ("u8R\"x(raw literal)x\";",
10438             format("u8R\"x(raw literal)x\";", Style));
10439 }
10440 
10441 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10442   FormatStyle Style = getLLVMStyleWithColumns(20);
10443   EXPECT_EQ(
10444       "_T(\"aaaaaaaaaaaaaa\")\n"
10445       "_T(\"aaaaaaaaaaaaaa\")\n"
10446       "_T(\"aaaaaaaaaaaa\")",
10447       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10448   EXPECT_EQ("f(x,\n"
10449             "  _T(\"aaaaaaaaaaaa\")\n"
10450             "  _T(\"aaa\"),\n"
10451             "  z);",
10452             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10453 
10454   // FIXME: Handle embedded spaces in one iteration.
10455   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10456   //            "_T(\"aaaaaaaaaaaaa\")\n"
10457   //            "_T(\"aaaaaaaaaaaaa\")\n"
10458   //            "_T(\"a\")",
10459   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10460   //                   getLLVMStyleWithColumns(20)));
10461   EXPECT_EQ(
10462       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10463       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10464   EXPECT_EQ("f(\n"
10465             "#if !TEST\n"
10466             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10467             "#endif\n"
10468             ");",
10469             format("f(\n"
10470                    "#if !TEST\n"
10471                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10472                    "#endif\n"
10473                    ");"));
10474   EXPECT_EQ("f(\n"
10475             "\n"
10476             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10477             format("f(\n"
10478                    "\n"
10479                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10480 }
10481 
10482 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10483   // In a function call with two operands, the second can be broken with no line
10484   // break before it.
10485   EXPECT_EQ(
10486       "func(a, \"long long \"\n"
10487       "        \"long long\");",
10488       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10489   // In a function call with three operands, the second must be broken with a
10490   // line break before it.
10491   EXPECT_EQ("func(a,\n"
10492             "     \"long long long \"\n"
10493             "     \"long\",\n"
10494             "     c);",
10495             format("func(a, \"long long long long\", c);",
10496                    getLLVMStyleWithColumns(24)));
10497   // In a function call with three operands, the third must be broken with a
10498   // line break before it.
10499   EXPECT_EQ("func(a, b,\n"
10500             "     \"long long long \"\n"
10501             "     \"long\");",
10502             format("func(a, b, \"long long long long\");",
10503                    getLLVMStyleWithColumns(24)));
10504   // In a function call with three operands, both the second and the third must
10505   // be broken with a line break before them.
10506   EXPECT_EQ("func(a,\n"
10507             "     \"long long long \"\n"
10508             "     \"long\",\n"
10509             "     \"long long long \"\n"
10510             "     \"long\");",
10511             format("func(a, \"long long long long\", \"long long long long\");",
10512                    getLLVMStyleWithColumns(24)));
10513   // In a chain of << with two operands, the second can be broken with no line
10514   // break before it.
10515   EXPECT_EQ("a << \"line line \"\n"
10516             "     \"line\";",
10517             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10518   // In a chain of << with three operands, the second can be broken with no line
10519   // break before it.
10520   EXPECT_EQ(
10521       "abcde << \"line \"\n"
10522       "         \"line line\"\n"
10523       "      << c;",
10524       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10525   // In a chain of << with three operands, the third must be broken with a line
10526   // break before it.
10527   EXPECT_EQ(
10528       "a << b\n"
10529       "  << \"line line \"\n"
10530       "     \"line\";",
10531       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10532   // In a chain of << with three operands, the second can be broken with no line
10533   // break before it and the third must be broken with a line break before it.
10534   EXPECT_EQ("abcd << \"line line \"\n"
10535             "        \"line\"\n"
10536             "     << \"line line \"\n"
10537             "        \"line\";",
10538             format("abcd << \"line line line\" << \"line line line\";",
10539                    getLLVMStyleWithColumns(20)));
10540   // In a chain of binary operators with two operands, the second can be broken
10541   // with no line break before it.
10542   EXPECT_EQ(
10543       "abcd + \"line line \"\n"
10544       "       \"line line\";",
10545       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10546   // In a chain of binary operators with three operands, the second must be
10547   // broken with a line break before it.
10548   EXPECT_EQ("abcd +\n"
10549             "    \"line line \"\n"
10550             "    \"line line\" +\n"
10551             "    e;",
10552             format("abcd + \"line line line line\" + e;",
10553                    getLLVMStyleWithColumns(20)));
10554   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10555   // the first must be broken with a line break before it.
10556   FormatStyle Style = getLLVMStyleWithColumns(25);
10557   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10558   EXPECT_EQ("someFunction(\n"
10559             "    \"long long long \"\n"
10560             "    \"long\",\n"
10561             "    a);",
10562             format("someFunction(\"long long long long\", a);", Style));
10563 }
10564 
10565 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10566   EXPECT_EQ(
10567       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10568       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10569       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10570       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10571              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10572              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10573 }
10574 
10575 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10576   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10577             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10578   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10579             "multiline raw string literal xxxxxxxxxxxxxx\n"
10580             ")x\",\n"
10581             "              a),\n"
10582             "            b);",
10583             format("fffffffffff(g(R\"x(\n"
10584                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10585                    ")x\", a), b);",
10586                    getGoogleStyleWithColumns(20)));
10587   EXPECT_EQ("fffffffffff(\n"
10588             "    g(R\"x(qqq\n"
10589             "multiline raw string literal xxxxxxxxxxxxxx\n"
10590             ")x\",\n"
10591             "      a),\n"
10592             "    b);",
10593             format("fffffffffff(g(R\"x(qqq\n"
10594                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10595                    ")x\", a), b);",
10596                    getGoogleStyleWithColumns(20)));
10597 
10598   EXPECT_EQ("fffffffffff(R\"x(\n"
10599             "multiline raw string literal xxxxxxxxxxxxxx\n"
10600             ")x\");",
10601             format("fffffffffff(R\"x(\n"
10602                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10603                    ")x\");",
10604                    getGoogleStyleWithColumns(20)));
10605   EXPECT_EQ("fffffffffff(R\"x(\n"
10606             "multiline raw string literal xxxxxxxxxxxxxx\n"
10607             ")x\" + bbbbbb);",
10608             format("fffffffffff(R\"x(\n"
10609                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10610                    ")x\" +   bbbbbb);",
10611                    getGoogleStyleWithColumns(20)));
10612   EXPECT_EQ("fffffffffff(\n"
10613             "    R\"x(\n"
10614             "multiline raw string literal xxxxxxxxxxxxxx\n"
10615             ")x\" +\n"
10616             "    bbbbbb);",
10617             format("fffffffffff(\n"
10618                    " R\"x(\n"
10619                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10620                    ")x\" + bbbbbb);",
10621                    getGoogleStyleWithColumns(20)));
10622   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10623             format("fffffffffff(\n"
10624                    " R\"(single line raw string)\" + bbbbbb);"));
10625 }
10626 
10627 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10628   verifyFormat("string a = \"unterminated;");
10629   EXPECT_EQ("function(\"unterminated,\n"
10630             "         OtherParameter);",
10631             format("function(  \"unterminated,\n"
10632                    "    OtherParameter);"));
10633 }
10634 
10635 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10636   FormatStyle Style = getLLVMStyle();
10637   Style.Standard = FormatStyle::LS_Cpp03;
10638   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10639             format("#define x(_a) printf(\"foo\"_a);", Style));
10640 }
10641 
10642 TEST_F(FormatTest, CppLexVersion) {
10643   FormatStyle Style = getLLVMStyle();
10644   // Formatting of x * y differs if x is a type.
10645   verifyFormat("void foo() { MACRO(a * b); }", Style);
10646   verifyFormat("void foo() { MACRO(int *b); }", Style);
10647 
10648   // LLVM style uses latest lexer.
10649   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10650   Style.Standard = FormatStyle::LS_Cpp17;
10651   // But in c++17, char8_t isn't a keyword.
10652   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10653 }
10654 
10655 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10656 
10657 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10658   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10659             "             \"ddeeefff\");",
10660             format("someFunction(\"aaabbbcccdddeeefff\");",
10661                    getLLVMStyleWithColumns(25)));
10662   EXPECT_EQ("someFunction1234567890(\n"
10663             "    \"aaabbbcccdddeeefff\");",
10664             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10665                    getLLVMStyleWithColumns(26)));
10666   EXPECT_EQ("someFunction1234567890(\n"
10667             "    \"aaabbbcccdddeeeff\"\n"
10668             "    \"f\");",
10669             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10670                    getLLVMStyleWithColumns(25)));
10671   EXPECT_EQ("someFunction1234567890(\n"
10672             "    \"aaabbbcccdddeeeff\"\n"
10673             "    \"f\");",
10674             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10675                    getLLVMStyleWithColumns(24)));
10676   EXPECT_EQ("someFunction(\n"
10677             "    \"aaabbbcc ddde \"\n"
10678             "    \"efff\");",
10679             format("someFunction(\"aaabbbcc ddde efff\");",
10680                    getLLVMStyleWithColumns(25)));
10681   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10682             "             \"ddeeefff\");",
10683             format("someFunction(\"aaabbbccc ddeeefff\");",
10684                    getLLVMStyleWithColumns(25)));
10685   EXPECT_EQ("someFunction1234567890(\n"
10686             "    \"aaabb \"\n"
10687             "    \"cccdddeeefff\");",
10688             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10689                    getLLVMStyleWithColumns(25)));
10690   EXPECT_EQ("#define A          \\\n"
10691             "  string s =       \\\n"
10692             "      \"123456789\"  \\\n"
10693             "      \"0\";         \\\n"
10694             "  int i;",
10695             format("#define A string s = \"1234567890\"; int i;",
10696                    getLLVMStyleWithColumns(20)));
10697   EXPECT_EQ("someFunction(\n"
10698             "    \"aaabbbcc \"\n"
10699             "    \"dddeeefff\");",
10700             format("someFunction(\"aaabbbcc dddeeefff\");",
10701                    getLLVMStyleWithColumns(25)));
10702 }
10703 
10704 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10705   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10706   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10707   EXPECT_EQ("\"test\"\n"
10708             "\"\\n\"",
10709             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10710   EXPECT_EQ("\"tes\\\\\"\n"
10711             "\"n\"",
10712             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10713   EXPECT_EQ("\"\\\\\\\\\"\n"
10714             "\"\\n\"",
10715             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10716   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10717   EXPECT_EQ("\"\\uff01\"\n"
10718             "\"test\"",
10719             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10720   EXPECT_EQ("\"\\Uff01ff02\"",
10721             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10722   EXPECT_EQ("\"\\x000000000001\"\n"
10723             "\"next\"",
10724             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10725   EXPECT_EQ("\"\\x000000000001next\"",
10726             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10727   EXPECT_EQ("\"\\x000000000001\"",
10728             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10729   EXPECT_EQ("\"test\"\n"
10730             "\"\\000000\"\n"
10731             "\"000001\"",
10732             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10733   EXPECT_EQ("\"test\\000\"\n"
10734             "\"00000000\"\n"
10735             "\"1\"",
10736             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10737 }
10738 
10739 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10740   verifyFormat("void f() {\n"
10741                "  return g() {}\n"
10742                "  void h() {}");
10743   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10744                "g();\n"
10745                "}");
10746 }
10747 
10748 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10749   verifyFormat(
10750       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10751 }
10752 
10753 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10754   verifyFormat("class X {\n"
10755                "  void f() {\n"
10756                "  }\n"
10757                "};",
10758                getLLVMStyleWithColumns(12));
10759 }
10760 
10761 TEST_F(FormatTest, ConfigurableIndentWidth) {
10762   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10763   EightIndent.IndentWidth = 8;
10764   EightIndent.ContinuationIndentWidth = 8;
10765   verifyFormat("void f() {\n"
10766                "        someFunction();\n"
10767                "        if (true) {\n"
10768                "                f();\n"
10769                "        }\n"
10770                "}",
10771                EightIndent);
10772   verifyFormat("class X {\n"
10773                "        void f() {\n"
10774                "        }\n"
10775                "};",
10776                EightIndent);
10777   verifyFormat("int x[] = {\n"
10778                "        call(),\n"
10779                "        call()};",
10780                EightIndent);
10781 }
10782 
10783 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10784   verifyFormat("double\n"
10785                "f();",
10786                getLLVMStyleWithColumns(8));
10787 }
10788 
10789 TEST_F(FormatTest, ConfigurableUseOfTab) {
10790   FormatStyle Tab = getLLVMStyleWithColumns(42);
10791   Tab.IndentWidth = 8;
10792   Tab.UseTab = FormatStyle::UT_Always;
10793   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10794 
10795   EXPECT_EQ("if (aaaaaaaa && // q\n"
10796             "    bb)\t\t// w\n"
10797             "\t;",
10798             format("if (aaaaaaaa &&// q\n"
10799                    "bb)// w\n"
10800                    ";",
10801                    Tab));
10802   EXPECT_EQ("if (aaa && bbb) // w\n"
10803             "\t;",
10804             format("if(aaa&&bbb)// w\n"
10805                    ";",
10806                    Tab));
10807 
10808   verifyFormat("class X {\n"
10809                "\tvoid f() {\n"
10810                "\t\tsomeFunction(parameter1,\n"
10811                "\t\t\t     parameter2);\n"
10812                "\t}\n"
10813                "};",
10814                Tab);
10815   verifyFormat("#define A                        \\\n"
10816                "\tvoid f() {               \\\n"
10817                "\t\tsomeFunction(    \\\n"
10818                "\t\t    parameter1,  \\\n"
10819                "\t\t    parameter2); \\\n"
10820                "\t}",
10821                Tab);
10822   verifyFormat("int a;\t      // x\n"
10823                "int bbbbbbbb; // x\n",
10824                Tab);
10825 
10826   Tab.TabWidth = 4;
10827   Tab.IndentWidth = 8;
10828   verifyFormat("class TabWidth4Indent8 {\n"
10829                "\t\tvoid f() {\n"
10830                "\t\t\t\tsomeFunction(parameter1,\n"
10831                "\t\t\t\t\t\t\t parameter2);\n"
10832                "\t\t}\n"
10833                "};",
10834                Tab);
10835 
10836   Tab.TabWidth = 4;
10837   Tab.IndentWidth = 4;
10838   verifyFormat("class TabWidth4Indent4 {\n"
10839                "\tvoid f() {\n"
10840                "\t\tsomeFunction(parameter1,\n"
10841                "\t\t\t\t\t parameter2);\n"
10842                "\t}\n"
10843                "};",
10844                Tab);
10845 
10846   Tab.TabWidth = 8;
10847   Tab.IndentWidth = 4;
10848   verifyFormat("class TabWidth8Indent4 {\n"
10849                "    void f() {\n"
10850                "\tsomeFunction(parameter1,\n"
10851                "\t\t     parameter2);\n"
10852                "    }\n"
10853                "};",
10854                Tab);
10855 
10856   Tab.TabWidth = 8;
10857   Tab.IndentWidth = 8;
10858   EXPECT_EQ("/*\n"
10859             "\t      a\t\tcomment\n"
10860             "\t      in multiple lines\n"
10861             "       */",
10862             format("   /*\t \t \n"
10863                    " \t \t a\t\tcomment\t \t\n"
10864                    " \t \t in multiple lines\t\n"
10865                    " \t  */",
10866                    Tab));
10867 
10868   Tab.UseTab = FormatStyle::UT_ForIndentation;
10869   verifyFormat("{\n"
10870                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10871                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10872                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10873                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10874                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10875                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10876                "};",
10877                Tab);
10878   verifyFormat("enum AA {\n"
10879                "\ta1, // Force multiple lines\n"
10880                "\ta2,\n"
10881                "\ta3\n"
10882                "};",
10883                Tab);
10884   EXPECT_EQ("if (aaaaaaaa && // q\n"
10885             "    bb)         // w\n"
10886             "\t;",
10887             format("if (aaaaaaaa &&// q\n"
10888                    "bb)// w\n"
10889                    ";",
10890                    Tab));
10891   verifyFormat("class X {\n"
10892                "\tvoid f() {\n"
10893                "\t\tsomeFunction(parameter1,\n"
10894                "\t\t             parameter2);\n"
10895                "\t}\n"
10896                "};",
10897                Tab);
10898   verifyFormat("{\n"
10899                "\tQ(\n"
10900                "\t    {\n"
10901                "\t\t    int a;\n"
10902                "\t\t    someFunction(aaaaaaaa,\n"
10903                "\t\t                 bbbbbbb);\n"
10904                "\t    },\n"
10905                "\t    p);\n"
10906                "}",
10907                Tab);
10908   EXPECT_EQ("{\n"
10909             "\t/* aaaa\n"
10910             "\t   bbbb */\n"
10911             "}",
10912             format("{\n"
10913                    "/* aaaa\n"
10914                    "   bbbb */\n"
10915                    "}",
10916                    Tab));
10917   EXPECT_EQ("{\n"
10918             "\t/*\n"
10919             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10920             "\t  bbbbbbbbbbbbb\n"
10921             "\t*/\n"
10922             "}",
10923             format("{\n"
10924                    "/*\n"
10925                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10926                    "*/\n"
10927                    "}",
10928                    Tab));
10929   EXPECT_EQ("{\n"
10930             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10931             "\t// bbbbbbbbbbbbb\n"
10932             "}",
10933             format("{\n"
10934                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10935                    "}",
10936                    Tab));
10937   EXPECT_EQ("{\n"
10938             "\t/*\n"
10939             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10940             "\t  bbbbbbbbbbbbb\n"
10941             "\t*/\n"
10942             "}",
10943             format("{\n"
10944                    "\t/*\n"
10945                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10946                    "\t*/\n"
10947                    "}",
10948                    Tab));
10949   EXPECT_EQ("{\n"
10950             "\t/*\n"
10951             "\n"
10952             "\t*/\n"
10953             "}",
10954             format("{\n"
10955                    "\t/*\n"
10956                    "\n"
10957                    "\t*/\n"
10958                    "}",
10959                    Tab));
10960   EXPECT_EQ("{\n"
10961             "\t/*\n"
10962             " asdf\n"
10963             "\t*/\n"
10964             "}",
10965             format("{\n"
10966                    "\t/*\n"
10967                    " asdf\n"
10968                    "\t*/\n"
10969                    "}",
10970                    Tab));
10971 
10972   Tab.UseTab = FormatStyle::UT_Never;
10973   EXPECT_EQ("/*\n"
10974             "              a\t\tcomment\n"
10975             "              in multiple lines\n"
10976             "       */",
10977             format("   /*\t \t \n"
10978                    " \t \t a\t\tcomment\t \t\n"
10979                    " \t \t in multiple lines\t\n"
10980                    " \t  */",
10981                    Tab));
10982   EXPECT_EQ("/* some\n"
10983             "   comment */",
10984             format(" \t \t /* some\n"
10985                    " \t \t    comment */",
10986                    Tab));
10987   EXPECT_EQ("int a; /* some\n"
10988             "   comment */",
10989             format(" \t \t int a; /* some\n"
10990                    " \t \t    comment */",
10991                    Tab));
10992 
10993   EXPECT_EQ("int a; /* some\n"
10994             "comment */",
10995             format(" \t \t int\ta; /* some\n"
10996                    " \t \t    comment */",
10997                    Tab));
10998   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10999             "    comment */",
11000             format(" \t \t f(\"\t\t\"); /* some\n"
11001                    " \t \t    comment */",
11002                    Tab));
11003   EXPECT_EQ("{\n"
11004             "        /*\n"
11005             "         * Comment\n"
11006             "         */\n"
11007             "        int i;\n"
11008             "}",
11009             format("{\n"
11010                    "\t/*\n"
11011                    "\t * Comment\n"
11012                    "\t */\n"
11013                    "\t int i;\n"
11014                    "}",
11015                    Tab));
11016 
11017   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11018   Tab.TabWidth = 8;
11019   Tab.IndentWidth = 8;
11020   EXPECT_EQ("if (aaaaaaaa && // q\n"
11021             "    bb)         // w\n"
11022             "\t;",
11023             format("if (aaaaaaaa &&// q\n"
11024                    "bb)// w\n"
11025                    ";",
11026                    Tab));
11027   EXPECT_EQ("if (aaa && bbb) // w\n"
11028             "\t;",
11029             format("if(aaa&&bbb)// w\n"
11030                    ";",
11031                    Tab));
11032   verifyFormat("class X {\n"
11033                "\tvoid f() {\n"
11034                "\t\tsomeFunction(parameter1,\n"
11035                "\t\t\t     parameter2);\n"
11036                "\t}\n"
11037                "};",
11038                Tab);
11039   verifyFormat("#define A                        \\\n"
11040                "\tvoid f() {               \\\n"
11041                "\t\tsomeFunction(    \\\n"
11042                "\t\t    parameter1,  \\\n"
11043                "\t\t    parameter2); \\\n"
11044                "\t}",
11045                Tab);
11046   Tab.TabWidth = 4;
11047   Tab.IndentWidth = 8;
11048   verifyFormat("class TabWidth4Indent8 {\n"
11049                "\t\tvoid f() {\n"
11050                "\t\t\t\tsomeFunction(parameter1,\n"
11051                "\t\t\t\t\t\t\t parameter2);\n"
11052                "\t\t}\n"
11053                "};",
11054                Tab);
11055   Tab.TabWidth = 4;
11056   Tab.IndentWidth = 4;
11057   verifyFormat("class TabWidth4Indent4 {\n"
11058                "\tvoid f() {\n"
11059                "\t\tsomeFunction(parameter1,\n"
11060                "\t\t\t\t\t parameter2);\n"
11061                "\t}\n"
11062                "};",
11063                Tab);
11064   Tab.TabWidth = 8;
11065   Tab.IndentWidth = 4;
11066   verifyFormat("class TabWidth8Indent4 {\n"
11067                "    void f() {\n"
11068                "\tsomeFunction(parameter1,\n"
11069                "\t\t     parameter2);\n"
11070                "    }\n"
11071                "};",
11072                Tab);
11073   Tab.TabWidth = 8;
11074   Tab.IndentWidth = 8;
11075   EXPECT_EQ("/*\n"
11076             "\t      a\t\tcomment\n"
11077             "\t      in multiple lines\n"
11078             "       */",
11079             format("   /*\t \t \n"
11080                    " \t \t a\t\tcomment\t \t\n"
11081                    " \t \t in multiple lines\t\n"
11082                    " \t  */",
11083                    Tab));
11084   verifyFormat("{\n"
11085                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11086                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11087                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11088                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11089                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11090                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11091                "};",
11092                Tab);
11093   verifyFormat("enum AA {\n"
11094                "\ta1, // Force multiple lines\n"
11095                "\ta2,\n"
11096                "\ta3\n"
11097                "};",
11098                Tab);
11099   EXPECT_EQ("if (aaaaaaaa && // q\n"
11100             "    bb)         // w\n"
11101             "\t;",
11102             format("if (aaaaaaaa &&// q\n"
11103                    "bb)// w\n"
11104                    ";",
11105                    Tab));
11106   verifyFormat("class X {\n"
11107                "\tvoid f() {\n"
11108                "\t\tsomeFunction(parameter1,\n"
11109                "\t\t\t     parameter2);\n"
11110                "\t}\n"
11111                "};",
11112                Tab);
11113   verifyFormat("{\n"
11114                "\tQ(\n"
11115                "\t    {\n"
11116                "\t\t    int a;\n"
11117                "\t\t    someFunction(aaaaaaaa,\n"
11118                "\t\t\t\t bbbbbbb);\n"
11119                "\t    },\n"
11120                "\t    p);\n"
11121                "}",
11122                Tab);
11123   EXPECT_EQ("{\n"
11124             "\t/* aaaa\n"
11125             "\t   bbbb */\n"
11126             "}",
11127             format("{\n"
11128                    "/* aaaa\n"
11129                    "   bbbb */\n"
11130                    "}",
11131                    Tab));
11132   EXPECT_EQ("{\n"
11133             "\t/*\n"
11134             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11135             "\t  bbbbbbbbbbbbb\n"
11136             "\t*/\n"
11137             "}",
11138             format("{\n"
11139                    "/*\n"
11140                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11141                    "*/\n"
11142                    "}",
11143                    Tab));
11144   EXPECT_EQ("{\n"
11145             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11146             "\t// bbbbbbbbbbbbb\n"
11147             "}",
11148             format("{\n"
11149                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11150                    "}",
11151                    Tab));
11152   EXPECT_EQ("{\n"
11153             "\t/*\n"
11154             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11155             "\t  bbbbbbbbbbbbb\n"
11156             "\t*/\n"
11157             "}",
11158             format("{\n"
11159                    "\t/*\n"
11160                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11161                    "\t*/\n"
11162                    "}",
11163                    Tab));
11164   EXPECT_EQ("{\n"
11165             "\t/*\n"
11166             "\n"
11167             "\t*/\n"
11168             "}",
11169             format("{\n"
11170                    "\t/*\n"
11171                    "\n"
11172                    "\t*/\n"
11173                    "}",
11174                    Tab));
11175   EXPECT_EQ("{\n"
11176             "\t/*\n"
11177             " asdf\n"
11178             "\t*/\n"
11179             "}",
11180             format("{\n"
11181                    "\t/*\n"
11182                    " asdf\n"
11183                    "\t*/\n"
11184                    "}",
11185                    Tab));
11186   EXPECT_EQ("/* some\n"
11187             "   comment */",
11188             format(" \t \t /* some\n"
11189                    " \t \t    comment */",
11190                    Tab));
11191   EXPECT_EQ("int a; /* some\n"
11192             "   comment */",
11193             format(" \t \t int a; /* some\n"
11194                    " \t \t    comment */",
11195                    Tab));
11196   EXPECT_EQ("int a; /* some\n"
11197             "comment */",
11198             format(" \t \t int\ta; /* some\n"
11199                    " \t \t    comment */",
11200                    Tab));
11201   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11202             "    comment */",
11203             format(" \t \t f(\"\t\t\"); /* some\n"
11204                    " \t \t    comment */",
11205                    Tab));
11206   EXPECT_EQ("{\n"
11207             "\t/*\n"
11208             "\t * Comment\n"
11209             "\t */\n"
11210             "\tint i;\n"
11211             "}",
11212             format("{\n"
11213                    "\t/*\n"
11214                    "\t * Comment\n"
11215                    "\t */\n"
11216                    "\t int i;\n"
11217                    "}",
11218                    Tab));
11219   Tab.TabWidth = 2;
11220   Tab.IndentWidth = 2;
11221   EXPECT_EQ("{\n"
11222             "\t/* aaaa\n"
11223             "\t\t bbbb */\n"
11224             "}",
11225             format("{\n"
11226                    "/* aaaa\n"
11227                    "\t bbbb */\n"
11228                    "}",
11229                    Tab));
11230   EXPECT_EQ("{\n"
11231             "\t/*\n"
11232             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11233             "\t\tbbbbbbbbbbbbb\n"
11234             "\t*/\n"
11235             "}",
11236             format("{\n"
11237                    "/*\n"
11238                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11239                    "*/\n"
11240                    "}",
11241                    Tab));
11242   Tab.AlignConsecutiveAssignments = true;
11243   Tab.AlignConsecutiveDeclarations = true;
11244   Tab.TabWidth = 4;
11245   Tab.IndentWidth = 4;
11246   verifyFormat("class Assign {\n"
11247                "\tvoid f() {\n"
11248                "\t\tint         x      = 123;\n"
11249                "\t\tint         random = 4;\n"
11250                "\t\tstd::string alphabet =\n"
11251                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11252                "\t}\n"
11253                "};",
11254                Tab);
11255 
11256   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11257   Tab.TabWidth = 8;
11258   Tab.IndentWidth = 8;
11259   EXPECT_EQ("if (aaaaaaaa && // q\n"
11260             "    bb)         // w\n"
11261             "\t;",
11262             format("if (aaaaaaaa &&// q\n"
11263                    "bb)// w\n"
11264                    ";",
11265                    Tab));
11266   EXPECT_EQ("if (aaa && bbb) // w\n"
11267             "\t;",
11268             format("if(aaa&&bbb)// w\n"
11269                    ";",
11270                    Tab));
11271   verifyFormat("class X {\n"
11272                "\tvoid f() {\n"
11273                "\t\tsomeFunction(parameter1,\n"
11274                "\t\t             parameter2);\n"
11275                "\t}\n"
11276                "};",
11277                Tab);
11278   verifyFormat("#define A                        \\\n"
11279                "\tvoid f() {               \\\n"
11280                "\t\tsomeFunction(    \\\n"
11281                "\t\t    parameter1,  \\\n"
11282                "\t\t    parameter2); \\\n"
11283                "\t}",
11284                Tab);
11285   Tab.TabWidth = 4;
11286   Tab.IndentWidth = 8;
11287   verifyFormat("class TabWidth4Indent8 {\n"
11288                "\t\tvoid f() {\n"
11289                "\t\t\t\tsomeFunction(parameter1,\n"
11290                "\t\t\t\t             parameter2);\n"
11291                "\t\t}\n"
11292                "};",
11293                Tab);
11294   Tab.TabWidth = 4;
11295   Tab.IndentWidth = 4;
11296   verifyFormat("class TabWidth4Indent4 {\n"
11297                "\tvoid f() {\n"
11298                "\t\tsomeFunction(parameter1,\n"
11299                "\t\t             parameter2);\n"
11300                "\t}\n"
11301                "};",
11302                Tab);
11303   Tab.TabWidth = 8;
11304   Tab.IndentWidth = 4;
11305   verifyFormat("class TabWidth8Indent4 {\n"
11306                "    void f() {\n"
11307                "\tsomeFunction(parameter1,\n"
11308                "\t             parameter2);\n"
11309                "    }\n"
11310                "};",
11311                Tab);
11312   Tab.TabWidth = 8;
11313   Tab.IndentWidth = 8;
11314   EXPECT_EQ("/*\n"
11315             "              a\t\tcomment\n"
11316             "              in multiple lines\n"
11317             "       */",
11318             format("   /*\t \t \n"
11319                    " \t \t a\t\tcomment\t \t\n"
11320                    " \t \t in multiple lines\t\n"
11321                    " \t  */",
11322                    Tab));
11323   verifyFormat("{\n"
11324                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11325                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11326                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11327                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11328                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11329                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11330                "};",
11331                Tab);
11332   verifyFormat("enum AA {\n"
11333                "\ta1, // Force multiple lines\n"
11334                "\ta2,\n"
11335                "\ta3\n"
11336                "};",
11337                Tab);
11338   EXPECT_EQ("if (aaaaaaaa && // q\n"
11339             "    bb)         // w\n"
11340             "\t;",
11341             format("if (aaaaaaaa &&// q\n"
11342                    "bb)// w\n"
11343                    ";",
11344                    Tab));
11345   verifyFormat("class X {\n"
11346                "\tvoid f() {\n"
11347                "\t\tsomeFunction(parameter1,\n"
11348                "\t\t             parameter2);\n"
11349                "\t}\n"
11350                "};",
11351                Tab);
11352   verifyFormat("{\n"
11353                "\tQ(\n"
11354                "\t    {\n"
11355                "\t\t    int a;\n"
11356                "\t\t    someFunction(aaaaaaaa,\n"
11357                "\t\t                 bbbbbbb);\n"
11358                "\t    },\n"
11359                "\t    p);\n"
11360                "}",
11361                Tab);
11362   EXPECT_EQ("{\n"
11363             "\t/* aaaa\n"
11364             "\t   bbbb */\n"
11365             "}",
11366             format("{\n"
11367                    "/* aaaa\n"
11368                    "   bbbb */\n"
11369                    "}",
11370                    Tab));
11371   EXPECT_EQ("{\n"
11372             "\t/*\n"
11373             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11374             "\t  bbbbbbbbbbbbb\n"
11375             "\t*/\n"
11376             "}",
11377             format("{\n"
11378                    "/*\n"
11379                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11380                    "*/\n"
11381                    "}",
11382                    Tab));
11383   EXPECT_EQ("{\n"
11384             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11385             "\t// bbbbbbbbbbbbb\n"
11386             "}",
11387             format("{\n"
11388                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11389                    "}",
11390                    Tab));
11391   EXPECT_EQ("{\n"
11392             "\t/*\n"
11393             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11394             "\t  bbbbbbbbbbbbb\n"
11395             "\t*/\n"
11396             "}",
11397             format("{\n"
11398                    "\t/*\n"
11399                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11400                    "\t*/\n"
11401                    "}",
11402                    Tab));
11403   EXPECT_EQ("{\n"
11404             "\t/*\n"
11405             "\n"
11406             "\t*/\n"
11407             "}",
11408             format("{\n"
11409                    "\t/*\n"
11410                    "\n"
11411                    "\t*/\n"
11412                    "}",
11413                    Tab));
11414   EXPECT_EQ("{\n"
11415             "\t/*\n"
11416             " asdf\n"
11417             "\t*/\n"
11418             "}",
11419             format("{\n"
11420                    "\t/*\n"
11421                    " asdf\n"
11422                    "\t*/\n"
11423                    "}",
11424                    Tab));
11425   EXPECT_EQ("/* some\n"
11426             "   comment */",
11427             format(" \t \t /* some\n"
11428                    " \t \t    comment */",
11429                    Tab));
11430   EXPECT_EQ("int a; /* some\n"
11431             "   comment */",
11432             format(" \t \t int a; /* some\n"
11433                    " \t \t    comment */",
11434                    Tab));
11435   EXPECT_EQ("int a; /* some\n"
11436             "comment */",
11437             format(" \t \t int\ta; /* some\n"
11438                    " \t \t    comment */",
11439                    Tab));
11440   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11441             "    comment */",
11442             format(" \t \t f(\"\t\t\"); /* some\n"
11443                    " \t \t    comment */",
11444                    Tab));
11445   EXPECT_EQ("{\n"
11446             "\t/*\n"
11447             "\t * Comment\n"
11448             "\t */\n"
11449             "\tint i;\n"
11450             "}",
11451             format("{\n"
11452                    "\t/*\n"
11453                    "\t * Comment\n"
11454                    "\t */\n"
11455                    "\t int i;\n"
11456                    "}",
11457                    Tab));
11458   Tab.TabWidth = 2;
11459   Tab.IndentWidth = 2;
11460   EXPECT_EQ("{\n"
11461             "\t/* aaaa\n"
11462             "\t   bbbb */\n"
11463             "}",
11464             format("{\n"
11465                    "/* aaaa\n"
11466                    "   bbbb */\n"
11467                    "}",
11468                    Tab));
11469   EXPECT_EQ("{\n"
11470             "\t/*\n"
11471             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11472             "\t  bbbbbbbbbbbbb\n"
11473             "\t*/\n"
11474             "}",
11475             format("{\n"
11476                    "/*\n"
11477                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11478                    "*/\n"
11479                    "}",
11480                    Tab));
11481   Tab.AlignConsecutiveAssignments = true;
11482   Tab.AlignConsecutiveDeclarations = true;
11483   Tab.TabWidth = 4;
11484   Tab.IndentWidth = 4;
11485   verifyFormat("class Assign {\n"
11486                "\tvoid f() {\n"
11487                "\t\tint         x      = 123;\n"
11488                "\t\tint         random = 4;\n"
11489                "\t\tstd::string alphabet =\n"
11490                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11491                "\t}\n"
11492                "};",
11493                Tab);
11494   Tab.AlignOperands = FormatStyle::OAS_Align;
11495   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb +\n"
11496                "                 cccccccccccccccccccc;",
11497                Tab);
11498   // no alignment
11499   verifyFormat("int aaaaaaaaaa =\n"
11500                "\tbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
11501                Tab);
11502   verifyFormat("return aaaaaaaaaaaaaaaa ? 111111111111111\n"
11503                "       : bbbbbbbbbbbbbb ? 222222222222222\n"
11504                "                        : 333333333333333;",
11505                Tab);
11506   Tab.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
11507   Tab.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
11508   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"
11509                "               + cccccccccccccccccccc;",
11510                Tab);
11511 }
11512 
11513 TEST_F(FormatTest, ZeroTabWidth) {
11514   FormatStyle Tab = getLLVMStyleWithColumns(42);
11515   Tab.IndentWidth = 8;
11516   Tab.UseTab = FormatStyle::UT_Never;
11517   Tab.TabWidth = 0;
11518   EXPECT_EQ("void a(){\n"
11519             "    // line starts with '\t'\n"
11520             "};",
11521             format("void a(){\n"
11522                    "\t// line starts with '\t'\n"
11523                    "};",
11524                    Tab));
11525 
11526   EXPECT_EQ("void a(){\n"
11527             "    // line starts with '\t'\n"
11528             "};",
11529             format("void a(){\n"
11530                    "\t\t// line starts with '\t'\n"
11531                    "};",
11532                    Tab));
11533 
11534   Tab.UseTab = FormatStyle::UT_ForIndentation;
11535   EXPECT_EQ("void a(){\n"
11536             "    // line starts with '\t'\n"
11537             "};",
11538             format("void a(){\n"
11539                    "\t// line starts with '\t'\n"
11540                    "};",
11541                    Tab));
11542 
11543   EXPECT_EQ("void a(){\n"
11544             "    // line starts with '\t'\n"
11545             "};",
11546             format("void a(){\n"
11547                    "\t\t// line starts with '\t'\n"
11548                    "};",
11549                    Tab));
11550 
11551   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11552   EXPECT_EQ("void a(){\n"
11553             "    // line starts with '\t'\n"
11554             "};",
11555             format("void a(){\n"
11556                    "\t// line starts with '\t'\n"
11557                    "};",
11558                    Tab));
11559 
11560   EXPECT_EQ("void a(){\n"
11561             "    // line starts with '\t'\n"
11562             "};",
11563             format("void a(){\n"
11564                    "\t\t// line starts with '\t'\n"
11565                    "};",
11566                    Tab));
11567 
11568   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11569   EXPECT_EQ("void a(){\n"
11570             "    // line starts with '\t'\n"
11571             "};",
11572             format("void a(){\n"
11573                    "\t// line starts with '\t'\n"
11574                    "};",
11575                    Tab));
11576 
11577   EXPECT_EQ("void a(){\n"
11578             "    // line starts with '\t'\n"
11579             "};",
11580             format("void a(){\n"
11581                    "\t\t// line starts with '\t'\n"
11582                    "};",
11583                    Tab));
11584 
11585   Tab.UseTab = FormatStyle::UT_Always;
11586   EXPECT_EQ("void a(){\n"
11587             "// line starts with '\t'\n"
11588             "};",
11589             format("void a(){\n"
11590                    "\t// line starts with '\t'\n"
11591                    "};",
11592                    Tab));
11593 
11594   EXPECT_EQ("void a(){\n"
11595             "// line starts with '\t'\n"
11596             "};",
11597             format("void a(){\n"
11598                    "\t\t// line starts with '\t'\n"
11599                    "};",
11600                    Tab));
11601 }
11602 
11603 TEST_F(FormatTest, CalculatesOriginalColumn) {
11604   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11605             "q\"; /* some\n"
11606             "       comment */",
11607             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11608                    "q\"; /* some\n"
11609                    "       comment */",
11610                    getLLVMStyle()));
11611   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11612             "/* some\n"
11613             "   comment */",
11614             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11615                    " /* some\n"
11616                    "    comment */",
11617                    getLLVMStyle()));
11618   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11619             "qqq\n"
11620             "/* some\n"
11621             "   comment */",
11622             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11623                    "qqq\n"
11624                    " /* some\n"
11625                    "    comment */",
11626                    getLLVMStyle()));
11627   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11628             "wwww; /* some\n"
11629             "         comment */",
11630             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11631                    "wwww; /* some\n"
11632                    "         comment */",
11633                    getLLVMStyle()));
11634 }
11635 
11636 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11637   FormatStyle NoSpace = getLLVMStyle();
11638   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11639 
11640   verifyFormat("while(true)\n"
11641                "  continue;",
11642                NoSpace);
11643   verifyFormat("for(;;)\n"
11644                "  continue;",
11645                NoSpace);
11646   verifyFormat("if(true)\n"
11647                "  f();\n"
11648                "else if(true)\n"
11649                "  f();",
11650                NoSpace);
11651   verifyFormat("do {\n"
11652                "  do_something();\n"
11653                "} while(something());",
11654                NoSpace);
11655   verifyFormat("switch(x) {\n"
11656                "default:\n"
11657                "  break;\n"
11658                "}",
11659                NoSpace);
11660   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11661   verifyFormat("size_t x = sizeof(x);", NoSpace);
11662   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11663   verifyFormat("auto f(int x) -> typeof(x);", NoSpace);
11664   verifyFormat("auto f(int x) -> _Atomic(x);", NoSpace);
11665   verifyFormat("auto f(int x) -> __underlying_type(x);", NoSpace);
11666   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11667   verifyFormat("alignas(128) char a[128];", NoSpace);
11668   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11669   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11670   verifyFormat("int f() throw(Deprecated);", NoSpace);
11671   verifyFormat("typedef void (*cb)(int);", NoSpace);
11672   verifyFormat("T A::operator()();", NoSpace);
11673   verifyFormat("X A::operator++(T);", NoSpace);
11674   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11675 
11676   FormatStyle Space = getLLVMStyle();
11677   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11678 
11679   verifyFormat("int f ();", Space);
11680   verifyFormat("void f (int a, T b) {\n"
11681                "  while (true)\n"
11682                "    continue;\n"
11683                "}",
11684                Space);
11685   verifyFormat("if (true)\n"
11686                "  f ();\n"
11687                "else if (true)\n"
11688                "  f ();",
11689                Space);
11690   verifyFormat("do {\n"
11691                "  do_something ();\n"
11692                "} while (something ());",
11693                Space);
11694   verifyFormat("switch (x) {\n"
11695                "default:\n"
11696                "  break;\n"
11697                "}",
11698                Space);
11699   verifyFormat("A::A () : a (1) {}", Space);
11700   verifyFormat("void f () __attribute__ ((asdf));", Space);
11701   verifyFormat("*(&a + 1);\n"
11702                "&((&a)[1]);\n"
11703                "a[(b + c) * d];\n"
11704                "(((a + 1) * 2) + 3) * 4;",
11705                Space);
11706   verifyFormat("#define A(x) x", Space);
11707   verifyFormat("#define A (x) x", Space);
11708   verifyFormat("#if defined(x)\n"
11709                "#endif",
11710                Space);
11711   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11712   verifyFormat("size_t x = sizeof (x);", Space);
11713   verifyFormat("auto f (int x) -> decltype (x);", Space);
11714   verifyFormat("auto f (int x) -> typeof (x);", Space);
11715   verifyFormat("auto f (int x) -> _Atomic (x);", Space);
11716   verifyFormat("auto f (int x) -> __underlying_type (x);", Space);
11717   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11718   verifyFormat("alignas (128) char a[128];", Space);
11719   verifyFormat("size_t x = alignof (MyType);", Space);
11720   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11721   verifyFormat("int f () throw (Deprecated);", Space);
11722   verifyFormat("typedef void (*cb) (int);", Space);
11723   verifyFormat("T A::operator() ();", Space);
11724   verifyFormat("X A::operator++ (T);", Space);
11725   verifyFormat("auto lambda = [] () { return 0; };", Space);
11726   verifyFormat("int x = int (y);", Space);
11727 
11728   FormatStyle SomeSpace = getLLVMStyle();
11729   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11730 
11731   verifyFormat("[]() -> float {}", SomeSpace);
11732   verifyFormat("[] (auto foo) {}", SomeSpace);
11733   verifyFormat("[foo]() -> int {}", SomeSpace);
11734   verifyFormat("int f();", SomeSpace);
11735   verifyFormat("void f (int a, T b) {\n"
11736                "  while (true)\n"
11737                "    continue;\n"
11738                "}",
11739                SomeSpace);
11740   verifyFormat("if (true)\n"
11741                "  f();\n"
11742                "else if (true)\n"
11743                "  f();",
11744                SomeSpace);
11745   verifyFormat("do {\n"
11746                "  do_something();\n"
11747                "} while (something());",
11748                SomeSpace);
11749   verifyFormat("switch (x) {\n"
11750                "default:\n"
11751                "  break;\n"
11752                "}",
11753                SomeSpace);
11754   verifyFormat("A::A() : a (1) {}", SomeSpace);
11755   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11756   verifyFormat("*(&a + 1);\n"
11757                "&((&a)[1]);\n"
11758                "a[(b + c) * d];\n"
11759                "(((a + 1) * 2) + 3) * 4;",
11760                SomeSpace);
11761   verifyFormat("#define A(x) x", SomeSpace);
11762   verifyFormat("#define A (x) x", SomeSpace);
11763   verifyFormat("#if defined(x)\n"
11764                "#endif",
11765                SomeSpace);
11766   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11767   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11768   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11769   verifyFormat("auto f (int x) -> typeof (x);", SomeSpace);
11770   verifyFormat("auto f (int x) -> _Atomic (x);", SomeSpace);
11771   verifyFormat("auto f (int x) -> __underlying_type (x);", SomeSpace);
11772   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11773   verifyFormat("alignas (128) char a[128];", SomeSpace);
11774   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11775   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11776                SomeSpace);
11777   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11778   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11779   verifyFormat("T A::operator()();", SomeSpace);
11780   verifyFormat("X A::operator++ (T);", SomeSpace);
11781   verifyFormat("int x = int (y);", SomeSpace);
11782   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11783 }
11784 
11785 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11786   FormatStyle Spaces = getLLVMStyle();
11787   Spaces.SpaceAfterLogicalNot = true;
11788 
11789   verifyFormat("bool x = ! y", Spaces);
11790   verifyFormat("if (! isFailure())", Spaces);
11791   verifyFormat("if (! (a && b))", Spaces);
11792   verifyFormat("\"Error!\"", Spaces);
11793   verifyFormat("! ! x", Spaces);
11794 }
11795 
11796 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11797   FormatStyle Spaces = getLLVMStyle();
11798 
11799   Spaces.SpacesInParentheses = true;
11800   verifyFormat("do_something( ::globalVar );", Spaces);
11801   verifyFormat("call( x, y, z );", Spaces);
11802   verifyFormat("call();", Spaces);
11803   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11804   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11805                Spaces);
11806   verifyFormat("while ( (bool)1 )\n"
11807                "  continue;",
11808                Spaces);
11809   verifyFormat("for ( ;; )\n"
11810                "  continue;",
11811                Spaces);
11812   verifyFormat("if ( true )\n"
11813                "  f();\n"
11814                "else if ( true )\n"
11815                "  f();",
11816                Spaces);
11817   verifyFormat("do {\n"
11818                "  do_something( (int)i );\n"
11819                "} while ( something() );",
11820                Spaces);
11821   verifyFormat("switch ( x ) {\n"
11822                "default:\n"
11823                "  break;\n"
11824                "}",
11825                Spaces);
11826 
11827   Spaces.SpacesInParentheses = false;
11828   Spaces.SpacesInCStyleCastParentheses = true;
11829   verifyFormat("Type *A = ( Type * )P;", Spaces);
11830   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11831   verifyFormat("x = ( int32 )y;", Spaces);
11832   verifyFormat("int a = ( int )(2.0f);", Spaces);
11833   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11834   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11835   verifyFormat("#define x (( int )-1)", Spaces);
11836 
11837   // Run the first set of tests again with:
11838   Spaces.SpacesInParentheses = false;
11839   Spaces.SpaceInEmptyParentheses = true;
11840   Spaces.SpacesInCStyleCastParentheses = true;
11841   verifyFormat("call(x, y, z);", Spaces);
11842   verifyFormat("call( );", Spaces);
11843   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11844   verifyFormat("while (( bool )1)\n"
11845                "  continue;",
11846                Spaces);
11847   verifyFormat("for (;;)\n"
11848                "  continue;",
11849                Spaces);
11850   verifyFormat("if (true)\n"
11851                "  f( );\n"
11852                "else if (true)\n"
11853                "  f( );",
11854                Spaces);
11855   verifyFormat("do {\n"
11856                "  do_something(( int )i);\n"
11857                "} while (something( ));",
11858                Spaces);
11859   verifyFormat("switch (x) {\n"
11860                "default:\n"
11861                "  break;\n"
11862                "}",
11863                Spaces);
11864 
11865   // Run the first set of tests again with:
11866   Spaces.SpaceAfterCStyleCast = true;
11867   verifyFormat("call(x, y, z);", Spaces);
11868   verifyFormat("call( );", Spaces);
11869   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11870   verifyFormat("while (( bool ) 1)\n"
11871                "  continue;",
11872                Spaces);
11873   verifyFormat("for (;;)\n"
11874                "  continue;",
11875                Spaces);
11876   verifyFormat("if (true)\n"
11877                "  f( );\n"
11878                "else if (true)\n"
11879                "  f( );",
11880                Spaces);
11881   verifyFormat("do {\n"
11882                "  do_something(( int ) i);\n"
11883                "} while (something( ));",
11884                Spaces);
11885   verifyFormat("switch (x) {\n"
11886                "default:\n"
11887                "  break;\n"
11888                "}",
11889                Spaces);
11890 
11891   // Run subset of tests again with:
11892   Spaces.SpacesInCStyleCastParentheses = false;
11893   Spaces.SpaceAfterCStyleCast = true;
11894   verifyFormat("while ((bool) 1)\n"
11895                "  continue;",
11896                Spaces);
11897   verifyFormat("do {\n"
11898                "  do_something((int) i);\n"
11899                "} while (something( ));",
11900                Spaces);
11901 }
11902 
11903 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11904   verifyFormat("int a[5];");
11905   verifyFormat("a[3] += 42;");
11906 
11907   FormatStyle Spaces = getLLVMStyle();
11908   Spaces.SpacesInSquareBrackets = true;
11909   // Not lambdas.
11910   verifyFormat("int a[ 5 ];", Spaces);
11911   verifyFormat("a[ 3 ] += 42;", Spaces);
11912   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11913   verifyFormat("double &operator[](int i) { return 0; }\n"
11914                "int i;",
11915                Spaces);
11916   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11917   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11918   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11919   // Lambdas.
11920   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11921   verifyFormat("return [ i, args... ] {};", Spaces);
11922   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11923   verifyFormat("int foo = [ = ]() {};", Spaces);
11924   verifyFormat("int foo = [ & ]() {};", Spaces);
11925   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11926   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11927 }
11928 
11929 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11930   FormatStyle NoSpaceStyle = getLLVMStyle();
11931   verifyFormat("int a[5];", NoSpaceStyle);
11932   verifyFormat("a[3] += 42;", NoSpaceStyle);
11933 
11934   verifyFormat("int a[1];", NoSpaceStyle);
11935   verifyFormat("int 1 [a];", NoSpaceStyle);
11936   verifyFormat("int a[1][2];", NoSpaceStyle);
11937   verifyFormat("a[7] = 5;", NoSpaceStyle);
11938   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11939   verifyFormat("f([] {})", NoSpaceStyle);
11940 
11941   FormatStyle Space = getLLVMStyle();
11942   Space.SpaceBeforeSquareBrackets = true;
11943   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
11944   verifyFormat("return [i, args...] {};", Space);
11945 
11946   verifyFormat("int a [5];", Space);
11947   verifyFormat("a [3] += 42;", Space);
11948   verifyFormat("constexpr char hello []{\"hello\"};", Space);
11949   verifyFormat("double &operator[](int i) { return 0; }\n"
11950                "int i;",
11951                Space);
11952   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
11953   verifyFormat("int i = a [a][a]->f();", Space);
11954   verifyFormat("int i = (*b) [a]->f();", Space);
11955 
11956   verifyFormat("int a [1];", Space);
11957   verifyFormat("int 1 [a];", Space);
11958   verifyFormat("int a [1][2];", Space);
11959   verifyFormat("a [7] = 5;", Space);
11960   verifyFormat("int a = (f()) [23];", Space);
11961   verifyFormat("f([] {})", Space);
11962 }
11963 
11964 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
11965   verifyFormat("int a = 5;");
11966   verifyFormat("a += 42;");
11967   verifyFormat("a or_eq 8;");
11968 
11969   FormatStyle Spaces = getLLVMStyle();
11970   Spaces.SpaceBeforeAssignmentOperators = false;
11971   verifyFormat("int a= 5;", Spaces);
11972   verifyFormat("a+= 42;", Spaces);
11973   verifyFormat("a or_eq 8;", Spaces);
11974 }
11975 
11976 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
11977   verifyFormat("class Foo : public Bar {};");
11978   verifyFormat("Foo::Foo() : foo(1) {}");
11979   verifyFormat("for (auto a : b) {\n}");
11980   verifyFormat("int x = a ? b : c;");
11981   verifyFormat("{\n"
11982                "label0:\n"
11983                "  int x = 0;\n"
11984                "}");
11985   verifyFormat("switch (x) {\n"
11986                "case 1:\n"
11987                "default:\n"
11988                "}");
11989 
11990   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
11991   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
11992   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
11993   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
11994   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
11995   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
11996   verifyFormat("{\n"
11997                "label1:\n"
11998                "  int x = 0;\n"
11999                "}",
12000                CtorInitializerStyle);
12001   verifyFormat("switch (x) {\n"
12002                "case 1:\n"
12003                "default:\n"
12004                "}",
12005                CtorInitializerStyle);
12006   CtorInitializerStyle.BreakConstructorInitializers =
12007       FormatStyle::BCIS_AfterColon;
12008   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
12009                "    aaaaaaaaaaaaaaaa(1),\n"
12010                "    bbbbbbbbbbbbbbbb(2) {}",
12011                CtorInitializerStyle);
12012   CtorInitializerStyle.BreakConstructorInitializers =
12013       FormatStyle::BCIS_BeforeComma;
12014   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12015                "    : aaaaaaaaaaaaaaaa(1)\n"
12016                "    , bbbbbbbbbbbbbbbb(2) {}",
12017                CtorInitializerStyle);
12018   CtorInitializerStyle.BreakConstructorInitializers =
12019       FormatStyle::BCIS_BeforeColon;
12020   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12021                "    : aaaaaaaaaaaaaaaa(1),\n"
12022                "      bbbbbbbbbbbbbbbb(2) {}",
12023                CtorInitializerStyle);
12024   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
12025   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12026                ": aaaaaaaaaaaaaaaa(1),\n"
12027                "  bbbbbbbbbbbbbbbb(2) {}",
12028                CtorInitializerStyle);
12029 
12030   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
12031   InheritanceStyle.SpaceBeforeInheritanceColon = false;
12032   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
12033   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
12034   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
12035   verifyFormat("int x = a ? b : c;", InheritanceStyle);
12036   verifyFormat("{\n"
12037                "label2:\n"
12038                "  int x = 0;\n"
12039                "}",
12040                InheritanceStyle);
12041   verifyFormat("switch (x) {\n"
12042                "case 1:\n"
12043                "default:\n"
12044                "}",
12045                InheritanceStyle);
12046   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
12047   verifyFormat("class Foooooooooooooooooooooo:\n"
12048                "    public aaaaaaaaaaaaaaaaaa,\n"
12049                "    public bbbbbbbbbbbbbbbbbb {\n"
12050                "}",
12051                InheritanceStyle);
12052   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
12053   verifyFormat("class Foooooooooooooooooooooo\n"
12054                "    : public aaaaaaaaaaaaaaaaaa\n"
12055                "    , public bbbbbbbbbbbbbbbbbb {\n"
12056                "}",
12057                InheritanceStyle);
12058   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
12059   verifyFormat("class Foooooooooooooooooooooo\n"
12060                "    : public aaaaaaaaaaaaaaaaaa,\n"
12061                "      public bbbbbbbbbbbbbbbbbb {\n"
12062                "}",
12063                InheritanceStyle);
12064   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
12065   verifyFormat("class Foooooooooooooooooooooo\n"
12066                ": public aaaaaaaaaaaaaaaaaa,\n"
12067                "  public bbbbbbbbbbbbbbbbbb {}",
12068                InheritanceStyle);
12069 
12070   FormatStyle ForLoopStyle = getLLVMStyle();
12071   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
12072   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
12073   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
12074   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
12075   verifyFormat("int x = a ? b : c;", ForLoopStyle);
12076   verifyFormat("{\n"
12077                "label2:\n"
12078                "  int x = 0;\n"
12079                "}",
12080                ForLoopStyle);
12081   verifyFormat("switch (x) {\n"
12082                "case 1:\n"
12083                "default:\n"
12084                "}",
12085                ForLoopStyle);
12086 
12087   FormatStyle NoSpaceStyle = getLLVMStyle();
12088   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
12089   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
12090   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
12091   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
12092   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
12093   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
12094   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
12095   verifyFormat("{\n"
12096                "label3:\n"
12097                "  int x = 0;\n"
12098                "}",
12099                NoSpaceStyle);
12100   verifyFormat("switch (x) {\n"
12101                "case 1:\n"
12102                "default:\n"
12103                "}",
12104                NoSpaceStyle);
12105 }
12106 
12107 TEST_F(FormatTest, AlignConsecutiveMacros) {
12108   FormatStyle Style = getLLVMStyle();
12109   Style.AlignConsecutiveAssignments = true;
12110   Style.AlignConsecutiveDeclarations = true;
12111   Style.AlignConsecutiveMacros = false;
12112 
12113   verifyFormat("#define a 3\n"
12114                "#define bbbb 4\n"
12115                "#define ccc (5)",
12116                Style);
12117 
12118   verifyFormat("#define f(x) (x * x)\n"
12119                "#define fff(x, y, z) (x * y + z)\n"
12120                "#define ffff(x, y) (x - y)",
12121                Style);
12122 
12123   verifyFormat("#define foo(x, y) (x + y)\n"
12124                "#define bar (5, 6)(2 + 2)",
12125                Style);
12126 
12127   verifyFormat("#define a 3\n"
12128                "#define bbbb 4\n"
12129                "#define ccc (5)\n"
12130                "#define f(x) (x * x)\n"
12131                "#define fff(x, y, z) (x * y + z)\n"
12132                "#define ffff(x, y) (x - y)",
12133                Style);
12134 
12135   Style.AlignConsecutiveMacros = true;
12136   verifyFormat("#define a    3\n"
12137                "#define bbbb 4\n"
12138                "#define ccc  (5)",
12139                Style);
12140 
12141   verifyFormat("#define f(x)         (x * x)\n"
12142                "#define fff(x, y, z) (x * y + z)\n"
12143                "#define ffff(x, y)   (x - y)",
12144                Style);
12145 
12146   verifyFormat("#define foo(x, y) (x + y)\n"
12147                "#define bar       (5, 6)(2 + 2)",
12148                Style);
12149 
12150   verifyFormat("#define a            3\n"
12151                "#define bbbb         4\n"
12152                "#define ccc          (5)\n"
12153                "#define f(x)         (x * x)\n"
12154                "#define fff(x, y, z) (x * y + z)\n"
12155                "#define ffff(x, y)   (x - y)",
12156                Style);
12157 
12158   verifyFormat("#define a         5\n"
12159                "#define foo(x, y) (x + y)\n"
12160                "#define CCC       (6)\n"
12161                "auto lambda = []() {\n"
12162                "  auto  ii = 0;\n"
12163                "  float j  = 0;\n"
12164                "  return 0;\n"
12165                "};\n"
12166                "int   i  = 0;\n"
12167                "float i2 = 0;\n"
12168                "auto  v  = type{\n"
12169                "    i = 1,   //\n"
12170                "    (i = 2), //\n"
12171                "    i = 3    //\n"
12172                "};",
12173                Style);
12174 
12175   Style.AlignConsecutiveMacros = false;
12176   Style.ColumnLimit = 20;
12177 
12178   verifyFormat("#define a          \\\n"
12179                "  \"aabbbbbbbbbbbb\"\n"
12180                "#define D          \\\n"
12181                "  \"aabbbbbbbbbbbb\" \\\n"
12182                "  \"ccddeeeeeeeee\"\n"
12183                "#define B          \\\n"
12184                "  \"QQQQQQQQQQQQQ\"  \\\n"
12185                "  \"FFFFFFFFFFFFF\"  \\\n"
12186                "  \"LLLLLLLL\"\n",
12187                Style);
12188 
12189   Style.AlignConsecutiveMacros = true;
12190   verifyFormat("#define a          \\\n"
12191                "  \"aabbbbbbbbbbbb\"\n"
12192                "#define D          \\\n"
12193                "  \"aabbbbbbbbbbbb\" \\\n"
12194                "  \"ccddeeeeeeeee\"\n"
12195                "#define B          \\\n"
12196                "  \"QQQQQQQQQQQQQ\"  \\\n"
12197                "  \"FFFFFFFFFFFFF\"  \\\n"
12198                "  \"LLLLLLLL\"\n",
12199                Style);
12200 }
12201 
12202 TEST_F(FormatTest, AlignConsecutiveAssignments) {
12203   FormatStyle Alignment = getLLVMStyle();
12204   Alignment.AlignConsecutiveMacros = true;
12205   Alignment.AlignConsecutiveAssignments = false;
12206   verifyFormat("int a = 5;\n"
12207                "int oneTwoThree = 123;",
12208                Alignment);
12209   verifyFormat("int a = 5;\n"
12210                "int oneTwoThree = 123;",
12211                Alignment);
12212 
12213   Alignment.AlignConsecutiveAssignments = true;
12214   verifyFormat("int a           = 5;\n"
12215                "int oneTwoThree = 123;",
12216                Alignment);
12217   verifyFormat("int a           = method();\n"
12218                "int oneTwoThree = 133;",
12219                Alignment);
12220   verifyFormat("a &= 5;\n"
12221                "bcd *= 5;\n"
12222                "ghtyf += 5;\n"
12223                "dvfvdb -= 5;\n"
12224                "a /= 5;\n"
12225                "vdsvsv %= 5;\n"
12226                "sfdbddfbdfbb ^= 5;\n"
12227                "dvsdsv |= 5;\n"
12228                "int dsvvdvsdvvv = 123;",
12229                Alignment);
12230   verifyFormat("int i = 1, j = 10;\n"
12231                "something = 2000;",
12232                Alignment);
12233   verifyFormat("something = 2000;\n"
12234                "int i = 1, j = 10;\n",
12235                Alignment);
12236   verifyFormat("something = 2000;\n"
12237                "another   = 911;\n"
12238                "int i = 1, j = 10;\n"
12239                "oneMore = 1;\n"
12240                "i       = 2;",
12241                Alignment);
12242   verifyFormat("int a   = 5;\n"
12243                "int one = 1;\n"
12244                "method();\n"
12245                "int oneTwoThree = 123;\n"
12246                "int oneTwo      = 12;",
12247                Alignment);
12248   verifyFormat("int oneTwoThree = 123;\n"
12249                "int oneTwo      = 12;\n"
12250                "method();\n",
12251                Alignment);
12252   verifyFormat("int oneTwoThree = 123; // comment\n"
12253                "int oneTwo      = 12;  // comment",
12254                Alignment);
12255 
12256   // Bug 25167
12257   /* Uncomment when fixed
12258     verifyFormat("#if A\n"
12259                  "#else\n"
12260                  "int aaaaaaaa = 12;\n"
12261                  "#endif\n"
12262                  "#if B\n"
12263                  "#else\n"
12264                  "int a = 12;\n"
12265                  "#endif\n",
12266                  Alignment);
12267     verifyFormat("enum foo {\n"
12268                  "#if A\n"
12269                  "#else\n"
12270                  "  aaaaaaaa = 12;\n"
12271                  "#endif\n"
12272                  "#if B\n"
12273                  "#else\n"
12274                  "  a = 12;\n"
12275                  "#endif\n"
12276                  "};\n",
12277                  Alignment);
12278   */
12279 
12280   EXPECT_EQ("int a = 5;\n"
12281             "\n"
12282             "int oneTwoThree = 123;",
12283             format("int a       = 5;\n"
12284                    "\n"
12285                    "int oneTwoThree= 123;",
12286                    Alignment));
12287   EXPECT_EQ("int a   = 5;\n"
12288             "int one = 1;\n"
12289             "\n"
12290             "int oneTwoThree = 123;",
12291             format("int a = 5;\n"
12292                    "int one = 1;\n"
12293                    "\n"
12294                    "int oneTwoThree = 123;",
12295                    Alignment));
12296   EXPECT_EQ("int a   = 5;\n"
12297             "int one = 1;\n"
12298             "\n"
12299             "int oneTwoThree = 123;\n"
12300             "int oneTwo      = 12;",
12301             format("int a = 5;\n"
12302                    "int one = 1;\n"
12303                    "\n"
12304                    "int oneTwoThree = 123;\n"
12305                    "int oneTwo = 12;",
12306                    Alignment));
12307   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12308   verifyFormat("#define A \\\n"
12309                "  int aaaa       = 12; \\\n"
12310                "  int b          = 23; \\\n"
12311                "  int ccc        = 234; \\\n"
12312                "  int dddddddddd = 2345;",
12313                Alignment);
12314   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12315   verifyFormat("#define A               \\\n"
12316                "  int aaaa       = 12;  \\\n"
12317                "  int b          = 23;  \\\n"
12318                "  int ccc        = 234; \\\n"
12319                "  int dddddddddd = 2345;",
12320                Alignment);
12321   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12322   verifyFormat("#define A                                                      "
12323                "                \\\n"
12324                "  int aaaa       = 12;                                         "
12325                "                \\\n"
12326                "  int b          = 23;                                         "
12327                "                \\\n"
12328                "  int ccc        = 234;                                        "
12329                "                \\\n"
12330                "  int dddddddddd = 2345;",
12331                Alignment);
12332   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12333                "k = 4, int l = 5,\n"
12334                "                  int m = 6) {\n"
12335                "  int j      = 10;\n"
12336                "  otherThing = 1;\n"
12337                "}",
12338                Alignment);
12339   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12340                "  int i   = 1;\n"
12341                "  int j   = 2;\n"
12342                "  int big = 10000;\n"
12343                "}",
12344                Alignment);
12345   verifyFormat("class C {\n"
12346                "public:\n"
12347                "  int i            = 1;\n"
12348                "  virtual void f() = 0;\n"
12349                "};",
12350                Alignment);
12351   verifyFormat("int i = 1;\n"
12352                "if (SomeType t = getSomething()) {\n"
12353                "}\n"
12354                "int j   = 2;\n"
12355                "int big = 10000;",
12356                Alignment);
12357   verifyFormat("int j = 7;\n"
12358                "for (int k = 0; k < N; ++k) {\n"
12359                "}\n"
12360                "int j   = 2;\n"
12361                "int big = 10000;\n"
12362                "}",
12363                Alignment);
12364   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12365   verifyFormat("int i = 1;\n"
12366                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12367                "    = someLooooooooooooooooongFunction();\n"
12368                "int j = 2;",
12369                Alignment);
12370   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12371   verifyFormat("int i = 1;\n"
12372                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12373                "    someLooooooooooooooooongFunction();\n"
12374                "int j = 2;",
12375                Alignment);
12376 
12377   verifyFormat("auto lambda = []() {\n"
12378                "  auto i = 0;\n"
12379                "  return 0;\n"
12380                "};\n"
12381                "int i  = 0;\n"
12382                "auto v = type{\n"
12383                "    i = 1,   //\n"
12384                "    (i = 2), //\n"
12385                "    i = 3    //\n"
12386                "};",
12387                Alignment);
12388 
12389   verifyFormat(
12390       "int i      = 1;\n"
12391       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12392       "                          loooooooooooooooooooooongParameterB);\n"
12393       "int j      = 2;",
12394       Alignment);
12395 
12396   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12397                "          typename B   = very_long_type_name_1,\n"
12398                "          typename T_2 = very_long_type_name_2>\n"
12399                "auto foo() {}\n",
12400                Alignment);
12401   verifyFormat("int a, b = 1;\n"
12402                "int c  = 2;\n"
12403                "int dd = 3;\n",
12404                Alignment);
12405   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12406                "float b[1][] = {{3.f}};\n",
12407                Alignment);
12408   verifyFormat("for (int i = 0; i < 1; i++)\n"
12409                "  int x = 1;\n",
12410                Alignment);
12411   verifyFormat("for (i = 0; i < 1; i++)\n"
12412                "  x = 1;\n"
12413                "y = 1;\n",
12414                Alignment);
12415 
12416   Alignment.ReflowComments = true;
12417   Alignment.ColumnLimit = 50;
12418   EXPECT_EQ("int x   = 0;\n"
12419             "int yy  = 1; /// specificlennospace\n"
12420             "int zzz = 2;\n",
12421             format("int x   = 0;\n"
12422                    "int yy  = 1; ///specificlennospace\n"
12423                    "int zzz = 2;\n",
12424                    Alignment));
12425 }
12426 
12427 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12428   FormatStyle Alignment = getLLVMStyle();
12429   Alignment.AlignConsecutiveBitFields = true;
12430   verifyFormat("int const a     : 5;\n"
12431                "int oneTwoThree : 23;",
12432                Alignment);
12433 
12434   // Initializers are allowed starting with c++2a
12435   verifyFormat("int const a     : 5 = 1;\n"
12436                "int oneTwoThree : 23 = 0;",
12437                Alignment);
12438 
12439   Alignment.AlignConsecutiveDeclarations = true;
12440   verifyFormat("int const a           : 5;\n"
12441                "int       oneTwoThree : 23;",
12442                Alignment);
12443 
12444   verifyFormat("int const a           : 5;  // comment\n"
12445                "int       oneTwoThree : 23; // comment",
12446                Alignment);
12447 
12448   verifyFormat("int const a           : 5 = 1;\n"
12449                "int       oneTwoThree : 23 = 0;",
12450                Alignment);
12451 
12452   Alignment.AlignConsecutiveAssignments = true;
12453   verifyFormat("int const a           : 5  = 1;\n"
12454                "int       oneTwoThree : 23 = 0;",
12455                Alignment);
12456   verifyFormat("int const a           : 5  = {1};\n"
12457                "int       oneTwoThree : 23 = 0;",
12458                Alignment);
12459 
12460   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
12461   verifyFormat("int const a          :5;\n"
12462                "int       oneTwoThree:23;",
12463                Alignment);
12464 
12465   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
12466   verifyFormat("int const a           :5;\n"
12467                "int       oneTwoThree :23;",
12468                Alignment);
12469 
12470   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
12471   verifyFormat("int const a          : 5;\n"
12472                "int       oneTwoThree: 23;",
12473                Alignment);
12474 
12475   // Known limitations: ':' is only recognized as a bitfield colon when
12476   // followed by a number.
12477   /*
12478   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12479                "int a           : 5;",
12480                Alignment);
12481   */
12482 }
12483 
12484 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12485   FormatStyle Alignment = getLLVMStyle();
12486   Alignment.AlignConsecutiveMacros = true;
12487   Alignment.AlignConsecutiveDeclarations = false;
12488   verifyFormat("float const a = 5;\n"
12489                "int oneTwoThree = 123;",
12490                Alignment);
12491   verifyFormat("int a = 5;\n"
12492                "float const oneTwoThree = 123;",
12493                Alignment);
12494 
12495   Alignment.AlignConsecutiveDeclarations = true;
12496   verifyFormat("float const a = 5;\n"
12497                "int         oneTwoThree = 123;",
12498                Alignment);
12499   verifyFormat("int         a = method();\n"
12500                "float const oneTwoThree = 133;",
12501                Alignment);
12502   verifyFormat("int i = 1, j = 10;\n"
12503                "something = 2000;",
12504                Alignment);
12505   verifyFormat("something = 2000;\n"
12506                "int i = 1, j = 10;\n",
12507                Alignment);
12508   verifyFormat("float      something = 2000;\n"
12509                "double     another = 911;\n"
12510                "int        i = 1, j = 10;\n"
12511                "const int *oneMore = 1;\n"
12512                "unsigned   i = 2;",
12513                Alignment);
12514   verifyFormat("float a = 5;\n"
12515                "int   one = 1;\n"
12516                "method();\n"
12517                "const double       oneTwoThree = 123;\n"
12518                "const unsigned int oneTwo = 12;",
12519                Alignment);
12520   verifyFormat("int      oneTwoThree{0}; // comment\n"
12521                "unsigned oneTwo;         // comment",
12522                Alignment);
12523   EXPECT_EQ("float const a = 5;\n"
12524             "\n"
12525             "int oneTwoThree = 123;",
12526             format("float const   a = 5;\n"
12527                    "\n"
12528                    "int           oneTwoThree= 123;",
12529                    Alignment));
12530   EXPECT_EQ("float a = 5;\n"
12531             "int   one = 1;\n"
12532             "\n"
12533             "unsigned oneTwoThree = 123;",
12534             format("float    a = 5;\n"
12535                    "int      one = 1;\n"
12536                    "\n"
12537                    "unsigned oneTwoThree = 123;",
12538                    Alignment));
12539   EXPECT_EQ("float a = 5;\n"
12540             "int   one = 1;\n"
12541             "\n"
12542             "unsigned oneTwoThree = 123;\n"
12543             "int      oneTwo = 12;",
12544             format("float    a = 5;\n"
12545                    "int one = 1;\n"
12546                    "\n"
12547                    "unsigned oneTwoThree = 123;\n"
12548                    "int oneTwo = 12;",
12549                    Alignment));
12550   // Function prototype alignment
12551   verifyFormat("int    a();\n"
12552                "double b();",
12553                Alignment);
12554   verifyFormat("int    a(int x);\n"
12555                "double b();",
12556                Alignment);
12557   unsigned OldColumnLimit = Alignment.ColumnLimit;
12558   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12559   // otherwise the function parameters will be re-flowed onto a single line.
12560   Alignment.ColumnLimit = 0;
12561   EXPECT_EQ("int    a(int   x,\n"
12562             "         float y);\n"
12563             "double b(int    x,\n"
12564             "         double y);",
12565             format("int a(int x,\n"
12566                    " float y);\n"
12567                    "double b(int x,\n"
12568                    " double y);",
12569                    Alignment));
12570   // This ensures that function parameters of function declarations are
12571   // correctly indented when their owning functions are indented.
12572   // The failure case here is for 'double y' to not be indented enough.
12573   EXPECT_EQ("double a(int x);\n"
12574             "int    b(int    y,\n"
12575             "         double z);",
12576             format("double a(int x);\n"
12577                    "int b(int y,\n"
12578                    " double z);",
12579                    Alignment));
12580   // Set ColumnLimit low so that we induce wrapping immediately after
12581   // the function name and opening paren.
12582   Alignment.ColumnLimit = 13;
12583   verifyFormat("int function(\n"
12584                "    int  x,\n"
12585                "    bool y);",
12586                Alignment);
12587   Alignment.ColumnLimit = OldColumnLimit;
12588   // Ensure function pointers don't screw up recursive alignment
12589   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12590                "double b();",
12591                Alignment);
12592   Alignment.AlignConsecutiveAssignments = true;
12593   // Ensure recursive alignment is broken by function braces, so that the
12594   // "a = 1" does not align with subsequent assignments inside the function
12595   // body.
12596   verifyFormat("int func(int a = 1) {\n"
12597                "  int b  = 2;\n"
12598                "  int cc = 3;\n"
12599                "}",
12600                Alignment);
12601   verifyFormat("float      something = 2000;\n"
12602                "double     another   = 911;\n"
12603                "int        i = 1, j = 10;\n"
12604                "const int *oneMore = 1;\n"
12605                "unsigned   i       = 2;",
12606                Alignment);
12607   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12608                "unsigned oneTwo      = 0;   // comment",
12609                Alignment);
12610   // Make sure that scope is correctly tracked, in the absence of braces
12611   verifyFormat("for (int i = 0; i < n; i++)\n"
12612                "  j = i;\n"
12613                "double x = 1;\n",
12614                Alignment);
12615   verifyFormat("if (int i = 0)\n"
12616                "  j = i;\n"
12617                "double x = 1;\n",
12618                Alignment);
12619   // Ensure operator[] and operator() are comprehended
12620   verifyFormat("struct test {\n"
12621                "  long long int foo();\n"
12622                "  int           operator[](int a);\n"
12623                "  double        bar();\n"
12624                "};\n",
12625                Alignment);
12626   verifyFormat("struct test {\n"
12627                "  long long int foo();\n"
12628                "  int           operator()(int a);\n"
12629                "  double        bar();\n"
12630                "};\n",
12631                Alignment);
12632   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12633             "  int const i   = 1;\n"
12634             "  int *     j   = 2;\n"
12635             "  int       big = 10000;\n"
12636             "\n"
12637             "  unsigned oneTwoThree = 123;\n"
12638             "  int      oneTwo      = 12;\n"
12639             "  method();\n"
12640             "  float k  = 2;\n"
12641             "  int   ll = 10000;\n"
12642             "}",
12643             format("void SomeFunction(int parameter= 0) {\n"
12644                    " int const  i= 1;\n"
12645                    "  int *j=2;\n"
12646                    " int big  =  10000;\n"
12647                    "\n"
12648                    "unsigned oneTwoThree  =123;\n"
12649                    "int oneTwo = 12;\n"
12650                    "  method();\n"
12651                    "float k= 2;\n"
12652                    "int ll=10000;\n"
12653                    "}",
12654                    Alignment));
12655   Alignment.AlignConsecutiveAssignments = false;
12656   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12657   verifyFormat("#define A \\\n"
12658                "  int       aaaa = 12; \\\n"
12659                "  float     b = 23; \\\n"
12660                "  const int ccc = 234; \\\n"
12661                "  unsigned  dddddddddd = 2345;",
12662                Alignment);
12663   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12664   verifyFormat("#define A              \\\n"
12665                "  int       aaaa = 12; \\\n"
12666                "  float     b = 23;    \\\n"
12667                "  const int ccc = 234; \\\n"
12668                "  unsigned  dddddddddd = 2345;",
12669                Alignment);
12670   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12671   Alignment.ColumnLimit = 30;
12672   verifyFormat("#define A                    \\\n"
12673                "  int       aaaa = 12;       \\\n"
12674                "  float     b = 23;          \\\n"
12675                "  const int ccc = 234;       \\\n"
12676                "  int       dddddddddd = 2345;",
12677                Alignment);
12678   Alignment.ColumnLimit = 80;
12679   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12680                "k = 4, int l = 5,\n"
12681                "                  int m = 6) {\n"
12682                "  const int j = 10;\n"
12683                "  otherThing = 1;\n"
12684                "}",
12685                Alignment);
12686   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12687                "  int const i = 1;\n"
12688                "  int *     j = 2;\n"
12689                "  int       big = 10000;\n"
12690                "}",
12691                Alignment);
12692   verifyFormat("class C {\n"
12693                "public:\n"
12694                "  int          i = 1;\n"
12695                "  virtual void f() = 0;\n"
12696                "};",
12697                Alignment);
12698   verifyFormat("float i = 1;\n"
12699                "if (SomeType t = getSomething()) {\n"
12700                "}\n"
12701                "const unsigned j = 2;\n"
12702                "int            big = 10000;",
12703                Alignment);
12704   verifyFormat("float j = 7;\n"
12705                "for (int k = 0; k < N; ++k) {\n"
12706                "}\n"
12707                "unsigned j = 2;\n"
12708                "int      big = 10000;\n"
12709                "}",
12710                Alignment);
12711   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12712   verifyFormat("float              i = 1;\n"
12713                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12714                "    = someLooooooooooooooooongFunction();\n"
12715                "int j = 2;",
12716                Alignment);
12717   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12718   verifyFormat("int                i = 1;\n"
12719                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12720                "    someLooooooooooooooooongFunction();\n"
12721                "int j = 2;",
12722                Alignment);
12723 
12724   Alignment.AlignConsecutiveAssignments = true;
12725   verifyFormat("auto lambda = []() {\n"
12726                "  auto  ii = 0;\n"
12727                "  float j  = 0;\n"
12728                "  return 0;\n"
12729                "};\n"
12730                "int   i  = 0;\n"
12731                "float i2 = 0;\n"
12732                "auto  v  = type{\n"
12733                "    i = 1,   //\n"
12734                "    (i = 2), //\n"
12735                "    i = 3    //\n"
12736                "};",
12737                Alignment);
12738   Alignment.AlignConsecutiveAssignments = false;
12739 
12740   verifyFormat(
12741       "int      i = 1;\n"
12742       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12743       "                          loooooooooooooooooooooongParameterB);\n"
12744       "int      j = 2;",
12745       Alignment);
12746 
12747   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12748   // We expect declarations and assignments to align, as long as it doesn't
12749   // exceed the column limit, starting a new alignment sequence whenever it
12750   // happens.
12751   Alignment.AlignConsecutiveAssignments = true;
12752   Alignment.ColumnLimit = 30;
12753   verifyFormat("float    ii              = 1;\n"
12754                "unsigned j               = 2;\n"
12755                "int someVerylongVariable = 1;\n"
12756                "AnotherLongType  ll = 123456;\n"
12757                "VeryVeryLongType k  = 2;\n"
12758                "int              myvar = 1;",
12759                Alignment);
12760   Alignment.ColumnLimit = 80;
12761   Alignment.AlignConsecutiveAssignments = false;
12762 
12763   verifyFormat(
12764       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12765       "          typename LongType, typename B>\n"
12766       "auto foo() {}\n",
12767       Alignment);
12768   verifyFormat("float a, b = 1;\n"
12769                "int   c = 2;\n"
12770                "int   dd = 3;\n",
12771                Alignment);
12772   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12773                "float b[1][] = {{3.f}};\n",
12774                Alignment);
12775   Alignment.AlignConsecutiveAssignments = true;
12776   verifyFormat("float a, b = 1;\n"
12777                "int   c  = 2;\n"
12778                "int   dd = 3;\n",
12779                Alignment);
12780   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12781                "float b[1][] = {{3.f}};\n",
12782                Alignment);
12783   Alignment.AlignConsecutiveAssignments = false;
12784 
12785   Alignment.ColumnLimit = 30;
12786   Alignment.BinPackParameters = false;
12787   verifyFormat("void foo(float     a,\n"
12788                "         float     b,\n"
12789                "         int       c,\n"
12790                "         uint32_t *d) {\n"
12791                "  int *  e = 0;\n"
12792                "  float  f = 0;\n"
12793                "  double g = 0;\n"
12794                "}\n"
12795                "void bar(ino_t     a,\n"
12796                "         int       b,\n"
12797                "         uint32_t *c,\n"
12798                "         bool      d) {}\n",
12799                Alignment);
12800   Alignment.BinPackParameters = true;
12801   Alignment.ColumnLimit = 80;
12802 
12803   // Bug 33507
12804   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12805   verifyFormat(
12806       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12807       "  static const Version verVs2017;\n"
12808       "  return true;\n"
12809       "});\n",
12810       Alignment);
12811   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12812 
12813   // See llvm.org/PR35641
12814   Alignment.AlignConsecutiveDeclarations = true;
12815   verifyFormat("int func() { //\n"
12816                "  int      b;\n"
12817                "  unsigned c;\n"
12818                "}",
12819                Alignment);
12820 
12821   // See PR37175
12822   FormatStyle Style = getMozillaStyle();
12823   Style.AlignConsecutiveDeclarations = true;
12824   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12825             "foo(int a);",
12826             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12827 }
12828 
12829 TEST_F(FormatTest, LinuxBraceBreaking) {
12830   FormatStyle LinuxBraceStyle = getLLVMStyle();
12831   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12832   verifyFormat("namespace a\n"
12833                "{\n"
12834                "class A\n"
12835                "{\n"
12836                "  void f()\n"
12837                "  {\n"
12838                "    if (true) {\n"
12839                "      a();\n"
12840                "      b();\n"
12841                "    } else {\n"
12842                "      a();\n"
12843                "    }\n"
12844                "  }\n"
12845                "  void g() { return; }\n"
12846                "};\n"
12847                "struct B {\n"
12848                "  int x;\n"
12849                "};\n"
12850                "} // namespace a\n",
12851                LinuxBraceStyle);
12852   verifyFormat("enum X {\n"
12853                "  Y = 0,\n"
12854                "}\n",
12855                LinuxBraceStyle);
12856   verifyFormat("struct S {\n"
12857                "  int Type;\n"
12858                "  union {\n"
12859                "    int x;\n"
12860                "    double y;\n"
12861                "  } Value;\n"
12862                "  class C\n"
12863                "  {\n"
12864                "    MyFavoriteType Value;\n"
12865                "  } Class;\n"
12866                "}\n",
12867                LinuxBraceStyle);
12868 }
12869 
12870 TEST_F(FormatTest, MozillaBraceBreaking) {
12871   FormatStyle MozillaBraceStyle = getLLVMStyle();
12872   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12873   MozillaBraceStyle.FixNamespaceComments = false;
12874   verifyFormat("namespace a {\n"
12875                "class A\n"
12876                "{\n"
12877                "  void f()\n"
12878                "  {\n"
12879                "    if (true) {\n"
12880                "      a();\n"
12881                "      b();\n"
12882                "    }\n"
12883                "  }\n"
12884                "  void g() { return; }\n"
12885                "};\n"
12886                "enum E\n"
12887                "{\n"
12888                "  A,\n"
12889                "  // foo\n"
12890                "  B,\n"
12891                "  C\n"
12892                "};\n"
12893                "struct B\n"
12894                "{\n"
12895                "  int x;\n"
12896                "};\n"
12897                "}\n",
12898                MozillaBraceStyle);
12899   verifyFormat("struct S\n"
12900                "{\n"
12901                "  int Type;\n"
12902                "  union\n"
12903                "  {\n"
12904                "    int x;\n"
12905                "    double y;\n"
12906                "  } Value;\n"
12907                "  class C\n"
12908                "  {\n"
12909                "    MyFavoriteType Value;\n"
12910                "  } Class;\n"
12911                "}\n",
12912                MozillaBraceStyle);
12913 }
12914 
12915 TEST_F(FormatTest, StroustrupBraceBreaking) {
12916   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12917   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12918   verifyFormat("namespace a {\n"
12919                "class A {\n"
12920                "  void f()\n"
12921                "  {\n"
12922                "    if (true) {\n"
12923                "      a();\n"
12924                "      b();\n"
12925                "    }\n"
12926                "  }\n"
12927                "  void g() { return; }\n"
12928                "};\n"
12929                "struct B {\n"
12930                "  int x;\n"
12931                "};\n"
12932                "} // namespace a\n",
12933                StroustrupBraceStyle);
12934 
12935   verifyFormat("void foo()\n"
12936                "{\n"
12937                "  if (a) {\n"
12938                "    a();\n"
12939                "  }\n"
12940                "  else {\n"
12941                "    b();\n"
12942                "  }\n"
12943                "}\n",
12944                StroustrupBraceStyle);
12945 
12946   verifyFormat("#ifdef _DEBUG\n"
12947                "int foo(int i = 0)\n"
12948                "#else\n"
12949                "int foo(int i = 5)\n"
12950                "#endif\n"
12951                "{\n"
12952                "  return i;\n"
12953                "}",
12954                StroustrupBraceStyle);
12955 
12956   verifyFormat("void foo() {}\n"
12957                "void bar()\n"
12958                "#ifdef _DEBUG\n"
12959                "{\n"
12960                "  foo();\n"
12961                "}\n"
12962                "#else\n"
12963                "{\n"
12964                "}\n"
12965                "#endif",
12966                StroustrupBraceStyle);
12967 
12968   verifyFormat("void foobar() { int i = 5; }\n"
12969                "#ifdef _DEBUG\n"
12970                "void bar() {}\n"
12971                "#else\n"
12972                "void bar() { foobar(); }\n"
12973                "#endif",
12974                StroustrupBraceStyle);
12975 }
12976 
12977 TEST_F(FormatTest, AllmanBraceBreaking) {
12978   FormatStyle AllmanBraceStyle = getLLVMStyle();
12979   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
12980 
12981   EXPECT_EQ("namespace a\n"
12982             "{\n"
12983             "void f();\n"
12984             "void g();\n"
12985             "} // namespace a\n",
12986             format("namespace a\n"
12987                    "{\n"
12988                    "void f();\n"
12989                    "void g();\n"
12990                    "}\n",
12991                    AllmanBraceStyle));
12992 
12993   verifyFormat("namespace a\n"
12994                "{\n"
12995                "class A\n"
12996                "{\n"
12997                "  void f()\n"
12998                "  {\n"
12999                "    if (true)\n"
13000                "    {\n"
13001                "      a();\n"
13002                "      b();\n"
13003                "    }\n"
13004                "  }\n"
13005                "  void g() { return; }\n"
13006                "};\n"
13007                "struct B\n"
13008                "{\n"
13009                "  int x;\n"
13010                "};\n"
13011                "union C\n"
13012                "{\n"
13013                "};\n"
13014                "} // namespace a",
13015                AllmanBraceStyle);
13016 
13017   verifyFormat("void f()\n"
13018                "{\n"
13019                "  if (true)\n"
13020                "  {\n"
13021                "    a();\n"
13022                "  }\n"
13023                "  else if (false)\n"
13024                "  {\n"
13025                "    b();\n"
13026                "  }\n"
13027                "  else\n"
13028                "  {\n"
13029                "    c();\n"
13030                "  }\n"
13031                "}\n",
13032                AllmanBraceStyle);
13033 
13034   verifyFormat("void f()\n"
13035                "{\n"
13036                "  for (int i = 0; i < 10; ++i)\n"
13037                "  {\n"
13038                "    a();\n"
13039                "  }\n"
13040                "  while (false)\n"
13041                "  {\n"
13042                "    b();\n"
13043                "  }\n"
13044                "  do\n"
13045                "  {\n"
13046                "    c();\n"
13047                "  } while (false)\n"
13048                "}\n",
13049                AllmanBraceStyle);
13050 
13051   verifyFormat("void f(int a)\n"
13052                "{\n"
13053                "  switch (a)\n"
13054                "  {\n"
13055                "  case 0:\n"
13056                "    break;\n"
13057                "  case 1:\n"
13058                "  {\n"
13059                "    break;\n"
13060                "  }\n"
13061                "  case 2:\n"
13062                "  {\n"
13063                "  }\n"
13064                "  break;\n"
13065                "  default:\n"
13066                "    break;\n"
13067                "  }\n"
13068                "}\n",
13069                AllmanBraceStyle);
13070 
13071   verifyFormat("enum X\n"
13072                "{\n"
13073                "  Y = 0,\n"
13074                "}\n",
13075                AllmanBraceStyle);
13076   verifyFormat("enum X\n"
13077                "{\n"
13078                "  Y = 0\n"
13079                "}\n",
13080                AllmanBraceStyle);
13081 
13082   verifyFormat("@interface BSApplicationController ()\n"
13083                "{\n"
13084                "@private\n"
13085                "  id _extraIvar;\n"
13086                "}\n"
13087                "@end\n",
13088                AllmanBraceStyle);
13089 
13090   verifyFormat("#ifdef _DEBUG\n"
13091                "int foo(int i = 0)\n"
13092                "#else\n"
13093                "int foo(int i = 5)\n"
13094                "#endif\n"
13095                "{\n"
13096                "  return i;\n"
13097                "}",
13098                AllmanBraceStyle);
13099 
13100   verifyFormat("void foo() {}\n"
13101                "void bar()\n"
13102                "#ifdef _DEBUG\n"
13103                "{\n"
13104                "  foo();\n"
13105                "}\n"
13106                "#else\n"
13107                "{\n"
13108                "}\n"
13109                "#endif",
13110                AllmanBraceStyle);
13111 
13112   verifyFormat("void foobar() { int i = 5; }\n"
13113                "#ifdef _DEBUG\n"
13114                "void bar() {}\n"
13115                "#else\n"
13116                "void bar() { foobar(); }\n"
13117                "#endif",
13118                AllmanBraceStyle);
13119 
13120   // This shouldn't affect ObjC blocks..
13121   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13122                "  // ...\n"
13123                "  int i;\n"
13124                "}];",
13125                AllmanBraceStyle);
13126   verifyFormat("void (^block)(void) = ^{\n"
13127                "  // ...\n"
13128                "  int i;\n"
13129                "};",
13130                AllmanBraceStyle);
13131   // .. or dict literals.
13132   verifyFormat("void f()\n"
13133                "{\n"
13134                "  // ...\n"
13135                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13136                "}",
13137                AllmanBraceStyle);
13138   verifyFormat("void f()\n"
13139                "{\n"
13140                "  // ...\n"
13141                "  [object someMethod:@{a : @\"b\"}];\n"
13142                "}",
13143                AllmanBraceStyle);
13144   verifyFormat("int f()\n"
13145                "{ // comment\n"
13146                "  return 42;\n"
13147                "}",
13148                AllmanBraceStyle);
13149 
13150   AllmanBraceStyle.ColumnLimit = 19;
13151   verifyFormat("void f() { int i; }", AllmanBraceStyle);
13152   AllmanBraceStyle.ColumnLimit = 18;
13153   verifyFormat("void f()\n"
13154                "{\n"
13155                "  int i;\n"
13156                "}",
13157                AllmanBraceStyle);
13158   AllmanBraceStyle.ColumnLimit = 80;
13159 
13160   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
13161   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13162       FormatStyle::SIS_WithoutElse;
13163   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13164   verifyFormat("void f(bool b)\n"
13165                "{\n"
13166                "  if (b)\n"
13167                "  {\n"
13168                "    return;\n"
13169                "  }\n"
13170                "}\n",
13171                BreakBeforeBraceShortIfs);
13172   verifyFormat("void f(bool b)\n"
13173                "{\n"
13174                "  if constexpr (b)\n"
13175                "  {\n"
13176                "    return;\n"
13177                "  }\n"
13178                "}\n",
13179                BreakBeforeBraceShortIfs);
13180   verifyFormat("void f(bool b)\n"
13181                "{\n"
13182                "  if CONSTEXPR (b)\n"
13183                "  {\n"
13184                "    return;\n"
13185                "  }\n"
13186                "}\n",
13187                BreakBeforeBraceShortIfs);
13188   verifyFormat("void f(bool b)\n"
13189                "{\n"
13190                "  if (b) return;\n"
13191                "}\n",
13192                BreakBeforeBraceShortIfs);
13193   verifyFormat("void f(bool b)\n"
13194                "{\n"
13195                "  if constexpr (b) return;\n"
13196                "}\n",
13197                BreakBeforeBraceShortIfs);
13198   verifyFormat("void f(bool b)\n"
13199                "{\n"
13200                "  if CONSTEXPR (b) return;\n"
13201                "}\n",
13202                BreakBeforeBraceShortIfs);
13203   verifyFormat("void f(bool b)\n"
13204                "{\n"
13205                "  while (b)\n"
13206                "  {\n"
13207                "    return;\n"
13208                "  }\n"
13209                "}\n",
13210                BreakBeforeBraceShortIfs);
13211 }
13212 
13213 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
13214   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
13215   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
13216 
13217   // Make a few changes to the style for testing purposes
13218   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
13219       FormatStyle::SFS_Empty;
13220   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
13221   WhitesmithsBraceStyle.ColumnLimit = 0;
13222 
13223   // FIXME: this test case can't decide whether there should be a blank line
13224   // after the ~D() line or not. It adds one if one doesn't exist in the test
13225   // and it removes the line if one exists.
13226   /*
13227   verifyFormat("class A;\n"
13228                "namespace B\n"
13229                "  {\n"
13230                "class C;\n"
13231                "// Comment\n"
13232                "class D\n"
13233                "  {\n"
13234                "public:\n"
13235                "  D();\n"
13236                "  ~D() {}\n"
13237                "private:\n"
13238                "  enum E\n"
13239                "    {\n"
13240                "    F\n"
13241                "    }\n"
13242                "  };\n"
13243                "  } // namespace B\n",
13244                WhitesmithsBraceStyle);
13245   */
13246 
13247   verifyFormat("namespace a\n"
13248                "  {\n"
13249                "class A\n"
13250                "  {\n"
13251                "  void f()\n"
13252                "    {\n"
13253                "    if (true)\n"
13254                "      {\n"
13255                "      a();\n"
13256                "      b();\n"
13257                "      }\n"
13258                "    }\n"
13259                "  void g()\n"
13260                "    {\n"
13261                "    return;\n"
13262                "    }\n"
13263                "  };\n"
13264                "struct B\n"
13265                "  {\n"
13266                "  int x;\n"
13267                "  };\n"
13268                "  } // namespace a",
13269                WhitesmithsBraceStyle);
13270 
13271   verifyFormat("void f()\n"
13272                "  {\n"
13273                "  if (true)\n"
13274                "    {\n"
13275                "    a();\n"
13276                "    }\n"
13277                "  else if (false)\n"
13278                "    {\n"
13279                "    b();\n"
13280                "    }\n"
13281                "  else\n"
13282                "    {\n"
13283                "    c();\n"
13284                "    }\n"
13285                "  }\n",
13286                WhitesmithsBraceStyle);
13287 
13288   verifyFormat("void f()\n"
13289                "  {\n"
13290                "  for (int i = 0; i < 10; ++i)\n"
13291                "    {\n"
13292                "    a();\n"
13293                "    }\n"
13294                "  while (false)\n"
13295                "    {\n"
13296                "    b();\n"
13297                "    }\n"
13298                "  do\n"
13299                "    {\n"
13300                "    c();\n"
13301                "    } while (false)\n"
13302                "  }\n",
13303                WhitesmithsBraceStyle);
13304 
13305   WhitesmithsBraceStyle.IndentCaseBlocks = true;
13306   verifyFormat("void switchTest1(int a)\n"
13307                "  {\n"
13308                "  switch (a)\n"
13309                "    {\n"
13310                "    case 2:\n"
13311                "      {\n"
13312                "      }\n"
13313                "    break;\n"
13314                "    }\n"
13315                "  }\n",
13316                WhitesmithsBraceStyle);
13317 
13318   verifyFormat("void switchTest2(int a)\n"
13319                "  {\n"
13320                "  switch (a)\n"
13321                "    {\n"
13322                "    case 0:\n"
13323                "    break;\n"
13324                "    case 1:\n"
13325                "      {\n"
13326                "      break;\n"
13327                "      }\n"
13328                "    case 2:\n"
13329                "      {\n"
13330                "      }\n"
13331                "    break;\n"
13332                "    default:\n"
13333                "    break;\n"
13334                "    }\n"
13335                "  }\n",
13336                WhitesmithsBraceStyle);
13337 
13338   verifyFormat("void switchTest3(int a)\n"
13339                "  {\n"
13340                "  switch (a)\n"
13341                "    {\n"
13342                "    case 0:\n"
13343                "      {\n"
13344                "      foo(x);\n"
13345                "      }\n"
13346                "    break;\n"
13347                "    default:\n"
13348                "      {\n"
13349                "      foo(1);\n"
13350                "      }\n"
13351                "    break;\n"
13352                "    }\n"
13353                "  }\n",
13354                WhitesmithsBraceStyle);
13355 
13356   WhitesmithsBraceStyle.IndentCaseBlocks = false;
13357 
13358   verifyFormat("void switchTest4(int a)\n"
13359                "  {\n"
13360                "  switch (a)\n"
13361                "    {\n"
13362                "    case 2:\n"
13363                "    {\n"
13364                "    }\n"
13365                "    break;\n"
13366                "    }\n"
13367                "  }\n",
13368                WhitesmithsBraceStyle);
13369 
13370   verifyFormat("void switchTest5(int a)\n"
13371                "  {\n"
13372                "  switch (a)\n"
13373                "    {\n"
13374                "    case 0:\n"
13375                "    break;\n"
13376                "    case 1:\n"
13377                "    {\n"
13378                "    foo();\n"
13379                "    break;\n"
13380                "    }\n"
13381                "    case 2:\n"
13382                "    {\n"
13383                "    }\n"
13384                "    break;\n"
13385                "    default:\n"
13386                "    break;\n"
13387                "    }\n"
13388                "  }\n",
13389                WhitesmithsBraceStyle);
13390 
13391   verifyFormat("void switchTest6(int a)\n"
13392                "  {\n"
13393                "  switch (a)\n"
13394                "    {\n"
13395                "    case 0:\n"
13396                "    {\n"
13397                "    foo(x);\n"
13398                "    }\n"
13399                "    break;\n"
13400                "    default:\n"
13401                "    {\n"
13402                "    foo(1);\n"
13403                "    }\n"
13404                "    break;\n"
13405                "    }\n"
13406                "  }\n",
13407                WhitesmithsBraceStyle);
13408 
13409   verifyFormat("enum X\n"
13410                "  {\n"
13411                "  Y = 0, // testing\n"
13412                "  }\n",
13413                WhitesmithsBraceStyle);
13414 
13415   verifyFormat("enum X\n"
13416                "  {\n"
13417                "  Y = 0\n"
13418                "  }\n",
13419                WhitesmithsBraceStyle);
13420   verifyFormat("enum X\n"
13421                "  {\n"
13422                "  Y = 0,\n"
13423                "  Z = 1\n"
13424                "  };\n",
13425                WhitesmithsBraceStyle);
13426 
13427   verifyFormat("@interface BSApplicationController ()\n"
13428                "  {\n"
13429                "@private\n"
13430                "  id _extraIvar;\n"
13431                "  }\n"
13432                "@end\n",
13433                WhitesmithsBraceStyle);
13434 
13435   verifyFormat("#ifdef _DEBUG\n"
13436                "int foo(int i = 0)\n"
13437                "#else\n"
13438                "int foo(int i = 5)\n"
13439                "#endif\n"
13440                "  {\n"
13441                "  return i;\n"
13442                "  }",
13443                WhitesmithsBraceStyle);
13444 
13445   verifyFormat("void foo() {}\n"
13446                "void bar()\n"
13447                "#ifdef _DEBUG\n"
13448                "  {\n"
13449                "  foo();\n"
13450                "  }\n"
13451                "#else\n"
13452                "  {\n"
13453                "  }\n"
13454                "#endif",
13455                WhitesmithsBraceStyle);
13456 
13457   verifyFormat("void foobar()\n"
13458                "  {\n"
13459                "  int i = 5;\n"
13460                "  }\n"
13461                "#ifdef _DEBUG\n"
13462                "void bar()\n"
13463                "  {\n"
13464                "  }\n"
13465                "#else\n"
13466                "void bar()\n"
13467                "  {\n"
13468                "  foobar();\n"
13469                "  }\n"
13470                "#endif",
13471                WhitesmithsBraceStyle);
13472 
13473   // This shouldn't affect ObjC blocks..
13474   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13475                "  // ...\n"
13476                "  int i;\n"
13477                "}];",
13478                WhitesmithsBraceStyle);
13479   verifyFormat("void (^block)(void) = ^{\n"
13480                "  // ...\n"
13481                "  int i;\n"
13482                "};",
13483                WhitesmithsBraceStyle);
13484   // .. or dict literals.
13485   verifyFormat("void f()\n"
13486                "  {\n"
13487                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13488                "  }",
13489                WhitesmithsBraceStyle);
13490 
13491   verifyFormat("int f()\n"
13492                "  { // comment\n"
13493                "  return 42;\n"
13494                "  }",
13495                WhitesmithsBraceStyle);
13496 
13497   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13498   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13499       FormatStyle::SIS_Always;
13500   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13501   verifyFormat("void f(bool b)\n"
13502                "  {\n"
13503                "  if (b)\n"
13504                "    {\n"
13505                "    return;\n"
13506                "    }\n"
13507                "  }\n",
13508                BreakBeforeBraceShortIfs);
13509   verifyFormat("void f(bool b)\n"
13510                "  {\n"
13511                "  if (b) return;\n"
13512                "  }\n",
13513                BreakBeforeBraceShortIfs);
13514   verifyFormat("void f(bool b)\n"
13515                "  {\n"
13516                "  while (b)\n"
13517                "    {\n"
13518                "    return;\n"
13519                "    }\n"
13520                "  }\n",
13521                BreakBeforeBraceShortIfs);
13522 }
13523 
13524 TEST_F(FormatTest, GNUBraceBreaking) {
13525   FormatStyle GNUBraceStyle = getLLVMStyle();
13526   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13527   verifyFormat("namespace a\n"
13528                "{\n"
13529                "class A\n"
13530                "{\n"
13531                "  void f()\n"
13532                "  {\n"
13533                "    int a;\n"
13534                "    {\n"
13535                "      int b;\n"
13536                "    }\n"
13537                "    if (true)\n"
13538                "      {\n"
13539                "        a();\n"
13540                "        b();\n"
13541                "      }\n"
13542                "  }\n"
13543                "  void g() { return; }\n"
13544                "}\n"
13545                "} // namespace a",
13546                GNUBraceStyle);
13547 
13548   verifyFormat("void f()\n"
13549                "{\n"
13550                "  if (true)\n"
13551                "    {\n"
13552                "      a();\n"
13553                "    }\n"
13554                "  else if (false)\n"
13555                "    {\n"
13556                "      b();\n"
13557                "    }\n"
13558                "  else\n"
13559                "    {\n"
13560                "      c();\n"
13561                "    }\n"
13562                "}\n",
13563                GNUBraceStyle);
13564 
13565   verifyFormat("void f()\n"
13566                "{\n"
13567                "  for (int i = 0; i < 10; ++i)\n"
13568                "    {\n"
13569                "      a();\n"
13570                "    }\n"
13571                "  while (false)\n"
13572                "    {\n"
13573                "      b();\n"
13574                "    }\n"
13575                "  do\n"
13576                "    {\n"
13577                "      c();\n"
13578                "    }\n"
13579                "  while (false);\n"
13580                "}\n",
13581                GNUBraceStyle);
13582 
13583   verifyFormat("void f(int a)\n"
13584                "{\n"
13585                "  switch (a)\n"
13586                "    {\n"
13587                "    case 0:\n"
13588                "      break;\n"
13589                "    case 1:\n"
13590                "      {\n"
13591                "        break;\n"
13592                "      }\n"
13593                "    case 2:\n"
13594                "      {\n"
13595                "      }\n"
13596                "      break;\n"
13597                "    default:\n"
13598                "      break;\n"
13599                "    }\n"
13600                "}\n",
13601                GNUBraceStyle);
13602 
13603   verifyFormat("enum X\n"
13604                "{\n"
13605                "  Y = 0,\n"
13606                "}\n",
13607                GNUBraceStyle);
13608 
13609   verifyFormat("@interface BSApplicationController ()\n"
13610                "{\n"
13611                "@private\n"
13612                "  id _extraIvar;\n"
13613                "}\n"
13614                "@end\n",
13615                GNUBraceStyle);
13616 
13617   verifyFormat("#ifdef _DEBUG\n"
13618                "int foo(int i = 0)\n"
13619                "#else\n"
13620                "int foo(int i = 5)\n"
13621                "#endif\n"
13622                "{\n"
13623                "  return i;\n"
13624                "}",
13625                GNUBraceStyle);
13626 
13627   verifyFormat("void foo() {}\n"
13628                "void bar()\n"
13629                "#ifdef _DEBUG\n"
13630                "{\n"
13631                "  foo();\n"
13632                "}\n"
13633                "#else\n"
13634                "{\n"
13635                "}\n"
13636                "#endif",
13637                GNUBraceStyle);
13638 
13639   verifyFormat("void foobar() { int i = 5; }\n"
13640                "#ifdef _DEBUG\n"
13641                "void bar() {}\n"
13642                "#else\n"
13643                "void bar() { foobar(); }\n"
13644                "#endif",
13645                GNUBraceStyle);
13646 }
13647 
13648 TEST_F(FormatTest, WebKitBraceBreaking) {
13649   FormatStyle WebKitBraceStyle = getLLVMStyle();
13650   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13651   WebKitBraceStyle.FixNamespaceComments = false;
13652   verifyFormat("namespace a {\n"
13653                "class A {\n"
13654                "  void f()\n"
13655                "  {\n"
13656                "    if (true) {\n"
13657                "      a();\n"
13658                "      b();\n"
13659                "    }\n"
13660                "  }\n"
13661                "  void g() { return; }\n"
13662                "};\n"
13663                "enum E {\n"
13664                "  A,\n"
13665                "  // foo\n"
13666                "  B,\n"
13667                "  C\n"
13668                "};\n"
13669                "struct B {\n"
13670                "  int x;\n"
13671                "};\n"
13672                "}\n",
13673                WebKitBraceStyle);
13674   verifyFormat("struct S {\n"
13675                "  int Type;\n"
13676                "  union {\n"
13677                "    int x;\n"
13678                "    double y;\n"
13679                "  } Value;\n"
13680                "  class C {\n"
13681                "    MyFavoriteType Value;\n"
13682                "  } Class;\n"
13683                "};\n",
13684                WebKitBraceStyle);
13685 }
13686 
13687 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13688   verifyFormat("void f() {\n"
13689                "  try {\n"
13690                "  } catch (const Exception &e) {\n"
13691                "  }\n"
13692                "}\n",
13693                getLLVMStyle());
13694 }
13695 
13696 TEST_F(FormatTest, UnderstandsPragmas) {
13697   verifyFormat("#pragma omp reduction(| : var)");
13698   verifyFormat("#pragma omp reduction(+ : var)");
13699 
13700   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13701             "(including parentheses).",
13702             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13703                    "(including parentheses)."));
13704 }
13705 
13706 TEST_F(FormatTest, UnderstandPragmaOption) {
13707   verifyFormat("#pragma option -C -A");
13708 
13709   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13710 }
13711 
13712 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13713   FormatStyle Style = getLLVMStyle();
13714   Style.ColumnLimit = 20;
13715 
13716   // See PR41213
13717   EXPECT_EQ("/*\n"
13718             " *\t9012345\n"
13719             " * /8901\n"
13720             " */",
13721             format("/*\n"
13722                    " *\t9012345 /8901\n"
13723                    " */",
13724                    Style));
13725   EXPECT_EQ("/*\n"
13726             " *345678\n"
13727             " *\t/8901\n"
13728             " */",
13729             format("/*\n"
13730                    " *345678\t/8901\n"
13731                    " */",
13732                    Style));
13733 
13734   verifyFormat("int a; // the\n"
13735                "       // comment",
13736                Style);
13737   EXPECT_EQ("int a; /* first line\n"
13738             "        * second\n"
13739             "        * line third\n"
13740             "        * line\n"
13741             "        */",
13742             format("int a; /* first line\n"
13743                    "        * second\n"
13744                    "        * line third\n"
13745                    "        * line\n"
13746                    "        */",
13747                    Style));
13748   EXPECT_EQ("int a; // first line\n"
13749             "       // second\n"
13750             "       // line third\n"
13751             "       // line",
13752             format("int a; // first line\n"
13753                    "       // second line\n"
13754                    "       // third line",
13755                    Style));
13756 
13757   Style.PenaltyExcessCharacter = 90;
13758   verifyFormat("int a; // the comment", Style);
13759   EXPECT_EQ("int a; // the comment\n"
13760             "       // aaa",
13761             format("int a; // the comment aaa", Style));
13762   EXPECT_EQ("int a; /* first line\n"
13763             "        * second line\n"
13764             "        * third line\n"
13765             "        */",
13766             format("int a; /* first line\n"
13767                    "        * second line\n"
13768                    "        * third line\n"
13769                    "        */",
13770                    Style));
13771   EXPECT_EQ("int a; // first line\n"
13772             "       // second line\n"
13773             "       // third line",
13774             format("int a; // first line\n"
13775                    "       // second line\n"
13776                    "       // third line",
13777                    Style));
13778   // FIXME: Investigate why this is not getting the same layout as the test
13779   // above.
13780   EXPECT_EQ("int a; /* first line\n"
13781             "        * second line\n"
13782             "        * third line\n"
13783             "        */",
13784             format("int a; /* first line second line third line"
13785                    "\n*/",
13786                    Style));
13787 
13788   EXPECT_EQ("// foo bar baz bazfoo\n"
13789             "// foo bar foo bar\n",
13790             format("// foo bar baz bazfoo\n"
13791                    "// foo bar foo           bar\n",
13792                    Style));
13793   EXPECT_EQ("// foo bar baz bazfoo\n"
13794             "// foo bar foo bar\n",
13795             format("// foo bar baz      bazfoo\n"
13796                    "// foo            bar foo bar\n",
13797                    Style));
13798 
13799   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13800   // next one.
13801   EXPECT_EQ("// foo bar baz bazfoo\n"
13802             "// bar foo bar\n",
13803             format("// foo bar baz      bazfoo bar\n"
13804                    "// foo            bar\n",
13805                    Style));
13806 
13807   EXPECT_EQ("// foo bar baz bazfoo\n"
13808             "// foo bar baz bazfoo\n"
13809             "// bar foo bar\n",
13810             format("// foo bar baz      bazfoo\n"
13811                    "// foo bar baz      bazfoo bar\n"
13812                    "// foo bar\n",
13813                    Style));
13814 
13815   EXPECT_EQ("// foo bar baz bazfoo\n"
13816             "// foo bar baz bazfoo\n"
13817             "// bar foo bar\n",
13818             format("// foo bar baz      bazfoo\n"
13819                    "// foo bar baz      bazfoo bar\n"
13820                    "// foo           bar\n",
13821                    Style));
13822 
13823   // Make sure we do not keep protruding characters if strict mode reflow is
13824   // cheaper than keeping protruding characters.
13825   Style.ColumnLimit = 21;
13826   EXPECT_EQ(
13827       "// foo foo foo foo\n"
13828       "// foo foo foo foo\n"
13829       "// foo foo foo foo\n",
13830       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13831 
13832   EXPECT_EQ("int a = /* long block\n"
13833             "           comment */\n"
13834             "    42;",
13835             format("int a = /* long block comment */ 42;", Style));
13836 }
13837 
13838 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13839   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13840   EXPECT_EQ(Styles[0], Styles[i])                                              \
13841       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13842 
13843 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13844   SmallVector<FormatStyle, 3> Styles;
13845   Styles.resize(3);
13846 
13847   Styles[0] = getLLVMStyle();
13848   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13849   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13850   EXPECT_ALL_STYLES_EQUAL(Styles);
13851 
13852   Styles[0] = getGoogleStyle();
13853   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13854   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13855   EXPECT_ALL_STYLES_EQUAL(Styles);
13856 
13857   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13858   EXPECT_TRUE(
13859       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13860   EXPECT_TRUE(
13861       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13862   EXPECT_ALL_STYLES_EQUAL(Styles);
13863 
13864   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13865   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13866   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13867   EXPECT_ALL_STYLES_EQUAL(Styles);
13868 
13869   Styles[0] = getMozillaStyle();
13870   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13871   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13872   EXPECT_ALL_STYLES_EQUAL(Styles);
13873 
13874   Styles[0] = getWebKitStyle();
13875   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13876   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13877   EXPECT_ALL_STYLES_EQUAL(Styles);
13878 
13879   Styles[0] = getGNUStyle();
13880   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13881   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13882   EXPECT_ALL_STYLES_EQUAL(Styles);
13883 
13884   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13885 }
13886 
13887 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13888   SmallVector<FormatStyle, 8> Styles;
13889   Styles.resize(2);
13890 
13891   Styles[0] = getGoogleStyle();
13892   Styles[1] = getLLVMStyle();
13893   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13894   EXPECT_ALL_STYLES_EQUAL(Styles);
13895 
13896   Styles.resize(5);
13897   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13898   Styles[1] = getLLVMStyle();
13899   Styles[1].Language = FormatStyle::LK_JavaScript;
13900   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13901 
13902   Styles[2] = getLLVMStyle();
13903   Styles[2].Language = FormatStyle::LK_JavaScript;
13904   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13905                                   "BasedOnStyle: Google",
13906                                   &Styles[2])
13907                    .value());
13908 
13909   Styles[3] = getLLVMStyle();
13910   Styles[3].Language = FormatStyle::LK_JavaScript;
13911   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13912                                   "Language: JavaScript",
13913                                   &Styles[3])
13914                    .value());
13915 
13916   Styles[4] = getLLVMStyle();
13917   Styles[4].Language = FormatStyle::LK_JavaScript;
13918   EXPECT_EQ(0, parseConfiguration("---\n"
13919                                   "BasedOnStyle: LLVM\n"
13920                                   "IndentWidth: 123\n"
13921                                   "---\n"
13922                                   "BasedOnStyle: Google\n"
13923                                   "Language: JavaScript",
13924                                   &Styles[4])
13925                    .value());
13926   EXPECT_ALL_STYLES_EQUAL(Styles);
13927 }
13928 
13929 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
13930   Style.FIELD = false;                                                         \
13931   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
13932   EXPECT_TRUE(Style.FIELD);                                                    \
13933   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
13934   EXPECT_FALSE(Style.FIELD);
13935 
13936 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
13937 
13938 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
13939   Style.STRUCT.FIELD = false;                                                  \
13940   EXPECT_EQ(0,                                                                 \
13941             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
13942                 .value());                                                     \
13943   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
13944   EXPECT_EQ(0,                                                                 \
13945             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
13946                 .value());                                                     \
13947   EXPECT_FALSE(Style.STRUCT.FIELD);
13948 
13949 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
13950   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
13951 
13952 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
13953   EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!";          \
13954   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
13955   EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
13956 
13957 TEST_F(FormatTest, ParsesConfigurationBools) {
13958   FormatStyle Style = {};
13959   Style.Language = FormatStyle::LK_Cpp;
13960   CHECK_PARSE_BOOL(AlignTrailingComments);
13961   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
13962   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
13963   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
13964   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
13965   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
13966   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
13967   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
13968   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
13969   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
13970   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
13971   CHECK_PARSE_BOOL(BinPackArguments);
13972   CHECK_PARSE_BOOL(BinPackParameters);
13973   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
13974   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
13975   CHECK_PARSE_BOOL(BreakStringLiterals);
13976   CHECK_PARSE_BOOL(CompactNamespaces);
13977   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
13978   CHECK_PARSE_BOOL(DeriveLineEnding);
13979   CHECK_PARSE_BOOL(DerivePointerAlignment);
13980   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
13981   CHECK_PARSE_BOOL(DisableFormat);
13982   CHECK_PARSE_BOOL(IndentCaseLabels);
13983   CHECK_PARSE_BOOL(IndentCaseBlocks);
13984   CHECK_PARSE_BOOL(IndentGotoLabels);
13985   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
13986   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
13987   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
13988   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
13989   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
13990   CHECK_PARSE_BOOL(ReflowComments);
13991   CHECK_PARSE_BOOL(SortIncludes);
13992   CHECK_PARSE_BOOL(SortUsingDeclarations);
13993   CHECK_PARSE_BOOL(SpacesInParentheses);
13994   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
13995   CHECK_PARSE_BOOL(SpacesInAngles);
13996   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
13997   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
13998   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
13999   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
14000   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
14001   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
14002   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
14003   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
14004   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
14005   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
14006   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
14007   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
14008   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
14009   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
14010   CHECK_PARSE_BOOL(UseCRLF);
14011 
14012   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
14013   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
14014   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
14015   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
14016   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
14017   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
14018   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
14019   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
14020   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
14021   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
14022   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
14023   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
14024   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
14025   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
14026   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
14027   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
14028   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
14029 }
14030 
14031 #undef CHECK_PARSE_BOOL
14032 
14033 TEST_F(FormatTest, ParsesConfiguration) {
14034   FormatStyle Style = {};
14035   Style.Language = FormatStyle::LK_Cpp;
14036   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
14037   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
14038               ConstructorInitializerIndentWidth, 1234u);
14039   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
14040   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
14041   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
14042   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
14043   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
14044               PenaltyBreakBeforeFirstCallParameter, 1234u);
14045   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
14046               PenaltyBreakTemplateDeclaration, 1234u);
14047   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
14048   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
14049               PenaltyReturnTypeOnItsOwnLine, 1234u);
14050   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
14051               SpacesBeforeTrailingComments, 1234u);
14052   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
14053   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
14054   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
14055 
14056   Style.PointerAlignment = FormatStyle::PAS_Middle;
14057   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
14058               FormatStyle::PAS_Left);
14059   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
14060               FormatStyle::PAS_Right);
14061   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
14062               FormatStyle::PAS_Middle);
14063   // For backward compatibility:
14064   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
14065               FormatStyle::PAS_Left);
14066   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
14067               FormatStyle::PAS_Right);
14068   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
14069               FormatStyle::PAS_Middle);
14070 
14071   Style.Standard = FormatStyle::LS_Auto;
14072   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
14073   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
14074   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
14075   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
14076   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
14077   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
14078   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
14079   // Legacy aliases:
14080   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
14081   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
14082   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
14083   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
14084 
14085   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
14086   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
14087               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
14088   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
14089               FormatStyle::BOS_None);
14090   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
14091               FormatStyle::BOS_All);
14092   // For backward compatibility:
14093   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
14094               FormatStyle::BOS_None);
14095   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
14096               FormatStyle::BOS_All);
14097 
14098   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
14099   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
14100               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14101   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
14102               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
14103   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
14104               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
14105   // For backward compatibility:
14106   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
14107               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14108 
14109   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
14110   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
14111               FormatStyle::BILS_BeforeComma);
14112   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
14113               FormatStyle::BILS_AfterColon);
14114   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
14115               FormatStyle::BILS_BeforeColon);
14116   // For backward compatibility:
14117   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
14118               FormatStyle::BILS_BeforeComma);
14119 
14120   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14121   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
14122               FormatStyle::BAS_Align);
14123   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
14124               FormatStyle::BAS_DontAlign);
14125   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
14126               FormatStyle::BAS_AlwaysBreak);
14127   // For backward compatibility:
14128   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
14129               FormatStyle::BAS_DontAlign);
14130   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
14131               FormatStyle::BAS_Align);
14132 
14133   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
14134   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
14135               FormatStyle::ENAS_DontAlign);
14136   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
14137               FormatStyle::ENAS_Left);
14138   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
14139               FormatStyle::ENAS_Right);
14140   // For backward compatibility:
14141   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
14142               FormatStyle::ENAS_Left);
14143   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
14144               FormatStyle::ENAS_Right);
14145 
14146   Style.AlignOperands = FormatStyle::OAS_Align;
14147   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
14148               FormatStyle::OAS_DontAlign);
14149   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
14150   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
14151               FormatStyle::OAS_AlignAfterOperator);
14152   // For backward compatibility:
14153   CHECK_PARSE("AlignOperands: false", AlignOperands,
14154               FormatStyle::OAS_DontAlign);
14155   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
14156 
14157   Style.UseTab = FormatStyle::UT_ForIndentation;
14158   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
14159   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
14160   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
14161   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
14162               FormatStyle::UT_ForContinuationAndIndentation);
14163   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
14164               FormatStyle::UT_AlignWithSpaces);
14165   // For backward compatibility:
14166   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
14167   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
14168 
14169   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
14170   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
14171               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14172   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
14173               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
14174   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
14175               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14176   // For backward compatibility:
14177   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
14178               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14179   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
14180               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14181 
14182   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
14183   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
14184               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14185   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
14186               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
14187   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
14188               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
14189   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
14190               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14191   // For backward compatibility:
14192   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
14193               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14194   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
14195               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14196 
14197   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
14198   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
14199               FormatStyle::SBPO_Never);
14200   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
14201               FormatStyle::SBPO_Always);
14202   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
14203               FormatStyle::SBPO_ControlStatements);
14204   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
14205               FormatStyle::SBPO_NonEmptyParentheses);
14206   // For backward compatibility:
14207   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
14208               FormatStyle::SBPO_Never);
14209   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
14210               FormatStyle::SBPO_ControlStatements);
14211 
14212   Style.ColumnLimit = 123;
14213   FormatStyle BaseStyle = getLLVMStyle();
14214   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
14215   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
14216 
14217   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
14218   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
14219               FormatStyle::BS_Attach);
14220   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
14221               FormatStyle::BS_Linux);
14222   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
14223               FormatStyle::BS_Mozilla);
14224   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
14225               FormatStyle::BS_Stroustrup);
14226   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
14227               FormatStyle::BS_Allman);
14228   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
14229               FormatStyle::BS_Whitesmiths);
14230   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
14231   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
14232               FormatStyle::BS_WebKit);
14233   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
14234               FormatStyle::BS_Custom);
14235 
14236   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
14237   CHECK_PARSE("BraceWrapping:\n"
14238               "  AfterControlStatement: MultiLine",
14239               BraceWrapping.AfterControlStatement,
14240               FormatStyle::BWACS_MultiLine);
14241   CHECK_PARSE("BraceWrapping:\n"
14242               "  AfterControlStatement: Always",
14243               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14244   CHECK_PARSE("BraceWrapping:\n"
14245               "  AfterControlStatement: Never",
14246               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14247   // For backward compatibility:
14248   CHECK_PARSE("BraceWrapping:\n"
14249               "  AfterControlStatement: true",
14250               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14251   CHECK_PARSE("BraceWrapping:\n"
14252               "  AfterControlStatement: false",
14253               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14254 
14255   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
14256   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
14257               FormatStyle::RTBS_None);
14258   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
14259               FormatStyle::RTBS_All);
14260   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
14261               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
14262   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
14263               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
14264   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
14265               AlwaysBreakAfterReturnType,
14266               FormatStyle::RTBS_TopLevelDefinitions);
14267 
14268   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
14269   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
14270               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
14271   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
14272               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14273   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
14274               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14275   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
14276               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14277   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
14278               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14279 
14280   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
14281   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
14282               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
14283   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
14284               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
14285   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
14286               AlwaysBreakAfterDefinitionReturnType,
14287               FormatStyle::DRTBS_TopLevel);
14288 
14289   Style.NamespaceIndentation = FormatStyle::NI_All;
14290   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
14291               FormatStyle::NI_None);
14292   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
14293               FormatStyle::NI_Inner);
14294   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
14295               FormatStyle::NI_All);
14296 
14297   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
14298   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
14299               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14300   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
14301               AllowShortIfStatementsOnASingleLine,
14302               FormatStyle::SIS_WithoutElse);
14303   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
14304               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
14305   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
14306               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14307   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
14308               AllowShortIfStatementsOnASingleLine,
14309               FormatStyle::SIS_WithoutElse);
14310 
14311   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
14312   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
14313               FormatStyle::IEBS_AfterExternBlock);
14314   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
14315               FormatStyle::IEBS_Indent);
14316   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
14317               FormatStyle::IEBS_NoIndent);
14318   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
14319               FormatStyle::IEBS_Indent);
14320   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
14321               FormatStyle::IEBS_NoIndent);
14322 
14323   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
14324   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
14325               FormatStyle::BFCS_Both);
14326   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
14327               FormatStyle::BFCS_None);
14328   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
14329               FormatStyle::BFCS_Before);
14330   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
14331               FormatStyle::BFCS_After);
14332 
14333   Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
14334   CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
14335               FormatStyle::SJSIO_After);
14336   CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
14337               FormatStyle::SJSIO_Before);
14338 
14339   // FIXME: This is required because parsing a configuration simply overwrites
14340   // the first N elements of the list instead of resetting it.
14341   Style.ForEachMacros.clear();
14342   std::vector<std::string> BoostForeach;
14343   BoostForeach.push_back("BOOST_FOREACH");
14344   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
14345   std::vector<std::string> BoostAndQForeach;
14346   BoostAndQForeach.push_back("BOOST_FOREACH");
14347   BoostAndQForeach.push_back("Q_FOREACH");
14348   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
14349               BoostAndQForeach);
14350 
14351   Style.AttributeMacros.clear();
14352   CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
14353               std::vector<std::string>{"__capability"});
14354   CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
14355               std::vector<std::string>({"attr1", "attr2"}));
14356 
14357   Style.StatementMacros.clear();
14358   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
14359               std::vector<std::string>{"QUNUSED"});
14360   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
14361               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
14362 
14363   Style.NamespaceMacros.clear();
14364   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
14365               std::vector<std::string>{"TESTSUITE"});
14366   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
14367               std::vector<std::string>({"TESTSUITE", "SUITE"}));
14368 
14369   Style.WhitespaceSensitiveMacros.clear();
14370   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
14371               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14372   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
14373               WhitespaceSensitiveMacros,
14374               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14375   Style.WhitespaceSensitiveMacros.clear();
14376   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
14377               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14378   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
14379               WhitespaceSensitiveMacros,
14380               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14381 
14382   Style.IncludeStyle.IncludeCategories.clear();
14383   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
14384       {"abc/.*", 2, 0}, {".*", 1, 0}};
14385   CHECK_PARSE("IncludeCategories:\n"
14386               "  - Regex: abc/.*\n"
14387               "    Priority: 2\n"
14388               "  - Regex: .*\n"
14389               "    Priority: 1",
14390               IncludeStyle.IncludeCategories, ExpectedCategories);
14391   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
14392               "abc$");
14393   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
14394               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
14395 
14396   Style.RawStringFormats.clear();
14397   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
14398       {
14399           FormatStyle::LK_TextProto,
14400           {"pb", "proto"},
14401           {"PARSE_TEXT_PROTO"},
14402           /*CanonicalDelimiter=*/"",
14403           "llvm",
14404       },
14405       {
14406           FormatStyle::LK_Cpp,
14407           {"cc", "cpp"},
14408           {"C_CODEBLOCK", "CPPEVAL"},
14409           /*CanonicalDelimiter=*/"cc",
14410           /*BasedOnStyle=*/"",
14411       },
14412   };
14413 
14414   CHECK_PARSE("RawStringFormats:\n"
14415               "  - Language: TextProto\n"
14416               "    Delimiters:\n"
14417               "      - 'pb'\n"
14418               "      - 'proto'\n"
14419               "    EnclosingFunctions:\n"
14420               "      - 'PARSE_TEXT_PROTO'\n"
14421               "    BasedOnStyle: llvm\n"
14422               "  - Language: Cpp\n"
14423               "    Delimiters:\n"
14424               "      - 'cc'\n"
14425               "      - 'cpp'\n"
14426               "    EnclosingFunctions:\n"
14427               "      - 'C_CODEBLOCK'\n"
14428               "      - 'CPPEVAL'\n"
14429               "    CanonicalDelimiter: 'cc'",
14430               RawStringFormats, ExpectedRawStringFormats);
14431 }
14432 
14433 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14434   FormatStyle Style = {};
14435   Style.Language = FormatStyle::LK_Cpp;
14436   CHECK_PARSE("Language: Cpp\n"
14437               "IndentWidth: 12",
14438               IndentWidth, 12u);
14439   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14440                                "IndentWidth: 34",
14441                                &Style),
14442             ParseError::Unsuitable);
14443   FormatStyle BinPackedTCS = {};
14444   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14445   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14446                                "InsertTrailingCommas: Wrapped",
14447                                &BinPackedTCS),
14448             ParseError::BinPackTrailingCommaConflict);
14449   EXPECT_EQ(12u, Style.IndentWidth);
14450   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14451   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14452 
14453   Style.Language = FormatStyle::LK_JavaScript;
14454   CHECK_PARSE("Language: JavaScript\n"
14455               "IndentWidth: 12",
14456               IndentWidth, 12u);
14457   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14458   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14459                                "IndentWidth: 34",
14460                                &Style),
14461             ParseError::Unsuitable);
14462   EXPECT_EQ(23u, Style.IndentWidth);
14463   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14464   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14465 
14466   CHECK_PARSE("BasedOnStyle: LLVM\n"
14467               "IndentWidth: 67",
14468               IndentWidth, 67u);
14469 
14470   CHECK_PARSE("---\n"
14471               "Language: JavaScript\n"
14472               "IndentWidth: 12\n"
14473               "---\n"
14474               "Language: Cpp\n"
14475               "IndentWidth: 34\n"
14476               "...\n",
14477               IndentWidth, 12u);
14478 
14479   Style.Language = FormatStyle::LK_Cpp;
14480   CHECK_PARSE("---\n"
14481               "Language: JavaScript\n"
14482               "IndentWidth: 12\n"
14483               "---\n"
14484               "Language: Cpp\n"
14485               "IndentWidth: 34\n"
14486               "...\n",
14487               IndentWidth, 34u);
14488   CHECK_PARSE("---\n"
14489               "IndentWidth: 78\n"
14490               "---\n"
14491               "Language: JavaScript\n"
14492               "IndentWidth: 56\n"
14493               "...\n",
14494               IndentWidth, 78u);
14495 
14496   Style.ColumnLimit = 123;
14497   Style.IndentWidth = 234;
14498   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14499   Style.TabWidth = 345;
14500   EXPECT_FALSE(parseConfiguration("---\n"
14501                                   "IndentWidth: 456\n"
14502                                   "BreakBeforeBraces: Allman\n"
14503                                   "---\n"
14504                                   "Language: JavaScript\n"
14505                                   "IndentWidth: 111\n"
14506                                   "TabWidth: 111\n"
14507                                   "---\n"
14508                                   "Language: Cpp\n"
14509                                   "BreakBeforeBraces: Stroustrup\n"
14510                                   "TabWidth: 789\n"
14511                                   "...\n",
14512                                   &Style));
14513   EXPECT_EQ(123u, Style.ColumnLimit);
14514   EXPECT_EQ(456u, Style.IndentWidth);
14515   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14516   EXPECT_EQ(789u, Style.TabWidth);
14517 
14518   EXPECT_EQ(parseConfiguration("---\n"
14519                                "Language: JavaScript\n"
14520                                "IndentWidth: 56\n"
14521                                "---\n"
14522                                "IndentWidth: 78\n"
14523                                "...\n",
14524                                &Style),
14525             ParseError::Error);
14526   EXPECT_EQ(parseConfiguration("---\n"
14527                                "Language: JavaScript\n"
14528                                "IndentWidth: 56\n"
14529                                "---\n"
14530                                "Language: JavaScript\n"
14531                                "IndentWidth: 78\n"
14532                                "...\n",
14533                                &Style),
14534             ParseError::Error);
14535 
14536   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14537 }
14538 
14539 #undef CHECK_PARSE
14540 
14541 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14542   FormatStyle Style = {};
14543   Style.Language = FormatStyle::LK_JavaScript;
14544   Style.BreakBeforeTernaryOperators = true;
14545   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14546   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14547 
14548   Style.BreakBeforeTernaryOperators = true;
14549   EXPECT_EQ(0, parseConfiguration("---\n"
14550                                   "BasedOnStyle: Google\n"
14551                                   "---\n"
14552                                   "Language: JavaScript\n"
14553                                   "IndentWidth: 76\n"
14554                                   "...\n",
14555                                   &Style)
14556                    .value());
14557   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14558   EXPECT_EQ(76u, Style.IndentWidth);
14559   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14560 }
14561 
14562 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14563   FormatStyle Style = getLLVMStyle();
14564   std::string YAML = configurationAsText(Style);
14565   FormatStyle ParsedStyle = {};
14566   ParsedStyle.Language = FormatStyle::LK_Cpp;
14567   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14568   EXPECT_EQ(Style, ParsedStyle);
14569 }
14570 
14571 TEST_F(FormatTest, WorksFor8bitEncodings) {
14572   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14573             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14574             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14575             "\"\xef\xee\xf0\xf3...\"",
14576             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14577                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14578                    "\xef\xee\xf0\xf3...\"",
14579                    getLLVMStyleWithColumns(12)));
14580 }
14581 
14582 TEST_F(FormatTest, HandlesUTF8BOM) {
14583   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14584   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14585             format("\xef\xbb\xbf#include <iostream>"));
14586   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14587             format("\xef\xbb\xbf\n#include <iostream>"));
14588 }
14589 
14590 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14591 #if !defined(_MSC_VER)
14592 
14593 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14594   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14595                getLLVMStyleWithColumns(35));
14596   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14597                getLLVMStyleWithColumns(31));
14598   verifyFormat("// Однажды в студёную зимнюю пору...",
14599                getLLVMStyleWithColumns(36));
14600   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14601   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14602                getLLVMStyleWithColumns(39));
14603   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14604                getLLVMStyleWithColumns(35));
14605 }
14606 
14607 TEST_F(FormatTest, SplitsUTF8Strings) {
14608   // Non-printable characters' width is currently considered to be the length in
14609   // bytes in UTF8. The characters can be displayed in very different manner
14610   // (zero-width, single width with a substitution glyph, expanded to their code
14611   // (e.g. "<8d>"), so there's no single correct way to handle them.
14612   EXPECT_EQ("\"aaaaÄ\"\n"
14613             "\"\xc2\x8d\";",
14614             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14615   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14616             "\"\xc2\x8d\";",
14617             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14618   EXPECT_EQ("\"Однажды, в \"\n"
14619             "\"студёную \"\n"
14620             "\"зимнюю \"\n"
14621             "\"пору,\"",
14622             format("\"Однажды, в студёную зимнюю пору,\"",
14623                    getLLVMStyleWithColumns(13)));
14624   EXPECT_EQ(
14625       "\"一 二 三 \"\n"
14626       "\"四 五六 \"\n"
14627       "\"七 八 九 \"\n"
14628       "\"十\"",
14629       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14630   EXPECT_EQ("\"一\t\"\n"
14631             "\"二 \t\"\n"
14632             "\"三 四 \"\n"
14633             "\"五\t\"\n"
14634             "\"六 \t\"\n"
14635             "\"七 \"\n"
14636             "\"八九十\tqq\"",
14637             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14638                    getLLVMStyleWithColumns(11)));
14639 
14640   // UTF8 character in an escape sequence.
14641   EXPECT_EQ("\"aaaaaa\"\n"
14642             "\"\\\xC2\x8D\"",
14643             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14644 }
14645 
14646 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14647   EXPECT_EQ("const char *sssss =\n"
14648             "    \"一二三四五六七八\\\n"
14649             " 九 十\";",
14650             format("const char *sssss = \"一二三四五六七八\\\n"
14651                    " 九 十\";",
14652                    getLLVMStyleWithColumns(30)));
14653 }
14654 
14655 TEST_F(FormatTest, SplitsUTF8LineComments) {
14656   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14657             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14658   EXPECT_EQ("// Я из лесу\n"
14659             "// вышел; был\n"
14660             "// сильный\n"
14661             "// мороз.",
14662             format("// Я из лесу вышел; был сильный мороз.",
14663                    getLLVMStyleWithColumns(13)));
14664   EXPECT_EQ("// 一二三\n"
14665             "// 四五六七\n"
14666             "// 八  九\n"
14667             "// 十",
14668             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14669 }
14670 
14671 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14672   EXPECT_EQ("/* Гляжу,\n"
14673             " * поднимается\n"
14674             " * медленно в\n"
14675             " * гору\n"
14676             " * Лошадка,\n"
14677             " * везущая\n"
14678             " * хворосту\n"
14679             " * воз. */",
14680             format("/* Гляжу, поднимается медленно в гору\n"
14681                    " * Лошадка, везущая хворосту воз. */",
14682                    getLLVMStyleWithColumns(13)));
14683   EXPECT_EQ(
14684       "/* 一二三\n"
14685       " * 四五六七\n"
14686       " * 八  九\n"
14687       " * 十  */",
14688       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14689   EXPECT_EQ("/* �������� ��������\n"
14690             " * ��������\n"
14691             " * ������-�� */",
14692             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14693 }
14694 
14695 #endif // _MSC_VER
14696 
14697 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14698   FormatStyle Style = getLLVMStyle();
14699 
14700   Style.ConstructorInitializerIndentWidth = 4;
14701   verifyFormat(
14702       "SomeClass::Constructor()\n"
14703       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14704       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14705       Style);
14706 
14707   Style.ConstructorInitializerIndentWidth = 2;
14708   verifyFormat(
14709       "SomeClass::Constructor()\n"
14710       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14711       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14712       Style);
14713 
14714   Style.ConstructorInitializerIndentWidth = 0;
14715   verifyFormat(
14716       "SomeClass::Constructor()\n"
14717       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14718       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14719       Style);
14720   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14721   verifyFormat(
14722       "SomeLongTemplateVariableName<\n"
14723       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14724       Style);
14725   verifyFormat("bool smaller = 1 < "
14726                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14727                "                       "
14728                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14729                Style);
14730 
14731   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14732   verifyFormat("SomeClass::Constructor() :\n"
14733                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14734                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14735                Style);
14736 }
14737 
14738 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14739   FormatStyle Style = getLLVMStyle();
14740   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14741   Style.ConstructorInitializerIndentWidth = 4;
14742   verifyFormat("SomeClass::Constructor()\n"
14743                "    : a(a)\n"
14744                "    , b(b)\n"
14745                "    , c(c) {}",
14746                Style);
14747   verifyFormat("SomeClass::Constructor()\n"
14748                "    : a(a) {}",
14749                Style);
14750 
14751   Style.ColumnLimit = 0;
14752   verifyFormat("SomeClass::Constructor()\n"
14753                "    : a(a) {}",
14754                Style);
14755   verifyFormat("SomeClass::Constructor() noexcept\n"
14756                "    : a(a) {}",
14757                Style);
14758   verifyFormat("SomeClass::Constructor()\n"
14759                "    : a(a)\n"
14760                "    , b(b)\n"
14761                "    , c(c) {}",
14762                Style);
14763   verifyFormat("SomeClass::Constructor()\n"
14764                "    : a(a) {\n"
14765                "  foo();\n"
14766                "  bar();\n"
14767                "}",
14768                Style);
14769 
14770   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14771   verifyFormat("SomeClass::Constructor()\n"
14772                "    : a(a)\n"
14773                "    , b(b)\n"
14774                "    , c(c) {\n}",
14775                Style);
14776   verifyFormat("SomeClass::Constructor()\n"
14777                "    : a(a) {\n}",
14778                Style);
14779 
14780   Style.ColumnLimit = 80;
14781   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14782   Style.ConstructorInitializerIndentWidth = 2;
14783   verifyFormat("SomeClass::Constructor()\n"
14784                "  : a(a)\n"
14785                "  , b(b)\n"
14786                "  , c(c) {}",
14787                Style);
14788 
14789   Style.ConstructorInitializerIndentWidth = 0;
14790   verifyFormat("SomeClass::Constructor()\n"
14791                ": a(a)\n"
14792                ", b(b)\n"
14793                ", c(c) {}",
14794                Style);
14795 
14796   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14797   Style.ConstructorInitializerIndentWidth = 4;
14798   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14799   verifyFormat(
14800       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14801       Style);
14802   verifyFormat(
14803       "SomeClass::Constructor()\n"
14804       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14805       Style);
14806   Style.ConstructorInitializerIndentWidth = 4;
14807   Style.ColumnLimit = 60;
14808   verifyFormat("SomeClass::Constructor()\n"
14809                "    : aaaaaaaa(aaaaaaaa)\n"
14810                "    , aaaaaaaa(aaaaaaaa)\n"
14811                "    , aaaaaaaa(aaaaaaaa) {}",
14812                Style);
14813 }
14814 
14815 TEST_F(FormatTest, Destructors) {
14816   verifyFormat("void F(int &i) { i.~int(); }");
14817   verifyFormat("void F(int &i) { i->~int(); }");
14818 }
14819 
14820 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14821   FormatStyle Style = getWebKitStyle();
14822 
14823   // Don't indent in outer namespaces.
14824   verifyFormat("namespace outer {\n"
14825                "int i;\n"
14826                "namespace inner {\n"
14827                "    int i;\n"
14828                "} // namespace inner\n"
14829                "} // namespace outer\n"
14830                "namespace other_outer {\n"
14831                "int i;\n"
14832                "}",
14833                Style);
14834 
14835   // Don't indent case labels.
14836   verifyFormat("switch (variable) {\n"
14837                "case 1:\n"
14838                "case 2:\n"
14839                "    doSomething();\n"
14840                "    break;\n"
14841                "default:\n"
14842                "    ++variable;\n"
14843                "}",
14844                Style);
14845 
14846   // Wrap before binary operators.
14847   EXPECT_EQ("void f()\n"
14848             "{\n"
14849             "    if (aaaaaaaaaaaaaaaa\n"
14850             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14851             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14852             "        return;\n"
14853             "}",
14854             format("void f() {\n"
14855                    "if (aaaaaaaaaaaaaaaa\n"
14856                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14857                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14858                    "return;\n"
14859                    "}",
14860                    Style));
14861 
14862   // Allow functions on a single line.
14863   verifyFormat("void f() { return; }", Style);
14864 
14865   // Allow empty blocks on a single line and insert a space in empty blocks.
14866   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14867   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14868   // However, don't merge non-empty short loops.
14869   EXPECT_EQ("while (true) {\n"
14870             "    continue;\n"
14871             "}",
14872             format("while (true) { continue; }", Style));
14873 
14874   // Constructor initializers are formatted one per line with the "," on the
14875   // new line.
14876   verifyFormat("Constructor()\n"
14877                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14878                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14879                "          aaaaaaaaaaaaaa)\n"
14880                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14881                "{\n"
14882                "}",
14883                Style);
14884   verifyFormat("SomeClass::Constructor()\n"
14885                "    : a(a)\n"
14886                "{\n"
14887                "}",
14888                Style);
14889   EXPECT_EQ("SomeClass::Constructor()\n"
14890             "    : a(a)\n"
14891             "{\n"
14892             "}",
14893             format("SomeClass::Constructor():a(a){}", Style));
14894   verifyFormat("SomeClass::Constructor()\n"
14895                "    : a(a)\n"
14896                "    , b(b)\n"
14897                "    , c(c)\n"
14898                "{\n"
14899                "}",
14900                Style);
14901   verifyFormat("SomeClass::Constructor()\n"
14902                "    : a(a)\n"
14903                "{\n"
14904                "    foo();\n"
14905                "    bar();\n"
14906                "}",
14907                Style);
14908 
14909   // Access specifiers should be aligned left.
14910   verifyFormat("class C {\n"
14911                "public:\n"
14912                "    int i;\n"
14913                "};",
14914                Style);
14915 
14916   // Do not align comments.
14917   verifyFormat("int a; // Do not\n"
14918                "double b; // align comments.",
14919                Style);
14920 
14921   // Do not align operands.
14922   EXPECT_EQ("ASSERT(aaaa\n"
14923             "    || bbbb);",
14924             format("ASSERT ( aaaa\n||bbbb);", Style));
14925 
14926   // Accept input's line breaks.
14927   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
14928             "    || bbbbbbbbbbbbbbb) {\n"
14929             "    i++;\n"
14930             "}",
14931             format("if (aaaaaaaaaaaaaaa\n"
14932                    "|| bbbbbbbbbbbbbbb) { i++; }",
14933                    Style));
14934   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
14935             "    i++;\n"
14936             "}",
14937             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
14938 
14939   // Don't automatically break all macro definitions (llvm.org/PR17842).
14940   verifyFormat("#define aNumber 10", Style);
14941   // However, generally keep the line breaks that the user authored.
14942   EXPECT_EQ("#define aNumber \\\n"
14943             "    10",
14944             format("#define aNumber \\\n"
14945                    " 10",
14946                    Style));
14947 
14948   // Keep empty and one-element array literals on a single line.
14949   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
14950             "                                  copyItems:YES];",
14951             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
14952                    "copyItems:YES];",
14953                    Style));
14954   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
14955             "                                  copyItems:YES];",
14956             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
14957                    "             copyItems:YES];",
14958                    Style));
14959   // FIXME: This does not seem right, there should be more indentation before
14960   // the array literal's entries. Nested blocks have the same problem.
14961   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14962             "    @\"a\",\n"
14963             "    @\"a\"\n"
14964             "]\n"
14965             "                                  copyItems:YES];",
14966             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14967                    "     @\"a\",\n"
14968                    "     @\"a\"\n"
14969                    "     ]\n"
14970                    "       copyItems:YES];",
14971                    Style));
14972   EXPECT_EQ(
14973       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14974       "                                  copyItems:YES];",
14975       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14976              "   copyItems:YES];",
14977              Style));
14978 
14979   verifyFormat("[self.a b:c c:d];", Style);
14980   EXPECT_EQ("[self.a b:c\n"
14981             "        c:d];",
14982             format("[self.a b:c\n"
14983                    "c:d];",
14984                    Style));
14985 }
14986 
14987 TEST_F(FormatTest, FormatsLambdas) {
14988   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
14989   verifyFormat(
14990       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
14991   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
14992   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
14993   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
14994   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
14995   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
14996   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
14997   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
14998   verifyFormat("int x = f(*+[] {});");
14999   verifyFormat("void f() {\n"
15000                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
15001                "}\n");
15002   verifyFormat("void f() {\n"
15003                "  other(x.begin(), //\n"
15004                "        x.end(),   //\n"
15005                "        [&](int, int) { return 1; });\n"
15006                "}\n");
15007   verifyFormat("void f() {\n"
15008                "  other.other.other.other.other(\n"
15009                "      x.begin(), x.end(),\n"
15010                "      [something, rather](int, int, int, int, int, int, int) { "
15011                "return 1; });\n"
15012                "}\n");
15013   verifyFormat(
15014       "void f() {\n"
15015       "  other.other.other.other.other(\n"
15016       "      x.begin(), x.end(),\n"
15017       "      [something, rather](int, int, int, int, int, int, int) {\n"
15018       "        //\n"
15019       "      });\n"
15020       "}\n");
15021   verifyFormat("SomeFunction([]() { // A cool function...\n"
15022                "  return 43;\n"
15023                "});");
15024   EXPECT_EQ("SomeFunction([]() {\n"
15025             "#define A a\n"
15026             "  return 43;\n"
15027             "});",
15028             format("SomeFunction([](){\n"
15029                    "#define A a\n"
15030                    "return 43;\n"
15031                    "});"));
15032   verifyFormat("void f() {\n"
15033                "  SomeFunction([](decltype(x), A *a) {});\n"
15034                "  SomeFunction([](typeof(x), A *a) {});\n"
15035                "  SomeFunction([](_Atomic(x), A *a) {});\n"
15036                "  SomeFunction([](__underlying_type(x), A *a) {});\n"
15037                "}");
15038   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15039                "    [](const aaaaaaaaaa &a) { return a; });");
15040   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
15041                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
15042                "});");
15043   verifyFormat("Constructor()\n"
15044                "    : Field([] { // comment\n"
15045                "        int i;\n"
15046                "      }) {}");
15047   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
15048                "  return some_parameter.size();\n"
15049                "};");
15050   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
15051                "    [](const string &s) { return s; };");
15052   verifyFormat("int i = aaaaaa ? 1 //\n"
15053                "               : [] {\n"
15054                "                   return 2; //\n"
15055                "                 }();");
15056   verifyFormat("llvm::errs() << \"number of twos is \"\n"
15057                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
15058                "                  return x == 2; // force break\n"
15059                "                });");
15060   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15061                "    [=](int iiiiiiiiiiii) {\n"
15062                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
15063                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
15064                "    });",
15065                getLLVMStyleWithColumns(60));
15066   verifyFormat("SomeFunction({[&] {\n"
15067                "                // comment\n"
15068                "              },\n"
15069                "              [&] {\n"
15070                "                // comment\n"
15071                "              }});");
15072   verifyFormat("SomeFunction({[&] {\n"
15073                "  // comment\n"
15074                "}});");
15075   verifyFormat(
15076       "virtual aaaaaaaaaaaaaaaa(\n"
15077       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
15078       "    aaaaa aaaaaaaaa);");
15079 
15080   // Lambdas with return types.
15081   verifyFormat("int c = []() -> int { return 2; }();\n");
15082   verifyFormat("int c = []() -> int * { return 2; }();\n");
15083   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
15084   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
15085   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
15086   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
15087   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
15088   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
15089   verifyFormat("[a, a]() -> a<1> {};");
15090   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
15091   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
15092   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
15093   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
15094   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
15095   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
15096   verifyFormat("[]() -> foo<!5> { return {}; };");
15097   verifyFormat("[]() -> foo<~5> { return {}; };");
15098   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
15099   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
15100   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
15101   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
15102   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
15103   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
15104   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
15105   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
15106   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
15107   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
15108   verifyFormat("namespace bar {\n"
15109                "// broken:\n"
15110                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
15111                "} // namespace bar");
15112   verifyFormat("namespace bar {\n"
15113                "// broken:\n"
15114                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
15115                "} // namespace bar");
15116   verifyFormat("namespace bar {\n"
15117                "// broken:\n"
15118                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
15119                "} // namespace bar");
15120   verifyFormat("namespace bar {\n"
15121                "// broken:\n"
15122                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
15123                "} // namespace bar");
15124   verifyFormat("namespace bar {\n"
15125                "// broken:\n"
15126                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
15127                "} // namespace bar");
15128   verifyFormat("namespace bar {\n"
15129                "// broken:\n"
15130                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
15131                "} // namespace bar");
15132   verifyFormat("namespace bar {\n"
15133                "// broken:\n"
15134                "auto foo{[]() -> foo<!5> { return {}; }};\n"
15135                "} // namespace bar");
15136   verifyFormat("namespace bar {\n"
15137                "// broken:\n"
15138                "auto foo{[]() -> foo<~5> { return {}; }};\n"
15139                "} // namespace bar");
15140   verifyFormat("namespace bar {\n"
15141                "// broken:\n"
15142                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
15143                "} // namespace bar");
15144   verifyFormat("namespace bar {\n"
15145                "// broken:\n"
15146                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
15147                "} // namespace bar");
15148   verifyFormat("namespace bar {\n"
15149                "// broken:\n"
15150                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
15151                "} // namespace bar");
15152   verifyFormat("namespace bar {\n"
15153                "// broken:\n"
15154                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
15155                "} // namespace bar");
15156   verifyFormat("namespace bar {\n"
15157                "// broken:\n"
15158                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
15159                "} // namespace bar");
15160   verifyFormat("namespace bar {\n"
15161                "// broken:\n"
15162                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
15163                "} // namespace bar");
15164   verifyFormat("namespace bar {\n"
15165                "// broken:\n"
15166                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
15167                "} // namespace bar");
15168   verifyFormat("namespace bar {\n"
15169                "// broken:\n"
15170                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
15171                "} // namespace bar");
15172   verifyFormat("namespace bar {\n"
15173                "// broken:\n"
15174                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
15175                "} // namespace bar");
15176   verifyFormat("namespace bar {\n"
15177                "// broken:\n"
15178                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
15179                "} // namespace bar");
15180   verifyFormat("[]() -> a<1> {};");
15181   verifyFormat("[]() -> a<1> { ; };");
15182   verifyFormat("[]() -> a<1> { ; }();");
15183   verifyFormat("[a, a]() -> a<true> {};");
15184   verifyFormat("[]() -> a<true> {};");
15185   verifyFormat("[]() -> a<true> { ; };");
15186   verifyFormat("[]() -> a<true> { ; }();");
15187   verifyFormat("[a, a]() -> a<false> {};");
15188   verifyFormat("[]() -> a<false> {};");
15189   verifyFormat("[]() -> a<false> { ; };");
15190   verifyFormat("[]() -> a<false> { ; }();");
15191   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
15192   verifyFormat("namespace bar {\n"
15193                "auto foo{[]() -> foo<false> { ; }};\n"
15194                "} // namespace bar");
15195   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
15196                "                   int j) -> int {\n"
15197                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
15198                "};");
15199   verifyFormat(
15200       "aaaaaaaaaaaaaaaaaaaaaa(\n"
15201       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
15202       "      return aaaaaaaaaaaaaaaaa;\n"
15203       "    });",
15204       getLLVMStyleWithColumns(70));
15205   verifyFormat("[]() //\n"
15206                "    -> int {\n"
15207                "  return 1; //\n"
15208                "};");
15209   verifyFormat("[]() -> Void<T...> {};");
15210   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
15211 
15212   // Lambdas with explicit template argument lists.
15213   verifyFormat(
15214       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
15215 
15216   // Multiple lambdas in the same parentheses change indentation rules. These
15217   // lambdas are forced to start on new lines.
15218   verifyFormat("SomeFunction(\n"
15219                "    []() {\n"
15220                "      //\n"
15221                "    },\n"
15222                "    []() {\n"
15223                "      //\n"
15224                "    });");
15225 
15226   // A lambda passed as arg0 is always pushed to the next line.
15227   verifyFormat("SomeFunction(\n"
15228                "    [this] {\n"
15229                "      //\n"
15230                "    },\n"
15231                "    1);\n");
15232 
15233   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
15234   // the arg0 case above.
15235   auto Style = getGoogleStyle();
15236   Style.BinPackArguments = false;
15237   verifyFormat("SomeFunction(\n"
15238                "    a,\n"
15239                "    [this] {\n"
15240                "      //\n"
15241                "    },\n"
15242                "    b);\n",
15243                Style);
15244   verifyFormat("SomeFunction(\n"
15245                "    a,\n"
15246                "    [this] {\n"
15247                "      //\n"
15248                "    },\n"
15249                "    b);\n");
15250 
15251   // A lambda with a very long line forces arg0 to be pushed out irrespective of
15252   // the BinPackArguments value (as long as the code is wide enough).
15253   verifyFormat(
15254       "something->SomeFunction(\n"
15255       "    a,\n"
15256       "    [this] {\n"
15257       "      "
15258       "D0000000000000000000000000000000000000000000000000000000000001();\n"
15259       "    },\n"
15260       "    b);\n");
15261 
15262   // A multi-line lambda is pulled up as long as the introducer fits on the
15263   // previous line and there are no further args.
15264   verifyFormat("function(1, [this, that] {\n"
15265                "  //\n"
15266                "});\n");
15267   verifyFormat("function([this, that] {\n"
15268                "  //\n"
15269                "});\n");
15270   // FIXME: this format is not ideal and we should consider forcing the first
15271   // arg onto its own line.
15272   verifyFormat("function(a, b, c, //\n"
15273                "         d, [this, that] {\n"
15274                "           //\n"
15275                "         });\n");
15276 
15277   // Multiple lambdas are treated correctly even when there is a short arg0.
15278   verifyFormat("SomeFunction(\n"
15279                "    1,\n"
15280                "    [this] {\n"
15281                "      //\n"
15282                "    },\n"
15283                "    [this] {\n"
15284                "      //\n"
15285                "    },\n"
15286                "    1);\n");
15287 
15288   // More complex introducers.
15289   verifyFormat("return [i, args...] {};");
15290 
15291   // Not lambdas.
15292   verifyFormat("constexpr char hello[]{\"hello\"};");
15293   verifyFormat("double &operator[](int i) { return 0; }\n"
15294                "int i;");
15295   verifyFormat("std::unique_ptr<int[]> foo() {}");
15296   verifyFormat("int i = a[a][a]->f();");
15297   verifyFormat("int i = (*b)[a]->f();");
15298 
15299   // Other corner cases.
15300   verifyFormat("void f() {\n"
15301                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
15302                "  );\n"
15303                "}");
15304 
15305   // Lambdas created through weird macros.
15306   verifyFormat("void f() {\n"
15307                "  MACRO((const AA &a) { return 1; });\n"
15308                "  MACRO((AA &a) { return 1; });\n"
15309                "}");
15310 
15311   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
15312                "      doo_dah();\n"
15313                "      doo_dah();\n"
15314                "    })) {\n"
15315                "}");
15316   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
15317                "                doo_dah();\n"
15318                "                doo_dah();\n"
15319                "              })) {\n"
15320                "}");
15321   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
15322                "                doo_dah();\n"
15323                "                doo_dah();\n"
15324                "              })) {\n"
15325                "}");
15326   verifyFormat("auto lambda = []() {\n"
15327                "  int a = 2\n"
15328                "#if A\n"
15329                "          + 2\n"
15330                "#endif\n"
15331                "      ;\n"
15332                "};");
15333 
15334   // Lambdas with complex multiline introducers.
15335   verifyFormat(
15336       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15337       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
15338       "        -> ::std::unordered_set<\n"
15339       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
15340       "      //\n"
15341       "    });");
15342 
15343   FormatStyle DoNotMerge = getLLVMStyle();
15344   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
15345   verifyFormat("auto c = []() {\n"
15346                "  return b;\n"
15347                "};",
15348                "auto c = []() { return b; };", DoNotMerge);
15349   verifyFormat("auto c = []() {\n"
15350                "};",
15351                " auto c = []() {};", DoNotMerge);
15352 
15353   FormatStyle MergeEmptyOnly = getLLVMStyle();
15354   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
15355   verifyFormat("auto c = []() {\n"
15356                "  return b;\n"
15357                "};",
15358                "auto c = []() {\n"
15359                "  return b;\n"
15360                " };",
15361                MergeEmptyOnly);
15362   verifyFormat("auto c = []() {};",
15363                "auto c = []() {\n"
15364                "};",
15365                MergeEmptyOnly);
15366 
15367   FormatStyle MergeInline = getLLVMStyle();
15368   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
15369   verifyFormat("auto c = []() {\n"
15370                "  return b;\n"
15371                "};",
15372                "auto c = []() { return b; };", MergeInline);
15373   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
15374                MergeInline);
15375   verifyFormat("function([]() { return b; }, a)",
15376                "function([]() { return b; }, a)", MergeInline);
15377   verifyFormat("function(a, []() { return b; })",
15378                "function(a, []() { return b; })", MergeInline);
15379 
15380   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
15381   // AllowShortLambdasOnASingleLine
15382   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15383   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15384   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15385   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15386       FormatStyle::ShortLambdaStyle::SLS_None;
15387   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
15388                "    []()\n"
15389                "    {\n"
15390                "      return 17;\n"
15391                "    });",
15392                LLVMWithBeforeLambdaBody);
15393   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
15394                "    []()\n"
15395                "    {\n"
15396                "    });",
15397                LLVMWithBeforeLambdaBody);
15398   verifyFormat("auto fct_SLS_None = []()\n"
15399                "{\n"
15400                "  return 17;\n"
15401                "};",
15402                LLVMWithBeforeLambdaBody);
15403   verifyFormat("TwoNestedLambdas_SLS_None(\n"
15404                "    []()\n"
15405                "    {\n"
15406                "      return Call(\n"
15407                "          []()\n"
15408                "          {\n"
15409                "            return 17;\n"
15410                "          });\n"
15411                "    });",
15412                LLVMWithBeforeLambdaBody);
15413   verifyFormat("void Fct()\n"
15414                "{\n"
15415                "  return {[]()\n"
15416                "          {\n"
15417                "            return 17;\n"
15418                "          }};\n"
15419                "}",
15420                LLVMWithBeforeLambdaBody);
15421 
15422   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15423       FormatStyle::ShortLambdaStyle::SLS_Empty;
15424   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
15425                "    []()\n"
15426                "    {\n"
15427                "      return 17;\n"
15428                "    });",
15429                LLVMWithBeforeLambdaBody);
15430   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
15431                LLVMWithBeforeLambdaBody);
15432   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
15433                "ongFunctionName_SLS_Empty(\n"
15434                "    []() {});",
15435                LLVMWithBeforeLambdaBody);
15436   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15437                "                                []()\n"
15438                "                                {\n"
15439                "                                  return 17;\n"
15440                "                                });",
15441                LLVMWithBeforeLambdaBody);
15442   verifyFormat("auto fct_SLS_Empty = []()\n"
15443                "{\n"
15444                "  return 17;\n"
15445                "};",
15446                LLVMWithBeforeLambdaBody);
15447   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15448                "    []()\n"
15449                "    {\n"
15450                "      return Call([]() {});\n"
15451                "    });",
15452                LLVMWithBeforeLambdaBody);
15453   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15454                "                           []()\n"
15455                "                           {\n"
15456                "                             return Call([]() {});\n"
15457                "                           });",
15458                LLVMWithBeforeLambdaBody);
15459   verifyFormat(
15460       "FctWithLongLineInLambda_SLS_Empty(\n"
15461       "    []()\n"
15462       "    {\n"
15463       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15464       "                               AndShouldNotBeConsiderAsInline,\n"
15465       "                               LambdaBodyMustBeBreak);\n"
15466       "    });",
15467       LLVMWithBeforeLambdaBody);
15468 
15469   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15470       FormatStyle::ShortLambdaStyle::SLS_Inline;
15471   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15472                LLVMWithBeforeLambdaBody);
15473   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15474                LLVMWithBeforeLambdaBody);
15475   verifyFormat("auto fct_SLS_Inline = []()\n"
15476                "{\n"
15477                "  return 17;\n"
15478                "};",
15479                LLVMWithBeforeLambdaBody);
15480   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15481                "17; }); });",
15482                LLVMWithBeforeLambdaBody);
15483   verifyFormat(
15484       "FctWithLongLineInLambda_SLS_Inline(\n"
15485       "    []()\n"
15486       "    {\n"
15487       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15488       "                               AndShouldNotBeConsiderAsInline,\n"
15489       "                               LambdaBodyMustBeBreak);\n"
15490       "    });",
15491       LLVMWithBeforeLambdaBody);
15492   verifyFormat("FctWithMultipleParams_SLS_Inline("
15493                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15494                "                                 []() { return 17; });",
15495                LLVMWithBeforeLambdaBody);
15496   verifyFormat(
15497       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15498       LLVMWithBeforeLambdaBody);
15499 
15500   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15501       FormatStyle::ShortLambdaStyle::SLS_All;
15502   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15503                LLVMWithBeforeLambdaBody);
15504   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15505                LLVMWithBeforeLambdaBody);
15506   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15507                LLVMWithBeforeLambdaBody);
15508   verifyFormat("FctWithOneParam_SLS_All(\n"
15509                "    []()\n"
15510                "    {\n"
15511                "      // A cool function...\n"
15512                "      return 43;\n"
15513                "    });",
15514                LLVMWithBeforeLambdaBody);
15515   verifyFormat("FctWithMultipleParams_SLS_All("
15516                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15517                "                              []() { return 17; });",
15518                LLVMWithBeforeLambdaBody);
15519   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15520                LLVMWithBeforeLambdaBody);
15521   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15522                LLVMWithBeforeLambdaBody);
15523   verifyFormat(
15524       "FctWithLongLineInLambda_SLS_All(\n"
15525       "    []()\n"
15526       "    {\n"
15527       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15528       "                               AndShouldNotBeConsiderAsInline,\n"
15529       "                               LambdaBodyMustBeBreak);\n"
15530       "    });",
15531       LLVMWithBeforeLambdaBody);
15532   verifyFormat(
15533       "auto fct_SLS_All = []()\n"
15534       "{\n"
15535       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15536       "                           AndShouldNotBeConsiderAsInline,\n"
15537       "                           LambdaBodyMustBeBreak);\n"
15538       "};",
15539       LLVMWithBeforeLambdaBody);
15540   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15541   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15542                LLVMWithBeforeLambdaBody);
15543   verifyFormat(
15544       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15545       "                                FirstParam,\n"
15546       "                                SecondParam,\n"
15547       "                                ThirdParam,\n"
15548       "                                FourthParam);",
15549       LLVMWithBeforeLambdaBody);
15550   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15551                "    []() { return "
15552                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15553                "    FirstParam,\n"
15554                "    SecondParam,\n"
15555                "    ThirdParam,\n"
15556                "    FourthParam);",
15557                LLVMWithBeforeLambdaBody);
15558   verifyFormat(
15559       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15560       "                                SecondParam,\n"
15561       "                                ThirdParam,\n"
15562       "                                FourthParam,\n"
15563       "                                []() { return SomeValueNotSoLong; });",
15564       LLVMWithBeforeLambdaBody);
15565   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15566                "    []()\n"
15567                "    {\n"
15568                "      return "
15569                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15570                "eConsiderAsInline;\n"
15571                "    });",
15572                LLVMWithBeforeLambdaBody);
15573   verifyFormat(
15574       "FctWithLongLineInLambda_SLS_All(\n"
15575       "    []()\n"
15576       "    {\n"
15577       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15578       "                               AndShouldNotBeConsiderAsInline,\n"
15579       "                               LambdaBodyMustBeBreak);\n"
15580       "    });",
15581       LLVMWithBeforeLambdaBody);
15582   verifyFormat("FctWithTwoParams_SLS_All(\n"
15583                "    []()\n"
15584                "    {\n"
15585                "      // A cool function...\n"
15586                "      return 43;\n"
15587                "    },\n"
15588                "    87);",
15589                LLVMWithBeforeLambdaBody);
15590   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15591                LLVMWithBeforeLambdaBody);
15592   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15593                LLVMWithBeforeLambdaBody);
15594   verifyFormat(
15595       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15596       LLVMWithBeforeLambdaBody);
15597   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15598                "}); }, x);",
15599                LLVMWithBeforeLambdaBody);
15600   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15601                "    []()\n"
15602                "    {\n"
15603                "      // A cool function...\n"
15604                "      return Call([]() { return 17; });\n"
15605                "    });",
15606                LLVMWithBeforeLambdaBody);
15607   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15608                "    []()\n"
15609                "    {\n"
15610                "      return Call(\n"
15611                "          []()\n"
15612                "          {\n"
15613                "            // A cool function...\n"
15614                "            return 17;\n"
15615                "          });\n"
15616                "    });",
15617                LLVMWithBeforeLambdaBody);
15618 }
15619 
15620 TEST_F(FormatTest, LambdaWithLineComments) {
15621   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15622   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15623   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15624   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15625       FormatStyle::ShortLambdaStyle::SLS_All;
15626 
15627   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15628   verifyFormat("auto k = []() // comment\n"
15629                "{ return; }",
15630                LLVMWithBeforeLambdaBody);
15631   verifyFormat("auto k = []() /* comment */ { return; }",
15632                LLVMWithBeforeLambdaBody);
15633   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15634                LLVMWithBeforeLambdaBody);
15635   verifyFormat("auto k = []() // X\n"
15636                "{ return; }",
15637                LLVMWithBeforeLambdaBody);
15638   verifyFormat(
15639       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15640       "{ return; }",
15641       LLVMWithBeforeLambdaBody);
15642 }
15643 
15644 TEST_F(FormatTest, EmptyLinesInLambdas) {
15645   verifyFormat("auto lambda = []() {\n"
15646                "  x(); //\n"
15647                "};",
15648                "auto lambda = []() {\n"
15649                "\n"
15650                "  x(); //\n"
15651                "\n"
15652                "};");
15653 }
15654 
15655 TEST_F(FormatTest, FormatsBlocks) {
15656   FormatStyle ShortBlocks = getLLVMStyle();
15657   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15658   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15659   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15660   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15661   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15662   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15663   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15664 
15665   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15666   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15667   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15668 
15669   verifyFormat("[operation setCompletionBlock:^{\n"
15670                "  [self onOperationDone];\n"
15671                "}];");
15672   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15673                "  [self onOperationDone];\n"
15674                "}]};");
15675   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15676                "  f();\n"
15677                "}];");
15678   verifyFormat("int a = [operation block:^int(int *i) {\n"
15679                "  return 1;\n"
15680                "}];");
15681   verifyFormat("[myObject doSomethingWith:arg1\n"
15682                "                      aaa:^int(int *a) {\n"
15683                "                        return 1;\n"
15684                "                      }\n"
15685                "                      bbb:f(a * bbbbbbbb)];");
15686 
15687   verifyFormat("[operation setCompletionBlock:^{\n"
15688                "  [self.delegate newDataAvailable];\n"
15689                "}];",
15690                getLLVMStyleWithColumns(60));
15691   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15692                "  NSString *path = [self sessionFilePath];\n"
15693                "  if (path) {\n"
15694                "    // ...\n"
15695                "  }\n"
15696                "});");
15697   verifyFormat("[[SessionService sharedService]\n"
15698                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15699                "      if (window) {\n"
15700                "        [self windowDidLoad:window];\n"
15701                "      } else {\n"
15702                "        [self errorLoadingWindow];\n"
15703                "      }\n"
15704                "    }];");
15705   verifyFormat("void (^largeBlock)(void) = ^{\n"
15706                "  // ...\n"
15707                "};\n",
15708                getLLVMStyleWithColumns(40));
15709   verifyFormat("[[SessionService sharedService]\n"
15710                "    loadWindowWithCompletionBlock: //\n"
15711                "        ^(SessionWindow *window) {\n"
15712                "          if (window) {\n"
15713                "            [self windowDidLoad:window];\n"
15714                "          } else {\n"
15715                "            [self errorLoadingWindow];\n"
15716                "          }\n"
15717                "        }];",
15718                getLLVMStyleWithColumns(60));
15719   verifyFormat("[myObject doSomethingWith:arg1\n"
15720                "    firstBlock:^(Foo *a) {\n"
15721                "      // ...\n"
15722                "      int i;\n"
15723                "    }\n"
15724                "    secondBlock:^(Bar *b) {\n"
15725                "      // ...\n"
15726                "      int i;\n"
15727                "    }\n"
15728                "    thirdBlock:^Foo(Bar *b) {\n"
15729                "      // ...\n"
15730                "      int i;\n"
15731                "    }];");
15732   verifyFormat("[myObject doSomethingWith:arg1\n"
15733                "               firstBlock:-1\n"
15734                "              secondBlock:^(Bar *b) {\n"
15735                "                // ...\n"
15736                "                int i;\n"
15737                "              }];");
15738 
15739   verifyFormat("f(^{\n"
15740                "  @autoreleasepool {\n"
15741                "    if (a) {\n"
15742                "      g();\n"
15743                "    }\n"
15744                "  }\n"
15745                "});");
15746   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15747   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15748                "};");
15749 
15750   FormatStyle FourIndent = getLLVMStyle();
15751   FourIndent.ObjCBlockIndentWidth = 4;
15752   verifyFormat("[operation setCompletionBlock:^{\n"
15753                "    [self onOperationDone];\n"
15754                "}];",
15755                FourIndent);
15756 }
15757 
15758 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15759   FormatStyle ZeroColumn = getLLVMStyle();
15760   ZeroColumn.ColumnLimit = 0;
15761 
15762   verifyFormat("[[SessionService sharedService] "
15763                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15764                "  if (window) {\n"
15765                "    [self windowDidLoad:window];\n"
15766                "  } else {\n"
15767                "    [self errorLoadingWindow];\n"
15768                "  }\n"
15769                "}];",
15770                ZeroColumn);
15771   EXPECT_EQ("[[SessionService sharedService]\n"
15772             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15773             "      if (window) {\n"
15774             "        [self windowDidLoad:window];\n"
15775             "      } else {\n"
15776             "        [self errorLoadingWindow];\n"
15777             "      }\n"
15778             "    }];",
15779             format("[[SessionService sharedService]\n"
15780                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15781                    "                if (window) {\n"
15782                    "    [self windowDidLoad:window];\n"
15783                    "  } else {\n"
15784                    "    [self errorLoadingWindow];\n"
15785                    "  }\n"
15786                    "}];",
15787                    ZeroColumn));
15788   verifyFormat("[myObject doSomethingWith:arg1\n"
15789                "    firstBlock:^(Foo *a) {\n"
15790                "      // ...\n"
15791                "      int i;\n"
15792                "    }\n"
15793                "    secondBlock:^(Bar *b) {\n"
15794                "      // ...\n"
15795                "      int i;\n"
15796                "    }\n"
15797                "    thirdBlock:^Foo(Bar *b) {\n"
15798                "      // ...\n"
15799                "      int i;\n"
15800                "    }];",
15801                ZeroColumn);
15802   verifyFormat("f(^{\n"
15803                "  @autoreleasepool {\n"
15804                "    if (a) {\n"
15805                "      g();\n"
15806                "    }\n"
15807                "  }\n"
15808                "});",
15809                ZeroColumn);
15810   verifyFormat("void (^largeBlock)(void) = ^{\n"
15811                "  // ...\n"
15812                "};",
15813                ZeroColumn);
15814 
15815   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15816   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15817             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15818   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15819   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15820             "  int i;\n"
15821             "};",
15822             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15823 }
15824 
15825 TEST_F(FormatTest, SupportsCRLF) {
15826   EXPECT_EQ("int a;\r\n"
15827             "int b;\r\n"
15828             "int c;\r\n",
15829             format("int a;\r\n"
15830                    "  int b;\r\n"
15831                    "    int c;\r\n",
15832                    getLLVMStyle()));
15833   EXPECT_EQ("int a;\r\n"
15834             "int b;\r\n"
15835             "int c;\r\n",
15836             format("int a;\r\n"
15837                    "  int b;\n"
15838                    "    int c;\r\n",
15839                    getLLVMStyle()));
15840   EXPECT_EQ("int a;\n"
15841             "int b;\n"
15842             "int c;\n",
15843             format("int a;\r\n"
15844                    "  int b;\n"
15845                    "    int c;\n",
15846                    getLLVMStyle()));
15847   EXPECT_EQ("\"aaaaaaa \"\r\n"
15848             "\"bbbbbbb\";\r\n",
15849             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15850   EXPECT_EQ("#define A \\\r\n"
15851             "  b;      \\\r\n"
15852             "  c;      \\\r\n"
15853             "  d;\r\n",
15854             format("#define A \\\r\n"
15855                    "  b; \\\r\n"
15856                    "  c; d; \r\n",
15857                    getGoogleStyle()));
15858 
15859   EXPECT_EQ("/*\r\n"
15860             "multi line block comments\r\n"
15861             "should not introduce\r\n"
15862             "an extra carriage return\r\n"
15863             "*/\r\n",
15864             format("/*\r\n"
15865                    "multi line block comments\r\n"
15866                    "should not introduce\r\n"
15867                    "an extra carriage return\r\n"
15868                    "*/\r\n"));
15869   EXPECT_EQ("/*\r\n"
15870             "\r\n"
15871             "*/",
15872             format("/*\r\n"
15873                    "    \r\r\r\n"
15874                    "*/"));
15875 
15876   FormatStyle style = getLLVMStyle();
15877 
15878   style.DeriveLineEnding = true;
15879   style.UseCRLF = false;
15880   EXPECT_EQ("union FooBarBazQux {\n"
15881             "  int foo;\n"
15882             "  int bar;\n"
15883             "  int baz;\n"
15884             "};",
15885             format("union FooBarBazQux {\r\n"
15886                    "  int foo;\n"
15887                    "  int bar;\r\n"
15888                    "  int baz;\n"
15889                    "};",
15890                    style));
15891   style.UseCRLF = true;
15892   EXPECT_EQ("union FooBarBazQux {\r\n"
15893             "  int foo;\r\n"
15894             "  int bar;\r\n"
15895             "  int baz;\r\n"
15896             "};",
15897             format("union FooBarBazQux {\r\n"
15898                    "  int foo;\n"
15899                    "  int bar;\r\n"
15900                    "  int baz;\n"
15901                    "};",
15902                    style));
15903 
15904   style.DeriveLineEnding = false;
15905   style.UseCRLF = false;
15906   EXPECT_EQ("union FooBarBazQux {\n"
15907             "  int foo;\n"
15908             "  int bar;\n"
15909             "  int baz;\n"
15910             "  int qux;\n"
15911             "};",
15912             format("union FooBarBazQux {\r\n"
15913                    "  int foo;\n"
15914                    "  int bar;\r\n"
15915                    "  int baz;\n"
15916                    "  int qux;\r\n"
15917                    "};",
15918                    style));
15919   style.UseCRLF = true;
15920   EXPECT_EQ("union FooBarBazQux {\r\n"
15921             "  int foo;\r\n"
15922             "  int bar;\r\n"
15923             "  int baz;\r\n"
15924             "  int qux;\r\n"
15925             "};",
15926             format("union FooBarBazQux {\r\n"
15927                    "  int foo;\n"
15928                    "  int bar;\r\n"
15929                    "  int baz;\n"
15930                    "  int qux;\n"
15931                    "};",
15932                    style));
15933 
15934   style.DeriveLineEnding = true;
15935   style.UseCRLF = false;
15936   EXPECT_EQ("union FooBarBazQux {\r\n"
15937             "  int foo;\r\n"
15938             "  int bar;\r\n"
15939             "  int baz;\r\n"
15940             "  int qux;\r\n"
15941             "};",
15942             format("union FooBarBazQux {\r\n"
15943                    "  int foo;\n"
15944                    "  int bar;\r\n"
15945                    "  int baz;\n"
15946                    "  int qux;\r\n"
15947                    "};",
15948                    style));
15949   style.UseCRLF = true;
15950   EXPECT_EQ("union FooBarBazQux {\n"
15951             "  int foo;\n"
15952             "  int bar;\n"
15953             "  int baz;\n"
15954             "  int qux;\n"
15955             "};",
15956             format("union FooBarBazQux {\r\n"
15957                    "  int foo;\n"
15958                    "  int bar;\r\n"
15959                    "  int baz;\n"
15960                    "  int qux;\n"
15961                    "};",
15962                    style));
15963 }
15964 
15965 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
15966   verifyFormat("MY_CLASS(C) {\n"
15967                "  int i;\n"
15968                "  int j;\n"
15969                "};");
15970 }
15971 
15972 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
15973   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
15974   TwoIndent.ContinuationIndentWidth = 2;
15975 
15976   EXPECT_EQ("int i =\n"
15977             "  longFunction(\n"
15978             "    arg);",
15979             format("int i = longFunction(arg);", TwoIndent));
15980 
15981   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
15982   SixIndent.ContinuationIndentWidth = 6;
15983 
15984   EXPECT_EQ("int i =\n"
15985             "      longFunction(\n"
15986             "            arg);",
15987             format("int i = longFunction(arg);", SixIndent));
15988 }
15989 
15990 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
15991   FormatStyle Style = getLLVMStyle();
15992   verifyFormat("int Foo::getter(\n"
15993                "    //\n"
15994                ") const {\n"
15995                "  return foo;\n"
15996                "}",
15997                Style);
15998   verifyFormat("void Foo::setter(\n"
15999                "    //\n"
16000                ") {\n"
16001                "  foo = 1;\n"
16002                "}",
16003                Style);
16004 }
16005 
16006 TEST_F(FormatTest, SpacesInAngles) {
16007   FormatStyle Spaces = getLLVMStyle();
16008   Spaces.SpacesInAngles = true;
16009 
16010   verifyFormat("static_cast< int >(arg);", Spaces);
16011   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
16012   verifyFormat("f< int, float >();", Spaces);
16013   verifyFormat("template <> g() {}", Spaces);
16014   verifyFormat("template < std::vector< int > > f() {}", Spaces);
16015   verifyFormat("std::function< void(int, int) > fct;", Spaces);
16016   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
16017                Spaces);
16018 
16019   Spaces.Standard = FormatStyle::LS_Cpp03;
16020   Spaces.SpacesInAngles = true;
16021   verifyFormat("A< A< int > >();", Spaces);
16022 
16023   Spaces.SpacesInAngles = false;
16024   verifyFormat("A<A<int> >();", Spaces);
16025 
16026   Spaces.Standard = FormatStyle::LS_Cpp11;
16027   Spaces.SpacesInAngles = true;
16028   verifyFormat("A< A< int > >();", Spaces);
16029 
16030   Spaces.SpacesInAngles = false;
16031   verifyFormat("A<A<int>>();", Spaces);
16032 }
16033 
16034 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
16035   FormatStyle Style = getLLVMStyle();
16036   Style.SpaceAfterTemplateKeyword = false;
16037   verifyFormat("template<int> void foo();", Style);
16038 }
16039 
16040 TEST_F(FormatTest, TripleAngleBrackets) {
16041   verifyFormat("f<<<1, 1>>>();");
16042   verifyFormat("f<<<1, 1, 1, s>>>();");
16043   verifyFormat("f<<<a, b, c, d>>>();");
16044   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
16045   verifyFormat("f<param><<<1, 1>>>();");
16046   verifyFormat("f<1><<<1, 1>>>();");
16047   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
16048   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16049                "aaaaaaaaaaa<<<\n    1, 1>>>();");
16050   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
16051                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
16052 }
16053 
16054 TEST_F(FormatTest, MergeLessLessAtEnd) {
16055   verifyFormat("<<");
16056   EXPECT_EQ("< < <", format("\\\n<<<"));
16057   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16058                "aaallvm::outs() <<");
16059   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16060                "aaaallvm::outs()\n    <<");
16061 }
16062 
16063 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
16064   std::string code = "#if A\n"
16065                      "#if B\n"
16066                      "a.\n"
16067                      "#endif\n"
16068                      "    a = 1;\n"
16069                      "#else\n"
16070                      "#endif\n"
16071                      "#if C\n"
16072                      "#else\n"
16073                      "#endif\n";
16074   EXPECT_EQ(code, format(code));
16075 }
16076 
16077 TEST_F(FormatTest, HandleConflictMarkers) {
16078   // Git/SVN conflict markers.
16079   EXPECT_EQ("int a;\n"
16080             "void f() {\n"
16081             "  callme(some(parameter1,\n"
16082             "<<<<<<< text by the vcs\n"
16083             "              parameter2),\n"
16084             "||||||| text by the vcs\n"
16085             "              parameter2),\n"
16086             "         parameter3,\n"
16087             "======= text by the vcs\n"
16088             "              parameter2, parameter3),\n"
16089             ">>>>>>> text by the vcs\n"
16090             "         otherparameter);\n",
16091             format("int a;\n"
16092                    "void f() {\n"
16093                    "  callme(some(parameter1,\n"
16094                    "<<<<<<< text by the vcs\n"
16095                    "  parameter2),\n"
16096                    "||||||| text by the vcs\n"
16097                    "  parameter2),\n"
16098                    "  parameter3,\n"
16099                    "======= text by the vcs\n"
16100                    "  parameter2,\n"
16101                    "  parameter3),\n"
16102                    ">>>>>>> text by the vcs\n"
16103                    "  otherparameter);\n"));
16104 
16105   // Perforce markers.
16106   EXPECT_EQ("void f() {\n"
16107             "  function(\n"
16108             ">>>> text by the vcs\n"
16109             "      parameter,\n"
16110             "==== text by the vcs\n"
16111             "      parameter,\n"
16112             "==== text by the vcs\n"
16113             "      parameter,\n"
16114             "<<<< text by the vcs\n"
16115             "      parameter);\n",
16116             format("void f() {\n"
16117                    "  function(\n"
16118                    ">>>> text by the vcs\n"
16119                    "  parameter,\n"
16120                    "==== text by the vcs\n"
16121                    "  parameter,\n"
16122                    "==== text by the vcs\n"
16123                    "  parameter,\n"
16124                    "<<<< text by the vcs\n"
16125                    "  parameter);\n"));
16126 
16127   EXPECT_EQ("<<<<<<<\n"
16128             "|||||||\n"
16129             "=======\n"
16130             ">>>>>>>",
16131             format("<<<<<<<\n"
16132                    "|||||||\n"
16133                    "=======\n"
16134                    ">>>>>>>"));
16135 
16136   EXPECT_EQ("<<<<<<<\n"
16137             "|||||||\n"
16138             "int i;\n"
16139             "=======\n"
16140             ">>>>>>>",
16141             format("<<<<<<<\n"
16142                    "|||||||\n"
16143                    "int i;\n"
16144                    "=======\n"
16145                    ">>>>>>>"));
16146 
16147   // FIXME: Handle parsing of macros around conflict markers correctly:
16148   EXPECT_EQ("#define Macro \\\n"
16149             "<<<<<<<\n"
16150             "Something \\\n"
16151             "|||||||\n"
16152             "Else \\\n"
16153             "=======\n"
16154             "Other \\\n"
16155             ">>>>>>>\n"
16156             "    End int i;\n",
16157             format("#define Macro \\\n"
16158                    "<<<<<<<\n"
16159                    "  Something \\\n"
16160                    "|||||||\n"
16161                    "  Else \\\n"
16162                    "=======\n"
16163                    "  Other \\\n"
16164                    ">>>>>>>\n"
16165                    "  End\n"
16166                    "int i;\n"));
16167 }
16168 
16169 TEST_F(FormatTest, DisableRegions) {
16170   EXPECT_EQ("int i;\n"
16171             "// clang-format off\n"
16172             "  int j;\n"
16173             "// clang-format on\n"
16174             "int k;",
16175             format(" int  i;\n"
16176                    "   // clang-format off\n"
16177                    "  int j;\n"
16178                    " // clang-format on\n"
16179                    "   int   k;"));
16180   EXPECT_EQ("int i;\n"
16181             "/* clang-format off */\n"
16182             "  int j;\n"
16183             "/* clang-format on */\n"
16184             "int k;",
16185             format(" int  i;\n"
16186                    "   /* clang-format off */\n"
16187                    "  int j;\n"
16188                    " /* clang-format on */\n"
16189                    "   int   k;"));
16190 
16191   // Don't reflow comments within disabled regions.
16192   EXPECT_EQ("// clang-format off\n"
16193             "// long long long long long long line\n"
16194             "/* clang-format on */\n"
16195             "/* long long long\n"
16196             " * long long long\n"
16197             " * line */\n"
16198             "int i;\n"
16199             "/* clang-format off */\n"
16200             "/* long long long long long long line */\n",
16201             format("// clang-format off\n"
16202                    "// long long long long long long line\n"
16203                    "/* clang-format on */\n"
16204                    "/* long long long long long long line */\n"
16205                    "int i;\n"
16206                    "/* clang-format off */\n"
16207                    "/* long long long long long long line */\n",
16208                    getLLVMStyleWithColumns(20)));
16209 }
16210 
16211 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
16212   format("? ) =");
16213   verifyNoCrash("#define a\\\n /**/}");
16214 }
16215 
16216 TEST_F(FormatTest, FormatsTableGenCode) {
16217   FormatStyle Style = getLLVMStyle();
16218   Style.Language = FormatStyle::LK_TableGen;
16219   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
16220 }
16221 
16222 TEST_F(FormatTest, ArrayOfTemplates) {
16223   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
16224             format("auto a = new unique_ptr<int > [ 10];"));
16225 
16226   FormatStyle Spaces = getLLVMStyle();
16227   Spaces.SpacesInSquareBrackets = true;
16228   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
16229             format("auto a = new unique_ptr<int > [10];", Spaces));
16230 }
16231 
16232 TEST_F(FormatTest, ArrayAsTemplateType) {
16233   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
16234             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
16235 
16236   FormatStyle Spaces = getLLVMStyle();
16237   Spaces.SpacesInSquareBrackets = true;
16238   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
16239             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
16240 }
16241 
16242 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
16243 
16244 TEST(FormatStyle, GetStyleWithEmptyFileName) {
16245   llvm::vfs::InMemoryFileSystem FS;
16246   auto Style1 = getStyle("file", "", "Google", "", &FS);
16247   ASSERT_TRUE((bool)Style1);
16248   ASSERT_EQ(*Style1, getGoogleStyle());
16249 }
16250 
16251 TEST(FormatStyle, GetStyleOfFile) {
16252   llvm::vfs::InMemoryFileSystem FS;
16253   // Test 1: format file in the same directory.
16254   ASSERT_TRUE(
16255       FS.addFile("/a/.clang-format", 0,
16256                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
16257   ASSERT_TRUE(
16258       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16259   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
16260   ASSERT_TRUE((bool)Style1);
16261   ASSERT_EQ(*Style1, getLLVMStyle());
16262 
16263   // Test 2.1: fallback to default.
16264   ASSERT_TRUE(
16265       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16266   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
16267   ASSERT_TRUE((bool)Style2);
16268   ASSERT_EQ(*Style2, getMozillaStyle());
16269 
16270   // Test 2.2: no format on 'none' fallback style.
16271   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16272   ASSERT_TRUE((bool)Style2);
16273   ASSERT_EQ(*Style2, getNoStyle());
16274 
16275   // Test 2.3: format if config is found with no based style while fallback is
16276   // 'none'.
16277   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
16278                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
16279   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16280   ASSERT_TRUE((bool)Style2);
16281   ASSERT_EQ(*Style2, getLLVMStyle());
16282 
16283   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
16284   Style2 = getStyle("{}", "a.h", "none", "", &FS);
16285   ASSERT_TRUE((bool)Style2);
16286   ASSERT_EQ(*Style2, getLLVMStyle());
16287 
16288   // Test 3: format file in parent directory.
16289   ASSERT_TRUE(
16290       FS.addFile("/c/.clang-format", 0,
16291                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
16292   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
16293                          llvm::MemoryBuffer::getMemBuffer("int i;")));
16294   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
16295   ASSERT_TRUE((bool)Style3);
16296   ASSERT_EQ(*Style3, getGoogleStyle());
16297 
16298   // Test 4: error on invalid fallback style
16299   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
16300   ASSERT_FALSE((bool)Style4);
16301   llvm::consumeError(Style4.takeError());
16302 
16303   // Test 5: error on invalid yaml on command line
16304   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
16305   ASSERT_FALSE((bool)Style5);
16306   llvm::consumeError(Style5.takeError());
16307 
16308   // Test 6: error on invalid style
16309   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
16310   ASSERT_FALSE((bool)Style6);
16311   llvm::consumeError(Style6.takeError());
16312 
16313   // Test 7: found config file, error on parsing it
16314   ASSERT_TRUE(
16315       FS.addFile("/d/.clang-format", 0,
16316                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
16317                                                   "InvalidKey: InvalidValue")));
16318   ASSERT_TRUE(
16319       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16320   auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
16321   ASSERT_FALSE((bool)Style7a);
16322   llvm::consumeError(Style7a.takeError());
16323 
16324   auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
16325   ASSERT_TRUE((bool)Style7b);
16326 
16327   // Test 8: inferred per-language defaults apply.
16328   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
16329   ASSERT_TRUE((bool)StyleTd);
16330   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
16331 }
16332 
16333 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
16334   // Column limit is 20.
16335   std::string Code = "Type *a =\n"
16336                      "    new Type();\n"
16337                      "g(iiiii, 0, jjjjj,\n"
16338                      "  0, kkkkk, 0, mm);\n"
16339                      "int  bad     = format   ;";
16340   std::string Expected = "auto a = new Type();\n"
16341                          "g(iiiii, nullptr,\n"
16342                          "  jjjjj, nullptr,\n"
16343                          "  kkkkk, nullptr,\n"
16344                          "  mm);\n"
16345                          "int  bad     = format   ;";
16346   FileID ID = Context.createInMemoryFile("format.cpp", Code);
16347   tooling::Replacements Replaces = toReplacements(
16348       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
16349                             "auto "),
16350        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
16351                             "nullptr"),
16352        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
16353                             "nullptr"),
16354        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
16355                             "nullptr")});
16356 
16357   format::FormatStyle Style = format::getLLVMStyle();
16358   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
16359   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16360   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16361       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16362   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16363   EXPECT_TRUE(static_cast<bool>(Result));
16364   EXPECT_EQ(Expected, *Result);
16365 }
16366 
16367 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
16368   std::string Code = "#include \"a.h\"\n"
16369                      "#include \"c.h\"\n"
16370                      "\n"
16371                      "int main() {\n"
16372                      "  return 0;\n"
16373                      "}";
16374   std::string Expected = "#include \"a.h\"\n"
16375                          "#include \"b.h\"\n"
16376                          "#include \"c.h\"\n"
16377                          "\n"
16378                          "int main() {\n"
16379                          "  return 0;\n"
16380                          "}";
16381   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
16382   tooling::Replacements Replaces = toReplacements(
16383       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
16384                             "#include \"b.h\"\n")});
16385 
16386   format::FormatStyle Style = format::getLLVMStyle();
16387   Style.SortIncludes = true;
16388   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16389   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16390       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16391   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16392   EXPECT_TRUE(static_cast<bool>(Result));
16393   EXPECT_EQ(Expected, *Result);
16394 }
16395 
16396 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
16397   EXPECT_EQ("using std::cin;\n"
16398             "using std::cout;",
16399             format("using std::cout;\n"
16400                    "using std::cin;",
16401                    getGoogleStyle()));
16402 }
16403 
16404 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
16405   format::FormatStyle Style = format::getLLVMStyle();
16406   Style.Standard = FormatStyle::LS_Cpp03;
16407   // cpp03 recognize this string as identifier u8 and literal character 'a'
16408   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
16409 }
16410 
16411 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
16412   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
16413   // all modes, including C++11, C++14 and C++17
16414   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
16415 }
16416 
16417 TEST_F(FormatTest, DoNotFormatLikelyXml) {
16418   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
16419   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
16420 }
16421 
16422 TEST_F(FormatTest, StructuredBindings) {
16423   // Structured bindings is a C++17 feature.
16424   // all modes, including C++11, C++14 and C++17
16425   verifyFormat("auto [a, b] = f();");
16426   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
16427   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
16428   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
16429   EXPECT_EQ("auto const volatile [a, b] = f();",
16430             format("auto  const   volatile[a, b] = f();"));
16431   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
16432   EXPECT_EQ("auto &[a, b, c] = f();",
16433             format("auto   &[  a  ,  b,c   ] = f();"));
16434   EXPECT_EQ("auto &&[a, b, c] = f();",
16435             format("auto   &&[  a  ,  b,c   ] = f();"));
16436   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
16437   EXPECT_EQ("auto const volatile &&[a, b] = f();",
16438             format("auto  const  volatile  &&[a, b] = f();"));
16439   EXPECT_EQ("auto const &&[a, b] = f();",
16440             format("auto  const   &&  [a, b] = f();"));
16441   EXPECT_EQ("const auto &[a, b] = f();",
16442             format("const  auto  &  [a, b] = f();"));
16443   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16444             format("const  auto   volatile  &&[a, b] = f();"));
16445   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16446             format("volatile  const  auto   &&[a, b] = f();"));
16447   EXPECT_EQ("const auto &&[a, b] = f();",
16448             format("const  auto  &&  [a, b] = f();"));
16449 
16450   // Make sure we don't mistake structured bindings for lambdas.
16451   FormatStyle PointerMiddle = getLLVMStyle();
16452   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16453   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16454   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16455   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16456   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16457   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16458   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16459   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16460   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16461   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16462   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16463   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16464   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16465 
16466   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16467             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16468   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16469             format("for (const auto   &   [a, b] : some_range) {\n}"));
16470   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16471             format("for (const auto[a, b] : some_range) {\n}"));
16472   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16473   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16474   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16475   EXPECT_EQ("auto const &[x, y](expr);",
16476             format("auto  const  &  [x,y]  (expr);"));
16477   EXPECT_EQ("auto const &&[x, y](expr);",
16478             format("auto  const  &&  [x,y]  (expr);"));
16479   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16480   EXPECT_EQ("auto const &[x, y]{expr};",
16481             format("auto  const  &  [x,y]  {expr};"));
16482   EXPECT_EQ("auto const &&[x, y]{expr};",
16483             format("auto  const  &&  [x,y]  {expr};"));
16484 
16485   format::FormatStyle Spaces = format::getLLVMStyle();
16486   Spaces.SpacesInSquareBrackets = true;
16487   verifyFormat("auto [ a, b ] = f();", Spaces);
16488   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16489   verifyFormat("auto &[ a, b ] = f();", Spaces);
16490   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16491   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16492 }
16493 
16494 TEST_F(FormatTest, FileAndCode) {
16495   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16496   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16497   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16498   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16499   EXPECT_EQ(FormatStyle::LK_ObjC,
16500             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16501   EXPECT_EQ(
16502       FormatStyle::LK_ObjC,
16503       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16504   EXPECT_EQ(FormatStyle::LK_ObjC,
16505             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16506   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16507   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16508   EXPECT_EQ(FormatStyle::LK_ObjC,
16509             guessLanguage("foo", "@interface Foo\n@end\n"));
16510   EXPECT_EQ(FormatStyle::LK_ObjC,
16511             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16512   EXPECT_EQ(
16513       FormatStyle::LK_ObjC,
16514       guessLanguage("foo.h",
16515                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16516   EXPECT_EQ(
16517       FormatStyle::LK_Cpp,
16518       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16519 }
16520 
16521 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16522   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16523   EXPECT_EQ(FormatStyle::LK_ObjC,
16524             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16525   EXPECT_EQ(FormatStyle::LK_Cpp,
16526             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16527   EXPECT_EQ(
16528       FormatStyle::LK_Cpp,
16529       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16530   EXPECT_EQ(FormatStyle::LK_ObjC,
16531             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16532   EXPECT_EQ(FormatStyle::LK_Cpp,
16533             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16534   EXPECT_EQ(FormatStyle::LK_ObjC,
16535             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16536   EXPECT_EQ(FormatStyle::LK_Cpp,
16537             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16538   EXPECT_EQ(FormatStyle::LK_Cpp,
16539             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16540   EXPECT_EQ(FormatStyle::LK_ObjC,
16541             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16542   EXPECT_EQ(FormatStyle::LK_Cpp,
16543             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16544   EXPECT_EQ(
16545       FormatStyle::LK_Cpp,
16546       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16547   EXPECT_EQ(
16548       FormatStyle::LK_Cpp,
16549       guessLanguage("foo.h",
16550                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16551   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16552 }
16553 
16554 TEST_F(FormatTest, GuessLanguageWithCaret) {
16555   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16556   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16557   EXPECT_EQ(FormatStyle::LK_ObjC,
16558             guessLanguage("foo.h", "int(^)(char, float);"));
16559   EXPECT_EQ(FormatStyle::LK_ObjC,
16560             guessLanguage("foo.h", "int(^foo)(char, float);"));
16561   EXPECT_EQ(FormatStyle::LK_ObjC,
16562             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16563   EXPECT_EQ(FormatStyle::LK_ObjC,
16564             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16565   EXPECT_EQ(
16566       FormatStyle::LK_ObjC,
16567       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16568 }
16569 
16570 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16571   // ASM symbolic names are identifiers that must be surrounded by [] without
16572   // space in between:
16573   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16574 
16575   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16576   verifyFormat(R"(//
16577 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16578 )");
16579 
16580   // A list of several ASM symbolic names.
16581   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16582 
16583   // ASM symbolic names in inline ASM with inputs and outputs.
16584   verifyFormat(R"(//
16585 asm("cmoveq %1, %2, %[result]"
16586     : [result] "=r"(result)
16587     : "r"(test), "r"(new), "[result]"(old));
16588 )");
16589 
16590   // ASM symbolic names in inline ASM with no outputs.
16591   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16592 }
16593 
16594 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16595   EXPECT_EQ(FormatStyle::LK_Cpp,
16596             guessLanguage("foo.h", "void f() {\n"
16597                                    "  asm (\"mov %[e], %[d]\"\n"
16598                                    "     : [d] \"=rm\" (d)\n"
16599                                    "       [e] \"rm\" (*e));\n"
16600                                    "}"));
16601   EXPECT_EQ(FormatStyle::LK_Cpp,
16602             guessLanguage("foo.h", "void f() {\n"
16603                                    "  _asm (\"mov %[e], %[d]\"\n"
16604                                    "     : [d] \"=rm\" (d)\n"
16605                                    "       [e] \"rm\" (*e));\n"
16606                                    "}"));
16607   EXPECT_EQ(FormatStyle::LK_Cpp,
16608             guessLanguage("foo.h", "void f() {\n"
16609                                    "  __asm (\"mov %[e], %[d]\"\n"
16610                                    "     : [d] \"=rm\" (d)\n"
16611                                    "       [e] \"rm\" (*e));\n"
16612                                    "}"));
16613   EXPECT_EQ(FormatStyle::LK_Cpp,
16614             guessLanguage("foo.h", "void f() {\n"
16615                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16616                                    "     : [d] \"=rm\" (d)\n"
16617                                    "       [e] \"rm\" (*e));\n"
16618                                    "}"));
16619   EXPECT_EQ(FormatStyle::LK_Cpp,
16620             guessLanguage("foo.h", "void f() {\n"
16621                                    "  asm (\"mov %[e], %[d]\"\n"
16622                                    "     : [d] \"=rm\" (d),\n"
16623                                    "       [e] \"rm\" (*e));\n"
16624                                    "}"));
16625   EXPECT_EQ(FormatStyle::LK_Cpp,
16626             guessLanguage("foo.h", "void f() {\n"
16627                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16628                                    "     : [d] \"=rm\" (d)\n"
16629                                    "       [e] \"rm\" (*e));\n"
16630                                    "}"));
16631 }
16632 
16633 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16634   EXPECT_EQ(FormatStyle::LK_Cpp,
16635             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16636   EXPECT_EQ(FormatStyle::LK_ObjC,
16637             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16638   EXPECT_EQ(
16639       FormatStyle::LK_Cpp,
16640       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16641   EXPECT_EQ(
16642       FormatStyle::LK_ObjC,
16643       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16644 }
16645 
16646 TEST_F(FormatTest, TypenameMacros) {
16647   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16648 
16649   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16650   FormatStyle Google = getGoogleStyleWithColumns(0);
16651   Google.TypenameMacros = TypenameMacros;
16652   verifyFormat("struct foo {\n"
16653                "  int bar;\n"
16654                "  TAILQ_ENTRY(a) bleh;\n"
16655                "};",
16656                Google);
16657 
16658   FormatStyle Macros = getLLVMStyle();
16659   Macros.TypenameMacros = TypenameMacros;
16660 
16661   verifyFormat("STACK_OF(int) a;", Macros);
16662   verifyFormat("STACK_OF(int) *a;", Macros);
16663   verifyFormat("STACK_OF(int const *) *a;", Macros);
16664   verifyFormat("STACK_OF(int *const) *a;", Macros);
16665   verifyFormat("STACK_OF(int, string) a;", Macros);
16666   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16667   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16668   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16669   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16670   verifyFormat("vector<LIST(uint64_t) *attr> x;", Macros);
16671   verifyFormat("vector<LIST(uint64_t) *const> f(LIST(uint64_t) *arg);", Macros);
16672 
16673   Macros.PointerAlignment = FormatStyle::PAS_Left;
16674   verifyFormat("STACK_OF(int)* a;", Macros);
16675   verifyFormat("STACK_OF(int*)* a;", Macros);
16676   verifyFormat("x = (STACK_OF(uint64_t))*a;", Macros);
16677   verifyFormat("x = (STACK_OF(uint64_t))&a;", Macros);
16678   verifyFormat("vector<STACK_OF(uint64_t)* attr> x;", Macros);
16679 }
16680 
16681 TEST_F(FormatTest, AtomicQualifier) {
16682   // Check that we treate _Atomic as a type and not a function call
16683   FormatStyle Google = getGoogleStyleWithColumns(0);
16684   verifyFormat("struct foo {\n"
16685                "  int a1;\n"
16686                "  _Atomic(a) a2;\n"
16687                "  _Atomic(_Atomic(int) *const) a3;\n"
16688                "};",
16689                Google);
16690   verifyFormat("_Atomic(uint64_t) a;");
16691   verifyFormat("_Atomic(uint64_t) *a;");
16692   verifyFormat("_Atomic(uint64_t const *) *a;");
16693   verifyFormat("_Atomic(uint64_t *const) *a;");
16694   verifyFormat("_Atomic(const uint64_t *) *a;");
16695   verifyFormat("_Atomic(uint64_t) a;");
16696   verifyFormat("_Atomic(_Atomic(uint64_t)) a;");
16697   verifyFormat("_Atomic(_Atomic(uint64_t)) a, b;");
16698   verifyFormat("for (_Atomic(uint64_t) *a = NULL; a;) {\n}");
16699   verifyFormat("_Atomic(uint64_t) f(_Atomic(uint64_t) *arg);");
16700 
16701   verifyFormat("_Atomic(uint64_t) *s(InitValue);");
16702   verifyFormat("_Atomic(uint64_t) *s{InitValue};");
16703   FormatStyle Style = getLLVMStyle();
16704   Style.PointerAlignment = FormatStyle::PAS_Left;
16705   verifyFormat("_Atomic(uint64_t)* s(InitValue);", Style);
16706   verifyFormat("_Atomic(uint64_t)* s{InitValue};", Style);
16707   verifyFormat("_Atomic(int)* a;", Style);
16708   verifyFormat("_Atomic(int*)* a;", Style);
16709   verifyFormat("vector<_Atomic(uint64_t)* attr> x;", Style);
16710 
16711   Style.SpacesInCStyleCastParentheses = true;
16712   Style.SpacesInParentheses = false;
16713   verifyFormat("x = ( _Atomic(uint64_t) )*a;", Style);
16714   Style.SpacesInCStyleCastParentheses = false;
16715   Style.SpacesInParentheses = true;
16716   verifyFormat("x = (_Atomic( uint64_t ))*a;", Style);
16717   verifyFormat("x = (_Atomic( uint64_t ))&a;", Style);
16718 }
16719 
16720 TEST_F(FormatTest, AmbersandInLamda) {
16721   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16722   FormatStyle AlignStyle = getLLVMStyle();
16723   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16724   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16725   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16726   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16727 }
16728 
16729 TEST_F(FormatTest, SpacesInConditionalStatement) {
16730   FormatStyle Spaces = getLLVMStyle();
16731   Spaces.SpacesInConditionalStatement = true;
16732   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16733   verifyFormat("if ( !a )\n  return;", Spaces);
16734   verifyFormat("if ( a )\n  return;", Spaces);
16735   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16736   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16737   verifyFormat("while ( a )\n  return;", Spaces);
16738   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16739   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16740   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16741   // Check that space on the left of "::" is inserted as expected at beginning
16742   // of condition.
16743   verifyFormat("while ( ::func() )\n  return;", Spaces);
16744 }
16745 
16746 TEST_F(FormatTest, AlternativeOperators) {
16747   // Test case for ensuring alternate operators are not
16748   // combined with their right most neighbour.
16749   verifyFormat("int a and b;");
16750   verifyFormat("int a and_eq b;");
16751   verifyFormat("int a bitand b;");
16752   verifyFormat("int a bitor b;");
16753   verifyFormat("int a compl b;");
16754   verifyFormat("int a not b;");
16755   verifyFormat("int a not_eq b;");
16756   verifyFormat("int a or b;");
16757   verifyFormat("int a xor b;");
16758   verifyFormat("int a xor_eq b;");
16759   verifyFormat("return this not_eq bitand other;");
16760   verifyFormat("bool operator not_eq(const X bitand other)");
16761 
16762   verifyFormat("int a and 5;");
16763   verifyFormat("int a and_eq 5;");
16764   verifyFormat("int a bitand 5;");
16765   verifyFormat("int a bitor 5;");
16766   verifyFormat("int a compl 5;");
16767   verifyFormat("int a not 5;");
16768   verifyFormat("int a not_eq 5;");
16769   verifyFormat("int a or 5;");
16770   verifyFormat("int a xor 5;");
16771   verifyFormat("int a xor_eq 5;");
16772 
16773   verifyFormat("int a compl(5);");
16774   verifyFormat("int a not(5);");
16775 
16776   /* FIXME handle alternate tokens
16777    * https://en.cppreference.com/w/cpp/language/operator_alternative
16778   // alternative tokens
16779   verifyFormat("compl foo();");     //  ~foo();
16780   verifyFormat("foo() <%%>;");      // foo();
16781   verifyFormat("void foo() <%%>;"); // void foo(){}
16782   verifyFormat("int a <:1:>;");     // int a[1];[
16783   verifyFormat("%:define ABC abc"); // #define ABC abc
16784   verifyFormat("%:%:");             // ##
16785   */
16786 }
16787 
16788 TEST_F(FormatTest, STLWhileNotDefineChed) {
16789   verifyFormat("#if defined(while)\n"
16790                "#define while EMIT WARNING C4005\n"
16791                "#endif // while");
16792 }
16793 
16794 TEST_F(FormatTest, OperatorSpacing) {
16795   FormatStyle Style = getLLVMStyle();
16796   Style.PointerAlignment = FormatStyle::PAS_Right;
16797   verifyFormat("Foo::operator*();", Style);
16798   verifyFormat("Foo::operator void *();", Style);
16799   verifyFormat("Foo::operator void **();", Style);
16800   verifyFormat("Foo::operator void *&();", Style);
16801   verifyFormat("Foo::operator void *&&();", Style);
16802   verifyFormat("Foo::operator()(void *);", Style);
16803   verifyFormat("Foo::operator*(void *);", Style);
16804   verifyFormat("Foo::operator*();", Style);
16805   verifyFormat("Foo::operator**();", Style);
16806   verifyFormat("Foo::operator&();", Style);
16807   verifyFormat("Foo::operator<int> *();", Style);
16808   verifyFormat("Foo::operator<Foo> *();", Style);
16809   verifyFormat("Foo::operator<int> **();", Style);
16810   verifyFormat("Foo::operator<Foo> **();", Style);
16811   verifyFormat("Foo::operator<int> &();", Style);
16812   verifyFormat("Foo::operator<Foo> &();", Style);
16813   verifyFormat("Foo::operator<int> &&();", Style);
16814   verifyFormat("Foo::operator<Foo> &&();", Style);
16815   verifyFormat("Foo::operator<int> *&();", Style);
16816   verifyFormat("Foo::operator<Foo> *&();", Style);
16817   verifyFormat("Foo::operator<int> *&&();", Style);
16818   verifyFormat("Foo::operator<Foo> *&&();", Style);
16819   verifyFormat("operator*(int (*)(), class Foo);", Style);
16820 
16821   verifyFormat("Foo::operator&();", Style);
16822   verifyFormat("Foo::operator void &();", Style);
16823   verifyFormat("Foo::operator()(void &);", Style);
16824   verifyFormat("Foo::operator&(void &);", Style);
16825   verifyFormat("Foo::operator&();", Style);
16826   verifyFormat("operator&(int (&)(), class Foo);", Style);
16827 
16828   verifyFormat("Foo::operator&&();", Style);
16829   verifyFormat("Foo::operator**();", Style);
16830   verifyFormat("Foo::operator void &&();", Style);
16831   verifyFormat("Foo::operator()(void &&);", Style);
16832   verifyFormat("Foo::operator&&(void &&);", Style);
16833   verifyFormat("Foo::operator&&();", Style);
16834   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16835   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16836   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16837                Style);
16838   verifyFormat("operator void **()", Style);
16839   verifyFormat("operator const FooRight<Object> &()", Style);
16840   verifyFormat("operator const FooRight<Object> *()", Style);
16841   verifyFormat("operator const FooRight<Object> **()", Style);
16842   verifyFormat("operator const FooRight<Object> *&()", Style);
16843   verifyFormat("operator const FooRight<Object> *&&()", Style);
16844 
16845   Style.PointerAlignment = FormatStyle::PAS_Left;
16846   verifyFormat("Foo::operator*();", Style);
16847   verifyFormat("Foo::operator**();", Style);
16848   verifyFormat("Foo::operator void*();", Style);
16849   verifyFormat("Foo::operator void**();", Style);
16850   verifyFormat("Foo::operator void*&();", Style);
16851   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16852   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16853   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16854   verifyFormat("Foo::operator()(void*);", Style);
16855   verifyFormat("Foo::operator*(void*);", Style);
16856   verifyFormat("Foo::operator*();", Style);
16857   verifyFormat("Foo::operator<int>*();", Style);
16858   verifyFormat("Foo::operator<Foo>*();", Style);
16859   verifyFormat("Foo::operator<int>**();", Style);
16860   verifyFormat("Foo::operator<Foo>**();", Style);
16861   verifyFormat("Foo::operator<Foo>*&();", Style);
16862   verifyFormat("Foo::operator<int>&();", Style);
16863   verifyFormat("Foo::operator<Foo>&();", Style);
16864   verifyFormat("Foo::operator<int>&&();", Style);
16865   verifyFormat("Foo::operator<Foo>&&();", Style);
16866   verifyFormat("Foo::operator<int>*&();", Style);
16867   verifyFormat("Foo::operator<Foo>*&();", Style);
16868   verifyFormat("operator*(int (*)(), class Foo);", Style);
16869 
16870   verifyFormat("Foo::operator&();", Style);
16871   verifyFormat("Foo::operator void&();", Style);
16872   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16873   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16874   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16875   verifyFormat("Foo::operator()(void&);", Style);
16876   verifyFormat("Foo::operator&(void&);", Style);
16877   verifyFormat("Foo::operator&();", Style);
16878   verifyFormat("operator&(int (&)(), class Foo);", Style);
16879 
16880   verifyFormat("Foo::operator&&();", Style);
16881   verifyFormat("Foo::operator void&&();", Style);
16882   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16883   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16884   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16885   verifyFormat("Foo::operator()(void&&);", Style);
16886   verifyFormat("Foo::operator&&(void&&);", Style);
16887   verifyFormat("Foo::operator&&();", Style);
16888   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16889   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16890   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16891                Style);
16892   verifyFormat("operator void**()", Style);
16893   verifyFormat("operator const FooLeft<Object>&()", Style);
16894   verifyFormat("operator const FooLeft<Object>*()", Style);
16895   verifyFormat("operator const FooLeft<Object>**()", Style);
16896   verifyFormat("operator const FooLeft<Object>*&()", Style);
16897   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16898 
16899   // PR45107
16900   verifyFormat("operator Vector<String>&();", Style);
16901   verifyFormat("operator const Vector<String>&();", Style);
16902   verifyFormat("operator foo::Bar*();", Style);
16903   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16904   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16905                Style);
16906 
16907   Style.PointerAlignment = FormatStyle::PAS_Middle;
16908   verifyFormat("Foo::operator*();", Style);
16909   verifyFormat("Foo::operator void *();", Style);
16910   verifyFormat("Foo::operator()(void *);", Style);
16911   verifyFormat("Foo::operator*(void *);", Style);
16912   verifyFormat("Foo::operator*();", Style);
16913   verifyFormat("operator*(int (*)(), class Foo);", Style);
16914 
16915   verifyFormat("Foo::operator&();", Style);
16916   verifyFormat("Foo::operator void &();", Style);
16917   verifyFormat("Foo::operator()(void &);", Style);
16918   verifyFormat("Foo::operator&(void &);", Style);
16919   verifyFormat("Foo::operator&();", Style);
16920   verifyFormat("operator&(int (&)(), class Foo);", Style);
16921 
16922   verifyFormat("Foo::operator&&();", Style);
16923   verifyFormat("Foo::operator void &&();", Style);
16924   verifyFormat("Foo::operator()(void &&);", Style);
16925   verifyFormat("Foo::operator&&(void &&);", Style);
16926   verifyFormat("Foo::operator&&();", Style);
16927   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16928 }
16929 
16930 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
16931   FormatStyle Style = getLLVMStyle();
16932   // PR46157
16933   verifyFormat("foo(operator+, -42);", Style);
16934   verifyFormat("foo(operator++, -42);", Style);
16935   verifyFormat("foo(operator--, -42);", Style);
16936   verifyFormat("foo(-42, operator--);", Style);
16937   verifyFormat("foo(-42, operator, );", Style);
16938   verifyFormat("foo(operator, , -42);", Style);
16939 }
16940 
16941 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
16942   FormatStyle Style = getLLVMStyle();
16943   Style.WhitespaceSensitiveMacros.push_back("FOO");
16944 
16945   // Don't use the helpers here, since 'mess up' will change the whitespace
16946   // and these are all whitespace sensitive by definition
16947   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
16948             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
16949   EXPECT_EQ(
16950       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
16951       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
16952   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
16953             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
16954   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
16955             "       Still=Intentional);",
16956             format("FOO(String-ized&Messy+But,: :\n"
16957                    "       Still=Intentional);",
16958                    Style));
16959   Style.AlignConsecutiveAssignments = true;
16960   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
16961             "       Still=Intentional);",
16962             format("FOO(String-ized=&Messy+But,: :\n"
16963                    "       Still=Intentional);",
16964                    Style));
16965 
16966   Style.ColumnLimit = 21;
16967   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
16968             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
16969 }
16970 
16971 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
16972   // These tests are not in NamespaceFixer because that doesn't
16973   // test its interaction with line wrapping
16974   FormatStyle Style = getLLVMStyle();
16975   Style.ColumnLimit = 80;
16976   verifyFormat("namespace {\n"
16977                "int i;\n"
16978                "int j;\n"
16979                "} // namespace",
16980                Style);
16981 
16982   verifyFormat("namespace AAA {\n"
16983                "int i;\n"
16984                "int j;\n"
16985                "} // namespace AAA",
16986                Style);
16987 
16988   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
16989             "int i;\n"
16990             "int j;\n"
16991             "} // namespace Averyveryveryverylongnamespace",
16992             format("namespace Averyveryveryverylongnamespace {\n"
16993                    "int i;\n"
16994                    "int j;\n"
16995                    "}",
16996                    Style));
16997 
16998   EXPECT_EQ(
16999       "namespace "
17000       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
17001       "    went::mad::now {\n"
17002       "int i;\n"
17003       "int j;\n"
17004       "} // namespace\n"
17005       "  // "
17006       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
17007       "went::mad::now",
17008       format("namespace "
17009              "would::it::save::you::a::lot::of::time::if_::i::"
17010              "just::gave::up::and_::went::mad::now {\n"
17011              "int i;\n"
17012              "int j;\n"
17013              "}",
17014              Style));
17015 
17016   // This used to duplicate the comment again and again on subsequent runs
17017   EXPECT_EQ(
17018       "namespace "
17019       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
17020       "    went::mad::now {\n"
17021       "int i;\n"
17022       "int j;\n"
17023       "} // namespace\n"
17024       "  // "
17025       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
17026       "went::mad::now",
17027       format("namespace "
17028              "would::it::save::you::a::lot::of::time::if_::i::"
17029              "just::gave::up::and_::went::mad::now {\n"
17030              "int i;\n"
17031              "int j;\n"
17032              "} // namespace\n"
17033              "  // "
17034              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
17035              "and_::went::mad::now",
17036              Style));
17037 }
17038 
17039 TEST_F(FormatTest, LikelyUnlikely) {
17040   FormatStyle Style = getLLVMStyle();
17041 
17042   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17043                "  return 29;\n"
17044                "}",
17045                Style);
17046 
17047   verifyFormat("if (argc > 5) [[likely]] {\n"
17048                "  return 29;\n"
17049                "}",
17050                Style);
17051 
17052   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17053                "  return 29;\n"
17054                "} else [[likely]] {\n"
17055                "  return 42;\n"
17056                "}\n",
17057                Style);
17058 
17059   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17060                "  return 29;\n"
17061                "} else if (argc > 10) [[likely]] {\n"
17062                "  return 99;\n"
17063                "} else {\n"
17064                "  return 42;\n"
17065                "}\n",
17066                Style);
17067 
17068   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
17069                "  return 29;\n"
17070                "}",
17071                Style);
17072 }
17073 
17074 TEST_F(FormatTest, LLVMDefaultStyle) {
17075   FormatStyle Style = getLLVMStyle();
17076   verifyFormat("extern \"C\" {\n"
17077                "int foo();\n"
17078                "}",
17079                Style);
17080 }
17081 TEST_F(FormatTest, GNUDefaultStyle) {
17082   FormatStyle Style = getGNUStyle();
17083   verifyFormat("extern \"C\"\n"
17084                "{\n"
17085                "  int foo ();\n"
17086                "}",
17087                Style);
17088 }
17089 TEST_F(FormatTest, MozillaDefaultStyle) {
17090   FormatStyle Style = getMozillaStyle();
17091   verifyFormat("extern \"C\"\n"
17092                "{\n"
17093                "  int foo();\n"
17094                "}",
17095                Style);
17096 }
17097 TEST_F(FormatTest, GoogleDefaultStyle) {
17098   FormatStyle Style = getGoogleStyle();
17099   verifyFormat("extern \"C\" {\n"
17100                "int foo();\n"
17101                "}",
17102                Style);
17103 }
17104 TEST_F(FormatTest, ChromiumDefaultStyle) {
17105   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
17106   verifyFormat("extern \"C\" {\n"
17107                "int foo();\n"
17108                "}",
17109                Style);
17110 }
17111 TEST_F(FormatTest, MicrosoftDefaultStyle) {
17112   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
17113   verifyFormat("extern \"C\"\n"
17114                "{\n"
17115                "    int foo();\n"
17116                "}",
17117                Style);
17118 }
17119 TEST_F(FormatTest, WebKitDefaultStyle) {
17120   FormatStyle Style = getWebKitStyle();
17121   verifyFormat("extern \"C\" {\n"
17122                "int foo();\n"
17123                "}",
17124                Style);
17125 }
17126 } // namespace
17127 } // namespace format
17128 } // namespace clang
17129